feat: reimplement req builder

Author: aorith

pkg/render/helpers.go

@@ -1,6 +1,11 @@
 package render
 
-import "strings"
+import (
+	"fmt"
+	"net"
+	"strconv"
+	"strings"
+)
 
 type CustomBuilder struct {
 	strings.Builder
@@ -10,3 +15,32 @@ type CustomBuilder struct {
 func (b *CustomBuilder) PadAdd(s string) {
 	b.WriteString("    " + s + "\n")
 }
+
+// ParseBackend parses "<HOST/IP>:<PORT>" where HOST may be a hostname,
+// IPv4, or IPv6 (possibly unbracketed). Returns host and port separately.
+func ParseBackend(s string) (host, port string, err error) {
+	// Try the standard parser first (works for "host:port" and "[v6]:port").
+	host, port, err = net.SplitHostPort(s)
+	if err != nil {
+		// Fallback: split at the last colon. This handles unbracketed IPv6 like "fe80::1%eth0:8080".
+		i := strings.LastIndex(s, ":")
+		if i == -1 {
+			return "", "", fmt.Errorf("missing port in %q", s)
+		}
+		host = s[:i]
+		port = s[i+1:]
+		if host == "" {
+			return "", "", fmt.Errorf("empty host in %q", s)
+		}
+		if _, e := strconv.Atoi(port); e != nil {
+			return "", "", fmt.Errorf("invalid port %q: %v", port, e)
+		}
+	}
+
+	// If it is an IPv6, surrond it with []
+	if strings.Contains(host, ":") && !strings.Contains(host, "[") && !strings.Contains(host, "]") {
+		host = fmt.Sprintf("[%s]", host)
+	}
+
+	return host, port, nil
+}

pkg/render/httpmodel.go

@@ -1,13 +1,19 @@
 package render
 
 import (
+	"fmt"
+	"net"
+	"sort"
+	"strings"
+
 	"github.com/aorith/varnishlog-parser/vsl"
 	"github.com/aorith/varnishlog-parser/vsl/tag"
 )
 
 type HTTPRequest struct {
 	method  string
 	host    string
+	port    string
 	url     string
 	headers []Header
 }
@@ -19,17 +25,21 @@ type Header struct {
 
 type Backend struct {
 	host string
-	port int
+	port string
+}
+
+func NewBackend(host string, port string) *Backend {
+	return &Backend{host: host, port: port}
 }
 
 // NewHTTPRequest constructs an HTTPRequest from a Varnish transaction.
 // Returns nil if the transaction type is session.
 //
 // If fromResponse is true, fields are extracted from the response; otherwise, from the request.
 // If received is true, initial (received) headers are used; otherwise, headers after VCL processing.
-func NewHTTPRequest(tx *vsl.Transaction, fromResponse, received bool) *HTTPRequest {
+func NewHTTPRequest(tx *vsl.Transaction, fromResponse, received bool) (*HTTPRequest, error) {
 	if tx.Type() == vsl.TxTypeSession {
-		return nil
+		return nil, fmt.Errorf("cannot create an http request from a transaction of type session")
 	}
 
 	var headers vsl.Headers
@@ -40,12 +50,24 @@ func NewHTTPRequest(tx *vsl.Transaction, fromResponse, received bool) *HTTPReque
 	}
 
 	host := headers.Get("host", received)
+	port := ""
+	if strings.Contains(host, ":") {
+		var err error
+		host, port, err = ParseBackend(headers.Get("host", received))
+		if err != nil {
+			return nil, err
+		}
+	}
+
 	httpHeaders := []Header{}
 	for name, h := range headers {
 		if name == vsl.HdrNameHost {
 			continue
 		}
 		for _, v := range h.Values(received) {
+			if v.State() == vsl.HdrStateDeleted {
+				continue
+			}
 			httpHeaders = append(httpHeaders, Header{name: name, value: v.Value()})
 		}
 	}
@@ -60,10 +82,74 @@ func NewHTTPRequest(tx *vsl.Transaction, fromResponse, received bool) *HTTPReque
 		url = tx.RecordValueByTag(tag.BereqURL, received)
 	}
 
+	sort.Slice(httpHeaders, func(i, j int) bool {
+		return httpHeaders[i].name < httpHeaders[j].name
+	})
+
 	return &HTTPRequest{
 		method:  method,
 		host:    host,
+		port:    port,
 		url:     url,
 		headers: httpHeaders,
+	}, nil
+}
+
+// CurlCommand generates a new curl command as a string
+// scheme can be "auto", "http://" or "https://"
+func (r *HTTPRequest) CurlCommand(scheme string, backend *Backend) string {
+	var s strings.Builder
+
+	// Parse scheme
+	switch scheme {
+	case "auto":
+		if r.port == "443" {
+			scheme = "https://"
+		} else {
+			// default to http for 80, empty, or any other port
+			scheme = "http://"
+		}
+	case "http://", "https://":
+		// keep as-is
+	default:
+		return "invalid scheme: " + scheme
+	}
+
+	// Build host URL, append port only when provided
+	hostURL := r.host
+	if r.port != "" {
+		hostURL = net.JoinHostPort(r.host, r.port)
+	}
+
+	// Initial command
+	s.WriteString(fmt.Sprintf(`curl "%s%s%s"`+" \\\n", scheme, hostURL, r.url))
+
+	switch r.method {
+	case "POST", "PUT", "PATCH":
+		s.WriteString("    -X " + r.method + " \\\n")
+		s.WriteString("    -d '<body-unavailable>' \\\n")
+	default:
+		s.WriteString("    -X " + r.method + " \\\n")
+	}
+
+	// Headers
+	for _, h := range r.headers {
+		if h.name == vsl.HdrNameHost {
+			continue
+		}
+		hdrVal := strings.ReplaceAll(h.value, `"`, `\"`)
+		s.WriteString(fmt.Sprintf(`    -H "%s: %s"`+" \\\n", h.name, hdrVal))
+	}
+
+	// Default parameters
+	s.WriteString("    -qsv -k -o /dev/null")
+
+	// Connect-to
+	// --connect-to HOST1:PORT1:HOST2:PORT2
+	// when you would connect to HOST1:PORT1, actually connect to HOST2:PORT2
+	if backend != nil {
+		s.WriteString(fmt.Sprintf(" \\\n    "+`--connect-to "%s:%s:%s"`, hostURL, backend.host, backend.port))
 	}
+
+	return s.String()
 }

pkg/server/routes.go

@@ -72,45 +72,21 @@ func (s *vlogServer) registerRoutes() http.Handler {
 			return
 		}
 
-		var rt int
-		rtValue := r.Form.Get("sendTo")
-		switch rtValue {
-		case "domain":
-			rt = content.SendToDomain
-		case "backend":
-			rt = content.SendToBackend
-		case "localhost":
-			rt = content.SendToLocalhost
+		connectTo := r.Form.Get("connectTo")
+		switch connectTo {
 		case "custom":
-			rt = content.SendToCustom
+			connectTo = r.Form.Get("custom")
+		case "backend":
+			connectTo = r.Form.Get("transactionBackend")
 		}
 
 		f := content.ReqBuilderForm{
-			TXID:            r.Form.Get("transaction"),
-			HTTPS:           r.Form.Get("https") == "on",
-			OriginalHeaders: r.Form.Get("headerType") == "original",
-			OriginalURL:     r.Form.Get("urlType") == "original",
-			ResolveTo:       rt,
-			CustomResolve:   r.Form.Get("customResolve"),
-		}
-
-		if f.ResolveTo == content.SendToBackend {
-			f.CustomResolve = r.Form.Get("transactionBackend")
-		}
-
-		// Find the tx which should still be present in the "New Parse" textarea
-		tx, ok := txsSet.TransactionsMap()[f.TXID]
-		if !ok {
-			err = partials.ErrorMsg(fmt.Errorf(`Transaction %q not found. Did you reset the "New Parse" textarea?`, f.TXID)).Render(context.Background(), w)
-			if err != nil {
-				w.WriteHeader(http.StatusInternalServerError)
-				fmt.Fprintln(w, err)
-				return
-			}
-			return
+			Scheme:    r.Form.Get("scheme"),
+			Received:  r.Form.Get("headers") == "received", // Use the received method/url and headers
+			ConnectTo: connectTo,
 		}
 
-		err = content.ReqBuild(txsSet, tx, f).Render(context.Background(), w)
+		err = content.ReqBuild(txsSet, f).Render(context.Background(), w)
 		if err != nil {
 			w.WriteHeader(http.StatusInternalServerError)
 			fmt.Fprintln(w, err)