Function startSSHWithRestart

pkg/devspace/services/ssh/ssh.go:147–229

(ctx devspacecontext.Context, arch, addr, sshHost string, selector targetselector.TargetSelector, parent *tomb.Tomb)

}

func startSSHWithRestart(ctx devspacecontext.Context, arch, addr, sshHost string, selector targetselector.TargetSelector, parent *tomb.Tomb) error {
	if ctx.IsDone() {
		return nil
	}

	// find target container
	container, err := selector.SelectSingleContainer(ctx.Context(), ctx.KubeClient(), ctx.Log())
	if err != nil {
		return errors.Wrap(err, "error selecting container")
	} else if container == nil {
		return nil
	}

	// make sure the DevSpace helper binary is injected
	err = inject.InjectDevSpaceHelper(ctx.Context(), ctx.KubeClient(), container.Pod, container.Container.Name, arch, ctx.Log())
	if err != nil {
		return err
	}

	// get host key
	hostKey, err := getHostKey()
	if err != nil {
		return errors.Wrap(err, "generate host key")
	}

	// get public key
	publicKey, err := getPublicKey()
	if err != nil {
		return errors.Wrap(err, "generate key pair")
	}

	// get command
	command := []string{inject.DevSpaceHelperContainerPath, "ssh", "--authorized-key", publicKey, "--host-key", hostKey}
	if addr != "" {
		command = append(command, "--address", addr)
	}

	// start ssh server
	parent.Go(func() error {
		writer := ctx.Log().Writer(logrus.DebugLevel, false)
		defer writer.Close()
		for !ctx.IsDone() {
			buffer := &bytes.Buffer{}
			multiWriter := io.MultiWriter(writer, buffer)
			err = ctx.KubeClient().ExecStream(ctx.Context(), &kubectl.ExecStreamOptions{
				Pod:         container.Pod,
				Container:   container.Container.Name,
				Command:     command,
				Stdout:      multiWriter,
				Stderr:      multiWriter,
				SubResource: kubectl.SubResourceExec,
			})
			if err != nil {
				select {
				case <-ctx.Context().Done():
					return nil
				case <-time.After(time.Second * 2):
					// check if context is done