private def setUpStandardSSH()

in src/main/scala/com/gu/ssm/Main.scala [49:85]
37 lines of code
4 McCabe index (conditional complexity)

  private def setUpStandardSSH(
    awsClients: AWSClients,
    executionTarget: ExecutionTarget,
    user: String,
    sism: SingleInstanceSelectionMode,
    onlyUsePrivateIP: Boolean,
    rawOutput: Boolean,
    targetInstancePortNumberOpt: Option[Int],
    preferredAlgs: List[String],
    useAgent: Option[Boolean],
    profile: Option[String],
    region: Region,
    tunnelThroughSystemsManager: Boolean,
    tunnelTarget: Option[TunnelTarget]): ProgramResult = {
    val fProgramResult = for {
      config <- IO.getSSMConfig(awsClients.ec2Client, awsClients.stsClient, executionTarget)
      sshArtifacts <- Attempt.fromEither(SSH.createKey())
      (privateKeyFile, publicKey) = sshArtifacts
      addPublicKeyCommand = SSH.addTaintedCommand(config.name) + SSH.addPublicKeyCommand(user, publicKey) + SSH.outputHostKeysCommand()
      resolvedTunnelTarget <- Attempt.sequence(tunnelTarget.toList.map {
        case t: TunnelTargetWithRDSTags => IO.resolveRDSTunnelTarget(t, awsClients.rdsClient)
        case t: TunnelTargetWithHostName => Attempt.Right(t)
      })
      removePublicKeyCommand = SSH.removePublicKeyCommand(user, publicKey)
      instance <- Attempt.fromEither(Logic.getSSHInstance(config.targets, sism))
      _ <- IO.tagAsTainted(instance.id, config.name, awsClients.ec2Client)
      result <- IO.executeOnInstance(instance.id, config.name, addPublicKeyCommand, awsClients.ssmClient)
      _ <- IO.executeOnInstanceAsync(instance.id, config.name, removePublicKeyCommand, awsClients.ssmClient)
      hostKey <- Attempt.fromEither(Logic.getHostKeyEntry(result, preferredAlgs))
      address <- Attempt.fromEither(Logic.getAddress(instance, onlyUsePrivateIP))
      hostKeyFile <- SSH.writeHostKey((address, hostKey))
    } yield {
      SSH.sshCmdStandard(rawOutput)(privateKeyFile, instance, user, address, targetInstancePortNumberOpt, Some(hostKeyFile), useAgent, profile, region, tunnelThroughSystemsManager, resolvedTunnelTarget.headOption)
    }
    val programResult = Await.result(fProgramResult.asFuture, Duration.Inf)
    ProgramResult.convertErrorToResult(programResult.map(UI.sshOutput(rawOutput)))
  }