Updated plugin interface

- Updated plugin interface to support static path routing
- Added autosave for statistic data (workaround for #561)

example/plugins/debugger/main.go

@@ -9,8 +9,9 @@ import (
 )
 
 const (
-	PLUGIN_ID = "org.aroz.zoraxy.debugger"
-	UI_PATH   = "/debug"
+	PLUGIN_ID              = "org.aroz.zoraxy.debugger"
+	UI_PATH                = "/debug"
+	STATIC_CAPTURE_INGRESS = "/s_capture"
 )
 
 func main() {
@@ -28,15 +29,15 @@ func main() {
 		VersionMinor:  0,
 		VersionPatch:  0,
 
-		GlobalCapturePaths: []plugin.CaptureRule{
+		StaticCapturePaths: []plugin.StaticCaptureRule{
 			{
-				CapturePath:     "/debug_test", //Capture all traffic of all HTTP proxy rule
-				IncludeSubPaths: true,
+				CapturePath: "/test_a",
+			},
+			{
+				CapturePath: "/test_b",
 			},
 		},
-		GlobalCaptureIngress: "",
-		AlwaysCapturePaths:   []plugin.CaptureRule{},
-		AlwaysCaptureIngress: "",
+		StaticCaptureIngress: "/s_capture",
 
 		UIPath: UI_PATH,
 
@@ -50,21 +51,42 @@ func main() {
 		panic(err)
 	}
 
-	// Register the shutdown handler
-	plugin.RegisterShutdownHandler(func() {
-		// Do cleanup here if needed
-		fmt.Println("Debugger Terminated")
-	})
+	//Create a path handler for the capture paths
+	pathRouter := plugin.NewPathRouter()
+	pathRouter.SetDebugPrintMode(true)
+	pathRouter.RegisterPathHandler("/test_a", http.HandlerFunc(HandleCaptureA))
+	pathRouter.RegisterPathHandler("/test_b", http.HandlerFunc(HandleCaptureB))
+	pathRouter.SetDefaultHandler(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		//In theory this should never be called
+		//but just in case the request is not captured by the path handlers
+		//this will be the fallback handler
+		w.Header().Set("Content-Type", "text/html")
+		w.Write([]byte("This request is captured by the default handler!<br>Request URI: " + r.URL.String()))
+	}))
+	pathRouter.RegisterHandle(STATIC_CAPTURE_INGRESS, http.DefaultServeMux)
 
 	http.HandleFunc(UI_PATH+"/", RenderDebugUI)
-	http.HandleFunc("/gcapture", HandleIngressCapture)
 	fmt.Println("Debugger started at http://127.0.0.1:" + strconv.Itoa(runtimeCfg.Port))
 	http.ListenAndServe("127.0.0.1:"+strconv.Itoa(runtimeCfg.Port), nil)
 }
 
 // Handle the captured request
-func HandleIngressCapture(w http.ResponseWriter, r *http.Request) {
-	fmt.Fprint(w, "Capture request received")
+func HandleCaptureA(w http.ResponseWriter, r *http.Request) {
+	for key, values := range r.Header {
+		for _, value := range values {
+			fmt.Printf("%s: %s\n", key, value)
+		}
+	}
 	w.Header().Set("Content-Type", "text/html")
-	w.Write([]byte("This request is captured by the debugger"))
+	w.Write([]byte("This request is captured by A handler!<br>Request URI: " + r.URL.String()))
+}
+
+func HandleCaptureB(w http.ResponseWriter, r *http.Request) {
+	for key, values := range r.Header {
+		for _, value := range values {
+			fmt.Printf("%s: %s\n", key, value)
+		}
+	}
+	w.Header().Set("Content-Type", "text/html")
+	w.Write([]byte("This request is captured by the B handler!<br>Request URI: " + r.URL.String()))
 }

example/plugins/debugger/mod/zoraxy_plugin/embed_webserver.go

@@ -6,6 +6,7 @@ import (
 	"io/fs"
 	"net/http"
 	"net/url"
+	"os"
 	"strings"
 	"time"
 )
@@ -15,6 +16,8 @@ type PluginUiRouter struct {
 	TargetFs       *embed.FS //The embed.FS where the UI files are stored
 	TargetFsPrefix string    //The prefix of the embed.FS where the UI files are stored, e.g. /web
 	HandlerPrefix  string    //The prefix of the handler used to route this router, e.g. /ui
+
+	terminateHandler func() //The handler to be called when the plugin is terminated
 }
 
 // NewPluginEmbedUIRouter creates a new PluginUiRouter with embed.FS
@@ -104,3 +107,22 @@ func (p *PluginUiRouter) Handler() http.Handler {
 		p.populateCSRFToken(r, http.FileServer(http.FS(subFS))).ServeHTTP(w, r)
 	})
 }
