TASK: prevent cache misses from crashing the whole application

Author: sachera

dummypathmapper/dummypathmapper.go

@@ -33,11 +33,11 @@ func (p *PathMapper) Initialize(c *config.Config, l *logger.Logger, m *pathmappi
 }
 
 // ApplyMappingToTextProtocol change file path in xDebug text protocol
-func (p *PathMapper) ApplyMappingToTextProtocol(message []byte) []byte {
-	return message
+func (p *PathMapper) ApplyMappingToTextProtocol(message []byte) ([]byte, error) {
+	return message, nil
 }
 
 // ApplyMappingToXML change file path in xDebug XML protocol
-func (p *PathMapper) ApplyMappingToXML(message []byte) []byte {
-	return message
+func (p *PathMapper) ApplyMappingToXML(message []byte) ([]byte, error) {
+	return message, nil
 }

errorhandler/errorhanlder.go

@@ -6,7 +6,6 @@ package flowpathmapper
 
 import (
 	"github.com/dfeyer/flow-debugproxy/config"
-	"github.com/dfeyer/flow-debugproxy/errorhandler"
 	"github.com/dfeyer/flow-debugproxy/logger"
 	"github.com/dfeyer/flow-debugproxy/pathmapperfactory"
 	"github.com/dfeyer/flow-debugproxy/pathmapping"
@@ -16,9 +15,9 @@ import (
 	"io/ioutil"
 	"os"
 	"regexp"
+	"runtime"
 	"strconv"
 	"strings"
-	"runtime"
 )
 
 const (
@@ -63,32 +62,34 @@ func (p *PathMapper) Initialize(c *config.Config, l *logger.Logger, m *pathmappi
 }
 
 // ApplyMappingToTextProtocol change file path in xDebug text protocol
-func (p *PathMapper) ApplyMappingToTextProtocol(message []byte) []byte {
-	return p.doTextPathMapping(message)
+func (p *PathMapper) ApplyMappingToTextProtocol(message []byte) ([]byte, error) {
+	return p.doTextPathMapping(message), nil
 }
 
 // ApplyMappingToXML change file path in xDebug XML protocol
-func (p *PathMapper) ApplyMappingToXML(message []byte) []byte {
+func (p *PathMapper) ApplyMappingToXML(message []byte) ([]byte, error) {
 	message = p.doXMLPathMapping(message)
 
 	// update xml length count
 	s := strings.Split(string(message), "\x00")
 	i, err := strconv.Atoi(s[0])
-	errorhandler.PanicHandling(err, p.logger)
+	if err != nil {
+		return nil, err
+	}
 	l := len(s[1])
 	if i != l {
 		message = bytes.Replace(message, []byte(strconv.Itoa(i)), []byte(strconv.Itoa(l)), 1)
 	}
 
-	return message
+	return message, nil
 }
 
 func (p *PathMapper) doTextPathMapping(message []byte) []byte {
 	var processedMapping = map[string]string{}
 	for _, match := range regexpPhpFile.FindAllStringSubmatch(string(message), -1) {
 		originalPath := match[1]
 		if runtime.GOOS == "windows" {
-			originalPath = strings.Replace(originalPath,"//","", 1)
+			originalPath = strings.Replace(originalPath, "//", "", 1)
 		}
 		path := p.mapPath(originalPath)
 		p.logger.Debug("doTextPathMapping %s >>> %s", path, originalPath)
@@ -183,7 +184,10 @@ func (p *PathMapper) readOriginalPathFromCache(path, basePath string) string {
 	}
 	p.logger.Debug("readOriginalPathFromCache %s", localPath)
 	dat, err := ioutil.ReadFile(localPath)
-	errorhandler.PanicHandling(err, p.logger)
+	if err != nil {
+		p.logger.Warn(err.Error())
+		return localPath
+	}
 	match := regexpPathAndFilename.FindStringSubmatch(string(dat))
 	if len(match) == 2 {
 		originalPath := match[1]

flowpathmapper/flowpathmapper.go

@@ -5,9 +5,10 @@
 package main
 
 import (
+	golog "log"
+
 	"github.com/dfeyer/flow-debugproxy/config"
 
-	"github.com/dfeyer/flow-debugproxy/errorhandler"
 	"github.com/dfeyer/flow-debugproxy/logger"
 	"github.com/dfeyer/flow-debugproxy/pathmapperfactory"
 	"github.com/dfeyer/flow-debugproxy/pathmapping"
@@ -84,13 +85,20 @@ func main() {
 			Config: c,
 		}
 
-		laddr, raddr, listener := setupNetworkConnection(cli.String("xdebug"), cli.String("ide"), log)
+		laddr, raddr, listener, err := setupNetworkConnection(cli.String("xdebug"), cli.String("ide"))
+		if err != nil {
+			log.Warn(err.Error())
+			os.Exit(1)
+		}
 
 		log.Info("Debugger from %v\nIDE      from %v\n", laddr, raddr)
 
 		pathMapping := &pathmapping.PathMapping{}
 		pathMapper, err := pathmapperfactory.Create(c, pathMapping, log)
-		errorhandler.PanicHandling(err, log)
+		if err != nil {
+			log.Warn(err.Error())
+			os.Exit(1)
+		}
 
 		for {
 			conn, err := listener.AcceptTCP()
@@ -109,18 +117,28 @@ func main() {
 		}
 	}
 
-	app.Run(os.Args)
+	err := app.Run(os.Args)
+	if err != nil {
+		golog.Fatal(err)
+		return
+	}
 }
 
-func setupNetworkConnection(xdebugAddr string, ideAddr string, log *logger.Logger) (*net.TCPAddr, *net.TCPAddr, *net.TCPListener) {
+func setupNetworkConnection(xdebugAddr string, ideAddr string) (*net.TCPAddr, *net.TCPAddr, *net.TCPListener, error) {
 	laddr, err := net.ResolveTCPAddr("tcp", xdebugAddr)
-	errorhandler.PanicHandling(err, log)
+	if err != nil {
+		return nil, nil, nil, err
+	}
 
 	raddr, err := net.ResolveTCPAddr("tcp", ideAddr)
-	errorhandler.PanicHandling(err, log)
+	if err != nil {
+		return nil, nil, nil, err
+	}
 
 	listener, err := net.ListenTCP("tcp", laddr)
-	errorhandler.PanicHandling(err, log)
+	if err != nil {
+		return nil, nil, nil, err
+	}
 
-	return laddr, raddr, listener
+	return laddr, raddr, listener, nil
 }

main.go

@@ -9,10 +9,10 @@ import (
 	"github.com/dfeyer/flow-debugproxy/logger"
 	"github.com/dfeyer/flow-debugproxy/pathmapping"
 
+	"bytes"
 	"fmt"
 	"io"
 	"net"
-	"bytes"
 	"strconv"
 )
 
@@ -21,8 +21,8 @@ const h = "%s"
 // XDebugProcessorPlugin process message in xDebug protocol
 type XDebugProcessorPlugin interface {
 	Initialize(c *config.Config, l *logger.Logger, m *pathmapping.PathMapping)
-	ApplyMappingToTextProtocol(message []byte) []byte
-	ApplyMappingToXML(message []byte) []byte
+	ApplyMappingToTextProtocol(message []byte) ([]byte, error)
+	ApplyMappingToXML(message []byte) ([]byte, error)
 }
 
 // Proxy represents a pair of connections and their state
@@ -135,18 +135,30 @@ func (p *Proxy) pipe(src, dst *net.TCPConn) {
 		}
 		// extract command name
 		if isFromDebugger {
-			b = p.PathMapper.ApplyMappingToXML(b)
+			b, err = p.PathMapper.ApplyMappingToXML(b)
+			if p.handleError(err, dst) {
+				return
+			}
 			// post processors
 			for _, d := range p.postProcessors {
 				processor = d
-				b = processor.ApplyMappingToXML(b)
+				b, err = processor.ApplyMappingToXML(b)
+				if p.handleError(err, dst) {
+					return
+				}
 			}
 		} else {
-			b = p.PathMapper.ApplyMappingToTextProtocol(b)
+			b, err = p.PathMapper.ApplyMappingToTextProtocol(b)
+			if p.handleError(err, dst) {
+				return
+			}
 			// post processors
 			for _, d := range p.postProcessors {
 				processor = d
-				b = processor.ApplyMappingToTextProtocol(b)
+				b, err = processor.ApplyMappingToTextProtocol(b)
+				if p.handleError(err, dst) {
+					return
+				}
 			}
 		}
 
@@ -184,4 +196,4 @@ func (p *Proxy) handleError(err error, ch *net.TCPConn) bool {
 	}
 
 	return false
-}
+}