preparing for v0.5

src/proxy/fields/alias.go

@@ -0,0 +1,23 @@
+package fields
+
+import (
+	"strings"
+
+	F "github.com/yusing/go-proxy/utils/functional"
+)
+
+type Alias struct{ F.Stringable }
+type Aliases struct{ *F.Slice[Alias] }
+
+func NewAlias(s string) Alias {
+	return Alias{F.NewStringable(s)}
+}
+
+func NewAliases(s string) Aliases {
+	split := strings.Split(s, ",")
+	a := Aliases{F.NewSliceN[Alias](len(split))}
+	for i, v := range split {
+		a.Set(i, NewAlias(v))
+	}
+	return a
+}

src/proxy/fields/host.go

@@ -0,0 +1,20 @@
+package fields
+
+import (
+	E "github.com/yusing/go-proxy/error"
+	F "github.com/yusing/go-proxy/utils/functional"
+)
+
+type Host struct{ F.Stringable }
+type Subdomain = Alias
+
+func NewHost(s string) (Host, E.NestedError) {
+	return Host{F.NewStringable(s)}, E.Nil()
+}
+
+func (h Host) Subdomain() (*Subdomain, E.NestedError) {
+	if i := h.IndexRune(':'); i != -1 {
+		return &Subdomain{h.SubStr(0, i)}, E.Nil()
+	}
+	return nil, E.Invalid("host", h)
+}

src/proxy/fields/path.go

@@ -0,0 +1,15 @@
+package fields
+
+import (
+	E "github.com/yusing/go-proxy/error"
+	F "github.com/yusing/go-proxy/utils/functional"
+)
+
+type Path struct{ F.Stringable }
+
+func NewPath(s string) (Path, E.NestedError) {
+	if s == "" || s[0] == '/' {
+		return Path{F.NewStringable(s)}, E.Nil()
+	}
+	return Path{}, E.Invalid("path", s).Extra("must be empty or start with '/'")
+}

src/proxy/fields/path_mode.go

@@ -0,0 +1,25 @@
+package fields
+
+import (
+	F "github.com/yusing/go-proxy/utils/functional"
+	E "github.com/yusing/go-proxy/error"
+)
+
+type PathMode struct{ F.Stringable }
+
+func NewPathMode(pm string) (PathMode, E.NestedError) {
+	switch pm {
+	case "", "forward":
+		return PathMode{F.NewStringable(pm)}, E.Nil()
+	default:
+		return PathMode{}, E.Invalid("path mode", pm)
+	}
+}
+
+func (p PathMode) IsRemove() bool {
+	return p.String() == ""
+}
+
+func (p PathMode) IsForward() bool {
+	return p.String() == "forward"
+}

src/proxy/fields/port.go

@@ -0,0 +1,40 @@
+package fields
+
+import (
+	"strconv"
+
+	E "github.com/yusing/go-proxy/error"
+)
+
+type Port int
+
+func NewPort(v string) (Port, E.NestedError) {
+	p, err := strconv.Atoi(v)
+	if err != nil {
+		return ErrPort, E.From(err)
+	}
+	return NewPortInt(p)
+}
+
+func NewPortInt(v int) (Port, E.NestedError) {
+	pp := Port(v)
+	if err := pp.boundCheck(); err.IsNotNil() {
+		return ErrPort, err
+	}
+	return pp, E.Nil()
+}
+
+func (p Port) boundCheck() E.NestedError {
+	if p < MinPort || p > MaxPort {
+		return E.Invalid("port", p)
+	}
+	return E.Nil()
+}
+
+const (
+	MinPort  = 0
+	MaxPort  = 65535
+	ErrPort  = Port(-1)
+	NoPort   = Port(-1)
+	ZeroPort = Port(0)
+)

src/proxy/fields/scheme.go

