TASK: listen to multiple ports and associate a context with each port listened to

Author: Andreas Sacher

Dockerfile

@@ -22,11 +22,13 @@ COPY --from=build-env /app/flow-debugproxy /app/
 
 ENV ADDITIONAL_ARGS ""
 
-ENV XDEBUG_PORT 9010
+ENV XDEBUG 9003:Development
 
-ENV IDE_IP 127.0.0.1
-ENV IDE_PORT 9000
+ENV IDE_IP host.docker.internal
+ENV IDE_PORT 9010
 
 ENV FRAMEWORK "flow"
 
-ENTRYPOINT ["sh", "-c", "./flow-debugproxy --xdebug 0.0.0.0:${XDEBUG_PORT} --framework ${FRAMEWORK} --ide ${IDE_IP}:${IDE_PORT} ${ADDITIONAL_ARGS}"]
+ENV LOCAL_ROOT ""
+
+ENTRYPOINT ["sh", "-c", "./flow-debugproxy --xdebug ${XDEBUG} --framework ${FRAMEWORK} --ide ${IDE_IP}:${IDE_PORT} --localroot \"${LOCAL_ROOT}\" ${ADDITIONAL_ARGS}"]

main.go

@@ -5,6 +5,7 @@
 package main
 
 import (
+	"fmt"
 	golog "log"
 
 	"github.com/dfeyer/flow-debugproxy/config"
@@ -34,19 +35,14 @@ func main() {
 	app.Flags = []cli.Flag{
 		&cli.StringFlag{
 			Name:  "xdebug, l",
-			Value: "127.0.0.1:9000",
+			Value: "Development:9003",
 			Usage: "Listen address IP and port number",
 		},
 		&cli.StringFlag{
 			Name:  "ide, I",
 			Value: "127.0.0.1:9010",
 			Usage: "Bind address IP and port number",
 		},
-		&cli.StringFlag{
-			Name:  "context, c",
-			Value: "Development",
-			Usage: "The context to run as",
-		},
 		&cli.StringFlag{
 			Name:  "localroot, r",
 			Value: "",
@@ -73,7 +69,7 @@ func main() {
 
 	app.Action = func(cli *cli.Context) error {
 		c := &config.Config{
-			Context:     cli.String("context"),
+			Context:     "",
 			Framework:   cli.String("framework"),
 			LocalRoot:   strings.TrimRight(cli.String("localroot"), "/"),
 			Verbose:     cli.Bool("verbose") || cli.Bool("vv"),
@@ -85,43 +81,58 @@ func main() {
 			Config: c,
 		}
 
-		laddr, raddr, listener, err := setupNetworkConnection(cli.String("xdebug"), cli.String("ide"))
+		listener, raddr, err := setupNetworkConnection(strings.Split(cli.String("xdebug"), ","), cli.String("ide"))
 		if err != nil {
 			log.Warn(err.Error())
 			os.Exit(1)
 		}
 
-		log.Info("Debugger from %v", laddr)
+		for _, listenerWithContext := range listener {
+			log.Info("Debugger from %v for context %v", listenerWithContext.addr, listenerWithContext.context)
+		}
 		log.Info("IDE      from %v", raddr)
 		if c.Verbose {
-			log.Info("Context       %v", c.Context)
 			log.Info("Framework     %v", c.Framework)
 			log.Info("Local Root    %v", c.LocalRoot)
 			log.Info("Verbose       %v", c.Verbose)
 			log.Info("Very Verbose  %v", c.VeryVerbose)
 			log.Info("Debug         %v", c.Debug)
 		}
 
-		pathMapping := &pathmapping.PathMapping{}
-		pathMapper, err := pathmapperfactory.Create(c, pathMapping, log)
-		if err != nil {
-			log.Warn(err.Error())
-			os.Exit(1)
-		}
+		connections := make(chan *xdebugproxy.Proxy)
+		for _, listenerWithContext := range listener {
+			listenerWithContext := listenerWithContext
+			originalConfig := *c
+			proxyConfig := originalConfig // copy config
+			proxyConfig.Context = listenerWithContext.context
 
-		for {
-			conn, err := listener.AcceptTCP()
+			pathMapping := &pathmapping.PathMapping{}
+			pathMapper, err := pathmapperfactory.Create(&proxyConfig, pathMapping, log)
 			if err != nil {
-				log.Warn("Failed to accept connection '%s'\n", err)
-				continue
+				log.Warn(err.Error())
+				os.Exit(1)
 			}
 
-			proxy := &xdebugproxy.Proxy{
-				Lconn:      conn,
-				Raddr:      raddr,
-				PathMapper: pathMapper,
-				Config:     c,
-			}
+			go func() {
+				for {
+					conn, err := listenerWithContext.listener.AcceptTCP()
+					if err != nil {
+						log.Warn("Failed to accept connection '%s'\n", err)
+						continue
+					}
+
+					connections <- &xdebugproxy.Proxy{
+						Lconn:      conn,
+						Raddr:      raddr,
+						PathMapper: pathMapper,
+						Config:     &proxyConfig,
+					}
+				}
+			}()
+		}
+
+		for {
+			proxy := <-connections
 			go proxy.Start()
 		}
 	}
@@ -133,21 +144,49 @@ func main() {
 	}
 }
 
-func setupNetworkConnection(xdebugAddr string, ideAddr string) (*net.TCPAddr, *net.TCPAddr, *net.TCPListener, error) {
-	laddr, err := net.ResolveTCPAddr("tcp", xdebugAddr)
-	if err != nil {
-		return nil, nil, nil, err
+type listenerWithContext struct {
+	addr     *net.TCPAddr
+	listener *net.TCPListener
+	context  string
+}
+
+func splitContextAndPort(contextWithPort string) (string, string, error) {
+	contextAndPort := strings.Split(contextWithPort, ":")
+	if len(contextAndPort) != 2 {
+		return "", "", fmt.Errorf("could not parse port and context information '%s'", contextWithPort)
 	}
+	return contextAndPort[0], contextAndPort[1], nil
+}
 
-	raddr, err := net.ResolveTCPAddr("tcp", ideAddr)
-	if err != nil {
-		return nil, nil, nil, err
+func setupNetworkConnection(xdebugAddr []string, ideAddr string) ([]*listenerWithContext, *net.TCPAddr, error) {
+	listener := make([]*listenerWithContext, 0, len(xdebugAddr))
+	for _, portWithContext := range xdebugAddr {
+		context, portStr, err := splitContextAndPort(portWithContext)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		addr, err := net.ResolveTCPAddr("tcp", "0.0.0.0:"+portStr)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		l, err := net.ListenTCP("tcp", addr)
+		if err != nil {
+			return nil, nil, err
+		}
+
+		listener = append(listener, &listenerWithContext{
+			addr:     addr,
+			listener: l,
+			context:  context,
+		})
 	}
 
-	listener, err := net.ListenTCP("tcp", laddr)
+	raddr, err := net.ResolveTCPAddr("tcp", ideAddr)
 	if err != nil {
-		return nil, nil, nil, err
+		return nil, nil, err
 	}
 
-	return laddr, raddr, listener, nil
+	return listener, raddr, nil
 }

xdebugproxy/xdebugproxy.go

@@ -60,7 +60,7 @@ func (p *Proxy) Start() {
 	defer close(p.pipeErrors)
 
 	// display both ends
-	p.log("Opened %s >>> %s", p.Lconn.RemoteAddr().String(), p.rconn.RemoteAddr().String())
+	p.log("Opened %s >>> %s -- context %s", p.Lconn.RemoteAddr().String(), p.rconn.RemoteAddr().String(), p.Config.Context)
 	// bidirectional copy
 	go p.pipe(p.Lconn, p.rconn)
 	go p.pipe(p.rconn, p.Lconn)