134 lines
2.6 KiB
Go
134 lines
2.6 KiB
Go
package reverseproxy
|
|
|
|
import (
|
|
"fmt"
|
|
"github.com/labstack/echo/v4"
|
|
"net/http"
|
|
"net/http/httputil"
|
|
"net/url"
|
|
"regexp"
|
|
"strings"
|
|
"tesseract/internal/service"
|
|
)
|
|
|
|
type ReverseProxy struct {
|
|
*echo.Echo
|
|
|
|
services service.Services
|
|
httpProxies map[string]*httputil.ReverseProxy
|
|
}
|
|
|
|
type portMapping struct {
|
|
subdomain string
|
|
containerPort int
|
|
hostPort int
|
|
}
|
|
|
|
const keyReverseProxy = "reverseProxy"
|
|
|
|
func New(services service.Services) *ReverseProxy {
|
|
e := echo.New()
|
|
proxy := &ReverseProxy{
|
|
e,
|
|
services,
|
|
make(map[string]*httputil.ReverseProxy),
|
|
}
|
|
|
|
e.Any("/*", proxy.handleRequest)
|
|
|
|
return proxy
|
|
}
|
|
|
|
func From(c echo.Context) *ReverseProxy {
|
|
return c.Get(keyReverseProxy).(*ReverseProxy)
|
|
}
|
|
|
|
func (p *ReverseProxy) Start() error {
|
|
rows, err := p.services.Database.Query("SELECT container_port, host_port, subdomain FROM port_mappings;")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
defer rows.Close()
|
|
|
|
var mappings []portMapping
|
|
for rows.Next() {
|
|
mapping := portMapping{}
|
|
err = rows.Scan(&mapping.containerPort, &mapping.hostPort, &mapping.subdomain)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
|
|
for _, m := range mappings {
|
|
if m.subdomain == "" {
|
|
continue
|
|
}
|
|
|
|
u, err := url.Parse(fmt.Sprintf("http://localhost:%d", m.hostPort))
|
|
if err != nil {
|
|
continue
|
|
}
|
|
|
|
proxy := httputil.NewSingleHostReverseProxy(u)
|
|
p.httpProxies[m.subdomain] = proxy
|
|
}
|
|
|
|
return nil
|
|
}
|
|
|
|
func (p *ReverseProxy) Middleware() echo.MiddlewareFunc {
|
|
return func(next echo.HandlerFunc) echo.HandlerFunc {
|
|
return func(c echo.Context) error {
|
|
c.Set(keyReverseProxy, p)
|
|
return next(c)
|
|
}
|
|
}
|
|
}
|
|
|
|
func (p *ReverseProxy) ShouldHandleRequest(c echo.Context) bool {
|
|
config := p.services.Config
|
|
h := strings.Replace(config.HostName, ".", "\\.", -1)
|
|
reg, err := regexp.Compile(".*\\." + h)
|
|
if err != nil {
|
|
return false
|
|
}
|
|
return reg.MatchString(c.Request().Host)
|
|
}
|
|
|
|
func (p *ReverseProxy) handleRequest(c echo.Context) error {
|
|
req := c.Request()
|
|
res := c.Response()
|
|
config := p.services.Config
|
|
|
|
h := strings.Replace(config.HostName, ".", "\\.", -1)
|
|
reg, err := regexp.Compile(fmt.Sprintf("(?P<subdomain>.*)\\.%v", h))
|
|
if err != nil {
|
|
return err
|
|
}
|
|
|
|
matches := reg.FindStringSubmatch(req.Host)
|
|
if len(matches) == 0 {
|
|
return echo.NewHTTPError(http.StatusNotFound)
|
|
}
|
|
|
|
var subdomain string
|
|
for i, name := range reg.SubexpNames() {
|
|
if i != 0 && name == "subdomain" {
|
|
subdomain = matches[i]
|
|
break
|
|
}
|
|
}
|
|
if subdomain == "" {
|
|
return echo.NewHTTPError(http.StatusNotFound)
|
|
}
|
|
|
|
proxy, ok := p.httpProxies[subdomain]
|
|
if !ok {
|
|
return echo.NewHTTPError(http.StatusNotFound)
|
|
}
|
|
|
|
proxy.ServeHTTP(res, req)
|
|
|
|
return nil
|
|
}
|