initial commit

server/server.go

@@ -0,0 +1,237 @@
+package server
+
+import (
+	"fmt"
+	"io"
+	"log"
+	"net/http"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+type TunnelConnection struct {
+	conn      *websocket.Conn
+	vhost     string
+	responses map[string]chan *TunnelResponse
+	mu        sync.RWMutex
+}
+
+type TunnelRequest struct {
+	ID      string            `json:"id"`
+	Method  string            `json:"method"`
+	URL     string            `json:"url"`
+	Headers map[string]string `json:"headers"`
+	Body    []byte            `json:"body"`
+}
+
+type TunnelResponse struct {
+	ID         string            `json:"id"`
+	StatusCode int               `json:"status_code"`
+	Headers    map[string]string `json:"headers"`
+	Body       []byte            `json:"body"`
+}
+
+type Server struct {
+	tunnels  map[string]*TunnelConnection
+	mu       sync.RWMutex
+	upgrader websocket.Upgrader
+}
+
+func NewServer() *Server {
+	return &Server{
+		tunnels: make(map[string]*TunnelConnection),
+		upgrader: websocket.Upgrader{
+			CheckOrigin: func(r *http.Request) bool {
+				return true
+			},
+		},
+	}
+}
+
+func (s *Server) Start(addr string) error {
+	http.HandleFunc("/", s.handleRequest)
+	http.HandleFunc("/_conduit/tunnel", s.handleTunnel)
+	http.HandleFunc("/_conduit/status", s.handleStatus)
+
+	log.Printf("Conduit server listening on %s", addr)
+	return http.ListenAndServe(addr, nil)
+}
+
+func (s *Server) handleRequest(w http.ResponseWriter, r *http.Request) {
+	host := r.Host
+	subdomain := s.extractSubdomain(host)
+
+	if subdomain == "" {
+		http.Error(w, "Invalid host", http.StatusBadRequest)
+		return
+	}
+
+	s.mu.RLock()
+	tunnel, exists := s.tunnels[subdomain]
+	s.mu.RUnlock()
+
+	if !exists {
+		http.Error(w, "Tunnel not found", http.StatusNotFound)
+		return
+	}
+
+	// Create unique request ID
+	reqID := fmt.Sprintf("%d", time.Now().UnixNano())
+
+	// Read request body
+	body, err := io.ReadAll(r.Body)
+	if err != nil {
+		http.Error(w, "Failed to read request body", http.StatusBadRequest)
+		return
+	}
+	defer r.Body.Close()
+
+	// Convert headers
+	headers := make(map[string]string)
+	for k, v := range r.Header {
+		if len(v) > 0 {
+			headers[k] = v[0]
+		}
+	}
+
+	// Create response channel for this request
+	respChan := make(chan *TunnelResponse, 1)
+	tunnel.mu.Lock()
+	tunnel.responses[reqID] = respChan
+	tunnel.mu.Unlock()
+
+	// Clean up response channel when done
+	defer func() {
+		tunnel.mu.Lock()
+		delete(tunnel.responses, reqID)
+		tunnel.mu.Unlock()
+	}()
+
+	tunnelReq := &TunnelRequest{
+		ID:      reqID,
+		Method:  r.Method,
+		URL:     r.URL.String(),
+		Headers: headers,
+		Body:    body,
+	}
+
+	// Send request to tunnel
+	if err := tunnel.conn.WriteJSON(tunnelReq); err != nil {
+		log.Printf("Error sending request to tunnel: %v", err)
+		http.Error(w, "Tunnel communication error", http.StatusServiceUnavailable)
+		return
+	}
+
+	// Wait for response
+	select {
+	case resp := <-respChan:
+		// Write response headers
+		for k, v := range resp.Headers {
+			w.Header().Set(k, v)
+		}
+		w.WriteHeader(resp.StatusCode)
+		w.Write(resp.Body)
+
+	case <-time.After(30 * time.Second):
+		http.Error(w, "Tunnel timeout", http.StatusGatewayTimeout)
+	}
+}
+
+func (s *Server) handleTunnel(w http.ResponseWriter, r *http.Request) {
+	vhost := r.URL.Query().Get("vhost")
+	if vhost == "" {
+		http.Error(w, "Missing vhost parameter", http.StatusBadRequest)
+		return
+	}
+
+	conn, err := s.upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		log.Printf("WebSocket upgrade failed: %v", err)
+		return
+	}
+
+	tunnel := &TunnelConnection{
+		conn:      conn,
+		vhost:     vhost,
+		responses: make(map[string]chan *TunnelResponse),
+	}
+
+	s.mu.Lock()
+	s.tunnels[vhost] = tunnel
+	s.mu.Unlock()
+
+	log.Printf("Tunnel established: %s", vhost)
+
+	// Handle tunnel communication
+	s.handleTunnelConnection(tunnel)
+}
+
+func (s *Server) handleTunnelConnection(tunnel *TunnelConnection) {
+	defer func() {
+		s.mu.Lock()
+		delete(s.tunnels, tunnel.vhost)
+		s.mu.Unlock()
+		tunnel.conn.Close()
+		log.Printf("Tunnel closed: %s", tunnel.vhost)
+	}()
+
+	// Handle incoming responses from client
+	for {
+		var resp TunnelResponse
+		if err := tunnel.conn.ReadJSON(&resp); err != nil {
+			log.Printf("Error reading response from tunnel %s: %v", tunnel.vhost, err)
+			return
+		}
+
+		// Find the response channel for this request
+		tunnel.mu.RLock()
+		respChan, exists := tunnel.responses[resp.ID]
+		tunnel.mu.RUnlock()
+
+		if exists {
+			select {
+			case respChan <- &resp:
+				// Response delivered
+			default:
+				log.Printf("Response channel full for request %s", resp.ID)
+			}
+		} else {
+			log.Printf("No response channel found for request %s", resp.ID)
+		}
+	}
+}
+
+func (s *Server) handleStatus(w http.ResponseWriter, r *http.Request) {
+	s.mu.RLock()
+	defer s.mu.RUnlock()
+
+	w.Header().Set("Content-Type", "application/json")
+	fmt.Fprintf(w, `{"tunnels": %d, "active": [`, len(s.tunnels))
+
+	first := true
+	for vhost := range s.tunnels {
+		if !first {
+			fmt.Fprint(w, ",")
+		}
+		fmt.Fprintf(w, `{"vhost":"%s"}`, vhost)
+		first = false
+	}
+
+	fmt.Fprint(w, "]}")
+}
+
+func (s *Server) extractSubdomain(host string) string {
+	if idx := strings.Index(host, ":"); idx != -1 {
+		host = host[:idx]
+	}
+
+	parts := strings.Split(host, ".")
+	if len(parts) >= 1 {
+		return parts[0]
+	}
+
+	return ""
+}