@@ -0,0 +1,37 @@
+package fields
+
+import (
+	"strings"
+
+	E "github.com/yusing/go-proxy/error"
+	F "github.com/yusing/go-proxy/utils/functional"
+)
+
+type Scheme struct{ F.Stringable }
+
+func NewScheme(s string) (*Scheme, E.NestedError) {
+	switch s {
+	case "http", "https", "tcp", "udp":
+		return &Scheme{F.NewStringable(s)}, E.Nil()
+	}
+	return nil, E.Invalid("scheme", s)
+}
+
+func NewSchemeFromPort(p string) (*Scheme, E.NestedError) {
+	var s string
+	switch {
+	case strings.ContainsRune(p, ':'):
+		s = "tcp"
+	case strings.HasSuffix(p, "443"):
+		s = "https"
+	default:
+		s = "http"
+	}
+	return &Scheme{F.NewStringable(s)}, E.Nil()
+}
+
+func (s Scheme) IsHTTP() bool   { return s.String() == "http" }
+func (s Scheme) IsHTTPS() bool  { return s.String() == "https" }
+func (s Scheme) IsTCP() bool    { return s.String() == "tcp" }
+func (s Scheme) IsUDP() bool    { return s.String() == "udp" }
+func (s Scheme) IsStream() bool { return s.IsTCP() || s.IsUDP() }

src/proxy/fields/stream_port.go

@@ -0,0 +1,49 @@
+package fields
+
+import (
+	"strings"
+
+	"github.com/yusing/go-proxy/common"
+	E "github.com/yusing/go-proxy/error"
+)
+
+type StreamPort struct {
+	ListeningPort Port `json:"listening"`
+	ProxyPort     Port `json:"proxy"`
+}
+
+func NewStreamPort(p string) (StreamPort, E.NestedError) {
+	split := strings.Split(p, ":")
+	if len(split) != 2 {
+		return StreamPort{}, E.Invalid("stream port", p).Extra("should be in 'x:y' format")
+	}
+
+	listeningPort, err := NewPort(split[0])
+	if err.IsNotNil() {
+		return StreamPort{}, err
+	}
+	if err = listeningPort.boundCheck(); err.IsNotNil() {
+		return StreamPort{}, err
+	}
+
+	proxyPort, err := NewPort(split[1])
+	if err.IsNotNil() {
+		proxyPort, err = parseNameToPort(split[1])
+		if err.IsNotNil() {
+			return StreamPort{}, err
+		}
+	}
+	if err = proxyPort.boundCheck(); err.IsNotNil() {
+		return StreamPort{}, err
+	}
+
+	return StreamPort{ListeningPort: listeningPort, ProxyPort: proxyPort}, E.Nil()
+}
+
+func parseNameToPort(name string) (Port, E.NestedError) {
+	port, ok := common.NamePortMapTCP[name]
+	if !ok {
+		return -1, E.Unsupported("service", name)
+	}
+	return Port(port), E.Nil()
+}

src/proxy/fields/stream_scheme.go

@@ -0,0 +1,42 @@
+package fields
+
+import (
+	"strings"
+
+	E "github.com/yusing/go-proxy/error"
+)
+
+type StreamScheme struct {
+	ListeningScheme *Scheme `json:"listening"`
+	ProxyScheme     *Scheme `json:"proxy"`
+}
+
+func NewStreamScheme(s string) (ss *StreamScheme, err E.NestedError) {
+	ss = &StreamScheme{}
+	parts := strings.Split(s, ":")
+	if len(parts) == 1 {
+		parts = []string{s, s}
+	} else if len(parts) != 2 {
+		return nil, E.Invalid("stream scheme", s)
+	}
+	ss.ListeningScheme, err = NewScheme(parts[0])
+	if err.IsNotNil() {
+		return nil, err
+	}
+	ss.ProxyScheme, err = NewScheme(parts[1])
+	if err.IsNotNil() {
+		return nil, err
+	}
+	return ss, E.Nil()
+}
+
+func (s StreamScheme) String() string {
+	return s.ListeningScheme.String() + " -> " + s.ProxyScheme.String()
+}
+
+// IsCoherent checks if the ListeningScheme and ProxyScheme of the StreamScheme are equal.
+//
+// It returns a boolean value indicating whether the ListeningScheme and ProxyScheme are equal.
+func (s StreamScheme) IsCoherent() bool {
+	return *s.ListeningScheme == *s.ProxyScheme
+}