+
+// RegisterTerminateHandler registers the terminate handler for the PluginUiRouter
+// The terminate handler will be called when the plugin is terminated from Zoraxy plugin manager
+// if mux is nil, the handler will be registered to http.DefaultServeMux
+func (p *PluginUiRouter) RegisterTerminateHandler(termFunc func(), mux *http.ServeMux) {
+	p.terminateHandler = termFunc
+	if mux == nil {
+		mux = http.DefaultServeMux
+	}
+	mux.HandleFunc(p.HandlerPrefix+"/term", func(w http.ResponseWriter, r *http.Request) {
+		p.terminateHandler()
+		w.WriteHeader(http.StatusOK)
+		go func() {
+			//Make sure the response is sent before the plugin is terminated
+			time.Sleep(100 * time.Millisecond)
+			os.Exit(0)
+		}()
+	})
+}

example/plugins/debugger/mod/zoraxy_plugin/static_router.go

@@ -0,0 +1,103 @@
+package zoraxy_plugin
+
+import (
+	"fmt"
+	"net/http"
+	"sort"
+	"strings"
+)
+
+type PathRouter struct {
+	enableDebugPrint bool
+	pathHandlers     map[string]http.Handler
+	defaultHandler   http.Handler
+}
+
+// NewPathRouter creates a new PathRouter
+func NewPathRouter() *PathRouter {
+	return &PathRouter{
+		enableDebugPrint: false,
+		pathHandlers:     make(map[string]http.Handler),
+	}
+}
+
+// RegisterPathHandler registers a handler for a path
+func (p *PathRouter) RegisterPathHandler(path string, handler http.Handler) {
+	path = strings.TrimSuffix(path, "/")
+	p.pathHandlers[path] = handler
+}
+
+// RemovePathHandler removes a handler for a path
+func (p *PathRouter) RemovePathHandler(path string) {
+	delete(p.pathHandlers, path)
+}
+
+// SetDefaultHandler sets the default handler for the router
+// This handler will be called if no path handler is found
+func (p *PathRouter) SetDefaultHandler(handler http.Handler) {
+	p.defaultHandler = handler
+}
+
+// SetDebugPrintMode sets the debug print mode
+func (p *PathRouter) SetDebugPrintMode(enable bool) {
+	p.enableDebugPrint = enable
+}
+
+func (p *PathRouter) RegisterHandle(capture_ingress string, mux *http.ServeMux) {
+	if !strings.HasSuffix(capture_ingress, "/") {
+		capture_ingress = capture_ingress + "/"
+	}
+	mux.Handle(capture_ingress, http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		p.ServeHTTP(w, r)
+	}))
+}
+
+func (p *PathRouter) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	capturePath := r.Header.Get("X-Zoraxy-Capture")
+	if capturePath != "" {
+		if p.enableDebugPrint {
+			fmt.Printf("Using capture path: %s\n", capturePath)
+		}
+		originalURI := r.Header.Get("X-Zoraxy-Uri")
+		r.URL.Path = originalURI
+		if handler, ok := p.pathHandlers[capturePath]; ok {
+			handler.ServeHTTP(w, r)
+			return
+		}
+	}
+	p.defaultHandler.ServeHTTP(w, r)
+}
+
+func (p *PathRouter) PrintRequestDebugMessage(r *http.Request) {
+	if p.enableDebugPrint {
+		fmt.Printf("Capture Request with path: %s \n\n**Request Headers** \n\n", r.URL.Path)
+		keys := make([]string, 0, len(r.Header))
+		for key := range r.Header {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+		for _, key := range keys {
+			for _, value := range r.Header[key] {
+				fmt.Printf("%s: %s\n", key, value)
+			}
+		}
+
+		fmt.Printf("\n\n**Request Details**\n\n")
+		fmt.Printf("Method: %s\n", r.Method)
+		fmt.Printf("URL: %s\n", r.URL.String())
+		fmt.Printf("Proto: %s\n", r.Proto)
+		fmt.Printf("Host: %s\n", r.Host)
+		fmt.Printf("RemoteAddr: %s\n", r.RemoteAddr)
+		fmt.Printf("RequestURI: %s\n", r.RequestURI)
+		fmt.Printf("ContentLength: %d\n", r.ContentLength)
+		fmt.Printf("TransferEncoding: %v\n", r.TransferEncoding)
+		fmt.Printf("Close: %v\n", r.Close)
+		fmt.Printf("Form: %v\n", r.Form)
+		fmt.Printf("PostForm: %v\n", r.PostForm)
+		fmt.Printf("MultipartForm: %v\n", r.MultipartForm)
+		fmt.Printf("Trailer: %v\n", r.Trailer)
+		fmt.Printf("RemoteAddr: %s\n", r.RemoteAddr)
+		fmt.Printf("RequestURI: %s\n", r.RequestURI)
+
+	}
+}

example/plugins/debugger/mod/zoraxy_plugin/zoraxy_plugin.go

@@ -4,9 +4,7 @@ import (
 	"encoding/json"
 	"fmt"
 	"os"
-	"os/signal"
 	"strings"
-	"syscall"
 )
 
 /*
@@ -24,9 +22,9 @@ const (
 	PluginType_Utilities PluginType = 1 //Utilities Plugin, used for utilities like Zerotier or Static Web Server that do not require interception with the dpcore
 )
 
-type CaptureRule struct {
-	CapturePath     string `json:"capture_path"`
-	IncludeSubPaths bool   `json:"include_sub_paths"`
+type StaticCaptureRule struct {
+	CapturePath string `json:"capture_path"`
+	//To be expanded
 }
 
 type ControlStatusCode int
@@ -74,23 +72,24 @@ type IntroSpect struct {
 	*/
 
 	/*
-		Global Capture Settings
-
-		Once plugin is enabled these rules always applies, no matter which HTTP Proxy rule it is enabled on
-		This captures the whole traffic of Zoraxy
+		Static Capture Settings
 
+		Once plugin is enabled these rules always applies to the enabled HTTP Proxy rule
+		This is faster than dynamic capture, but less flexible
 	*/
-	GlobalCapturePaths   []CaptureRule `json:"global_capture_path"`    //Global traffic capture path of your plugin
-	GlobalCaptureIngress string        `json:"global_capture_ingress"` //Global traffic capture ingress path of your plugin (e.g. /g_handler)
+	StaticCapturePaths   []StaticCaptureRule `json:"static_capture_paths"`   //Static capture paths of your plugin, see Zoraxy documentation for more details
+	StaticCaptureIngress string              `json:"static_capture_ingress"` //Static capture ingress path of your plugin (e.g. /s_handler)
 
 	/*
-		Always Capture Settings
+		Dynamic Capture Settings
 
-		Once the plugin is enabled on a given HTTP Proxy rule,
-		these always applies
+		Once plugin is enabled, these rules will be captured and forward to plugin sniff
+		if the plugin sniff returns 280, the traffic will be captured
+		otherwise, the traffic will be forwarded to the next plugin
+		This is slower than static capture, but more flexible
 	*/
-	AlwaysCapturePaths   []CaptureRule `json:"always_capture_path"`    //Always capture path of your plugin when enabled on a HTTP Proxy rule (e.g. /myapp)
-	AlwaysCaptureIngress string        `json:"always_capture_ingress"` //Always capture ingress path of your plugin when enabled on a HTTP Proxy rule (e.g. /a_handler)
+	DynamicCaptureSniff   string `json:"dynamic_capture_sniff"`   //Dynamic capture sniff path of your plugin (e.g. /d_sniff)
+	DynamicCaptureIngress string `json:"dynamic_capture_ingress"` //Dynamic capture ingress path of your plugin (e.g. /d_handler)
 
 	/* UI Path for your plugin */
 	UIPath string `json:"ui_path"` //UI path of your plugin (e.g. /ui), will proxy the whole subpath tree to Zoraxy Web UI as plugin UI
@@ -174,25 +173,3 @@ func ServeAndRecvSpec(pluginSpect *IntroSpect) (*ConfigureSpec, error) {
 	ServeIntroSpect(pluginSpect)
 	return RecvConfigureSpec()
 }
-
-/*
-
-Shutdown handler
-
-This function will register a shutdown handler for the plugin
-The shutdown callback will be called when the plugin is shutting down
-You can use this to clean up resources like closing database connections
-*/
-
-func RegisterShutdownHandler(shutdownCallback func()) {
-	// Set up a channel to receive OS signals
-	sigChan := make(chan os.Signal, 1)
-	signal.Notify(sigChan, syscall.SIGINT, syscall.SIGTERM)
-
-	// Start a goroutine to listen for signals
-	go func() {
-		<-sigChan
-		shutdownCallback()
-		os.Exit(0)
-	}()
-}