Function StartReverseForward

pkg/devspace/tunnel/client.go:190–301

(ctx context.Context, reader io.ReadCloser, writer io.WriteCloser, tunnels []*latest.PortMapping, stopChan chan struct{}, namespace string, name string, log logpkg.Logger)

}

func StartReverseForward(ctx context.Context, reader io.ReadCloser, writer io.WriteCloser, tunnels []*latest.PortMapping, stopChan chan struct{}, namespace string, name string, log logpkg.Logger) error {
	scheme := "TCP"
	closeStreams := make([]chan bool, len(tunnels))
	defer func() {
		for _, c := range closeStreams {
			if c == nil {
				continue
			}

			close(c)
		}
	}()

	// Create client
	conn, err := util.NewClientConnection(reader, writer)
	if err != nil {
		return errors.Wrap(err, "new client connection")
	}

	client := remote.NewTunnelClient(conn)
	logFile := logpkg.GetFileLogger("reverse-portforwarding")

	errorsChan := make(chan error, 2*len(tunnels)+1)
	closeStream := make(chan struct{})
	defer close(closeStream)
	go func() {
		for {
			select {
			case <-ctx.Done():
				return
			case <-closeStream:
				return
			case <-stopChan:
				return
			case <-time.After(time.Second * 20):
				ctx, cancel := context.WithTimeout(ctx, time.Second*20)
				_, err := client.Ping(ctx, &remote.Empty{})
				cancel()
				if err != nil {
					errorsChan <- errors.Wrap(err, "ping connection")
					return
				}
			}
		}
	}()

	for i, portMapping := range tunnels {
		if portMapping.Port == "" {
			return fmt.Errorf("local port cannot be undefined")
		}

		mappings, err := portforward.ParsePorts([]string{portMapping.Port})
		if err != nil {
			return fmt.Errorf("error parsing port %s: %v", portMapping.Port, err)
		}

		localPort := mappings[0].Local
		remotePort := mappings[0].Remote