refactor

Author: onyas

.vscode/settings.json

@@ -0,0 +1,8 @@
+{
+    "cSpell.words": [
+        "ggclient",
+        "ggrok",
+        "onyas",
+        "upgrader"
+    ]
+}

README.md

@@ -1,7 +1,7 @@
 
-go run ggrok-gorilla-server.go
+go run main.go
 
-go run ggrok-gorilla-client.go
+go run main.go -client
 
 request http://localhost:8080/ through postman
 

ggrok-client.go

@@ -1,4 +1,4 @@
-package main
+package ggrok
 
 import (
 	"bufio"
@@ -8,7 +8,6 @@ import (
 	"io"
 	"log"
 	"net/http"
-	"net/http/httputil"
 	"net/url"
 	"os"
 	"os/signal"
@@ -19,20 +18,14 @@ import (
 
 var addr = flag.String("addr", "localhost:8080", "http service address")
 
-func captureResponseData(resp *http.Response) (string, error) {
-	rump, err := httputil.DumpResponse(resp, true)
-	if err != nil {
-		log.Printf("local response dump error ", err)
-		return "", err
-	}
-	return string(rump), nil
+type GGrokClient struct {
 }
 
-func main() {
-	type RemoteRequest struct {
-		Req string
-		URL string
-	}
+func NewClient() *GGrokClient {
+	return &GGrokClient{}
+}
+
+func (ggclient *GGrokClient) Start() {
 
 	flag.Parse()
 	log.SetFlags(0)
@@ -61,7 +54,7 @@ func main() {
 			}
 			log.Printf("recv: %s", message)
 
-			var websocketReq RemoteRequest
+			var websocketReq WebSocketRequest
 			if err := json.Unmarshal(message, &websocketReq); err != nil {
 				log.Println("json.Unmarshal error", err)
 				continue
@@ -70,15 +63,15 @@ func main() {
 			var localRequest *http.Request
 			r := bufio.NewReader(bytes.NewReader([]byte(websocketReq.Req)))
 			if localRequest, err = http.ReadRequest(r); err != nil { // deserialize request
-				log.Printf("deserialize request error", err)
+				log.Println("deserialize request error", err)
 				continue
 			}
 
 			//TODO: change to config
 			localRequest.RequestURI = ""
 			u, err := url.Parse("/ada08e16-2112-4720-8fcb-18f2f8e47c2d")
 			if err != nil {
-				log.Printf("parse url error", err)
+				log.Println("parse url error", err)
 			}
 			localRequest.URL = u
 			localRequest.URL.Scheme = "https"
@@ -89,27 +82,15 @@ func main() {
 				continue
 			}
 
-			respStr, err := captureResponseData(resp)
-			if err != nil {
-				continue
-			}
-
-			type WebSocketResponse struct {
-				Status      string // e.g. "200 OK"
-				StatusCode  int    // e.g. 200
-				Proto       string // e.g. "HTTP/1.0"
-				Header      map[string][]string
-				Body        []byte
-				ContentType string
-			}
 			body, err := io.ReadAll(resp.Body)
 			if err != nil {
 				log.Println("read local response error ", err)
 			}
+			resp.Body.Close()
 			wsRes := WebSocketResponse{Status: resp.Status, StatusCode: resp.StatusCode,
 				Proto: resp.Proto, Header: resp.Header, Body: body, ContentType: resp.Header.Get("Content-Type")}
 
-			log.Println("client send response: %s", respStr)
+			log.Printf("client send response: %s \n", wsRes.Body)
 			c.WriteJSON(wsRes)
 		}
 	}()

ggrok-server.go

@@ -1,16 +1,14 @@
-package main
+package ggrok
 
 import (
 	"bytes"
-	"flag"
 	"io"
 	"log"
 	"net/http"
 
 	"github.com/gorilla/websocket"
 )
 
-var addr = flag.String("addr", "localhost:8080", "http service address")
 var connections = make(map[string]*websocket.Conn)
 
 var upgrader = websocket.Upgrader{
@@ -19,25 +17,35 @@ var upgrader = websocket.Upgrader{
 	},
 } // use default options
 
-func register(w http.ResponseWriter, r *http.Request) {
+type Server struct {
+}
+
+func NewServer() *Server {
+	return &Server{}
+}
+
+func (s *Server) Register(w http.ResponseWriter, r *http.Request) {
 	c, err := upgrader.Upgrade(w, r, nil)
 	if err != nil {
 		log.Print("upgrade:", err)
 		return
 	}
 
 	connections[r.Host] = c
-	log.Println("current connections: %s", connections)
+	log.Println("current connections: ", connections)
 }
 
-func copyHeader(dst, src http.Header) {
-	for k, vv := range src {
+func copyHeader(dst http.ResponseWriter, src WebSocketResponse) {
+	for k, vv := range src.Header {
 		for _, v := range vv {
-			dst.Add(k, v)
+			dst.Header().Add(k, v)
 		}
 	}
+	dst.WriteHeader(src.StatusCode)
+	dst.Header().Set("Content-Type", src.ContentType)
 }
-func proxy(w http.ResponseWriter, r *http.Request) {
+
+func (s *Server) Proxy(w http.ResponseWriter, r *http.Request) {
 	remoteConn := connections[r.Host]
 	if remoteConn == nil {
 		io.WriteString(w, "client not register")
@@ -48,35 +56,20 @@ func proxy(w http.ResponseWriter, r *http.Request) {
 	if err != nil {
 		log.Println("captureRequestData error:", err)
 	}
-	log.Println("req serialized: %s", reqStr)
+	log.Println("req serialized: ", reqStr)
 
-	// remoteConn.WriteMessage(100, []byte(reqStr))
-	type WebSocketRequest struct {
-		Req string
-		URL string
-	}
 	reqRemote := WebSocketRequest{Req: reqStr, URL: r.URL.String()}
 
 	remoteConn.WriteJSON(reqRemote)
 
-	type WebSocketResponse struct {
-		Status      string // e.g. "200 OK"
-		StatusCode  int    // e.g. 200
-		Proto       string // e.g. "HTTP/1.0"
-		Header      map[string][]string
-		Body        []byte
-		ContentType string
-	}
 	var wsRes WebSocketResponse
 	err = remoteConn.ReadJSON(&wsRes)
 	if err != nil {
 		log.Println("read remote client response error", err)
 	}
-	log.Println("remote client response: %s", wsRes)
+	log.Println("remote client response: ", wsRes)
 
-	copyHeader(w.Header(), wsRes.Header)
-	w.WriteHeader(wsRes.StatusCode)
-	w.Header().Set("Content-Type", wsRes.ContentType)
+	copyHeader(w, wsRes)
 	io.Copy(w, bytes.NewReader(wsRes.Body))
 }
 
@@ -88,11 +81,3 @@ func captureRequestData(req *http.Request) (string, error) {
 	}
 	return b.String(), nil
 }
-
-func main() {
-	flag.Parse()
-	log.SetFlags(0)
-	http.HandleFunc("/$$ggrok", register)
-	http.HandleFunc("/", proxy)
-	log.Fatal(http.ListenAndServe(*addr, nil))
-}

ggrok-gorilla-client.go ggrok/ggrok-gorilla-client.go

@@ -0,0 +1,15 @@
+package ggrok
+
+type WebSocketRequest struct {
+	Req string
+	URL string
+}
+
+type WebSocketResponse struct {
+	Status      string // e.g. "200 OK"
+	StatusCode  int    // e.g. 200
+	Proto       string // e.g. "HTTP/1.0"
+	Header      map[string][]string
+	Body        []byte
+	ContentType string
+}