add examples folder

Author: olekukonko

examples/basic/conn.go

@@ -0,0 +1,90 @@
+//go:build ignore
+// +build ignore
+
+package main
+
+import (
+	"fmt"
+	"github.com/gobwas/ws"
+	"github.com/gobwas/ws/wsutil"
+	"github.com/gorilla/websocket"
+	"log"
+	"net"
+)
+
+// GorillaConn wraps gorilla/websocket.Conn
+type GorillaConn struct {
+	*websocket.Conn
+}
+
+func (c *GorillaConn) Read() ([]byte, error) {
+	_, msg, err := c.Conn.ReadMessage()
+	return msg, err
+}
+
+func (c *GorillaConn) Write(message []byte) error {
+	fmt.Printf("[gorilla] %s\n", message)
+	return c.Conn.WriteMessage(websocket.TextMessage, message)
+}
+
+func (c *GorillaConn) Close() error {
+	return c.Conn.Close()
+}
+
+// GobwasConn wraps gobwas/ws connection
+type GobwasConn struct {
+	conn net.Conn
+}
+
+// Read reads a WebSocket message from the connection
+func (c *GobwasConn) Read() ([]byte, error) {
+	msg, _, err := wsutil.ReadClientData(c.conn)
+	if err != nil {
+		log.Printf("WebSocket read error: %v", err)
+		return nil, err
+	}
+	log.Printf("WebSocket read: %s", msg)
+	return msg, nil
+}
+
+// Write writes a WebSocket message to the connection
+func (c *GobwasConn) Write(message []byte) error {
+	fmt.Printf("[ws] %s\n", message)
+	err := wsutil.WriteServerMessage(c.conn, ws.OpText, message)
+	if err != nil {
+		log.Printf("WebSocket write error: %v", err)
+	}
+	return err
+}
+
+// Close closes the WebSocket connection
+func (c *GobwasConn) Close() error {
+	return c.conn.Close()
+}
+
+// TCPConn wraps a net.Conn for raw TCP connections
+type TCPConn struct {
+	conn net.Conn
+}
+
+// Read reads data from the TCP connection
+func (c *TCPConn) Read() ([]byte, error) {
+	buf := make([]byte, 1024)
+	n, err := c.conn.Read(buf)
+	if err != nil {
+		return nil, err
+	}
+	return buf[:n], nil
+}
+
+// Write writes data to the TCP connection
+func (c *TCPConn) Write(message []byte) error {
+	fmt.Printf("[tcp] %s\n", message)
+	_, err := c.conn.Write(message)
+	return err
+}
+
+// Close closes the TCP connection
+func (c *TCPConn) Close() error {
+	return c.conn.Close()
+}

examples/basic/main.go

@@ -0,0 +1,176 @@
+//go:build ignore
+// +build ignore
+
+package main
+
+import (
+	"fmt"
+	"github.com/gobwas/ws"
+	"github.com/olekukonko/ruta"
+	"log"
+	"net"
+	"sync"
+)
+
+func main() {
+	// Create a router
+	router := ruta.NewRouter()
+	router.Use(func(ctx *ruta.Frame) error {
+		ctx.Conn.Write([]byte("Default Use\n"))
+		return nil
+	})
+
+	router.Route("hello", func(ctx *ruta.Frame) {
+		ctx.Conn.Write([]byte("hi\n"))
+	})
+
+	router.Route("say/hello", func(ctx *ruta.Frame) {
+		ctx.Conn.Write([]byte("hello\n"))
+	})
+
+	router.Route("/user/{username}", func(ctx *ruta.Frame) {
+		username, _ := ctx.Params.Get("username")
+		ctx.Conn.Write([]byte("Hello, " + username + "\n"))
+	})
+
+	// First /welcome section
+	router.Section("/welcome", func(r ruta.RouteBase) {
+		r.Route("/message", func(ctx *ruta.Frame) {
+			ctx.Conn.Write([]byte("Hello router a\n"))
+		})
+	})
+
+	// Second /welcome section with group and nested admin section
+	router.Section("/service", func(x ruta.RouteBase) {
+		x.Group(func(r ruta.RouteBase) {
+			r.Use(func(ctx *ruta.Frame) error {
+				ctx.Conn.Write([]byte("Group Use\n"))
+				return nil
+			})
+
+			r.Route("/a", func(ctx *ruta.Frame) {
+				ctx.Conn.Write([]byte("service a\n"))
+			})
+
+			r.Route("/b", func(ctx *ruta.Frame) {
+				ctx.Conn.Write([]byte("service b\n"))
+			})
+
+			// Nested admin section
+			r.Section("/admin", func(r ruta.RouteBase) {
+				r.Route("/", func(ctx *ruta.Frame) { // Default "/" route for /welcome/admin
+					ctx.Conn.Write([]byte("admin base\n"))
+				})
+
+				r.Group(func(r ruta.RouteBase) {
+					r.Use(func(ctx *ruta.Frame) error {
+						ctx.Conn.Write([]byte("Sub Group Use\n"))
+						return nil
+					})
+
+					r.Route("/yes", func(ctx *ruta.Frame) {
+						ctx.Conn.Write([]byte("admin yes\n"))
+					})
+
+					r.Route("/done", func(ctx *ruta.Frame) {
+						ctx.Conn.Write([]byte("admin done\n"))
+					})
+				})
+			})
+		})
+
+		x.Route("/done", func(ctx *ruta.Frame) {
+			ctx.Conn.Write([]byte("am done a\n"))
+		})
+	})
+
+	fmt.Println("Registered routes:")
+	for _, route := range router.Routes() {
+		fmt.Println(route)
+	}
+
+	// Create a server with the router
+	server := NewServer(router)
+
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	// Start TCP and WebSocket servers
+	go handleTCP(wg, server)
+	go handleWS(wg, server)
+
+	// Wait for servers to be ready
+	wg.Wait()
+
+	router.Use(func(f *ruta.Frame) error {
+		log.Printf("Command: %s", f.Command())
+		return nil
+	})
+
+	router.Section("/admin", func(r ruta.RouteBase) {
+		r.Use(func(f *ruta.Frame) error {
+			return fmt.Errorf("admin access required")
+		})
+
+		r.Route("/shutdown", func(f *ruta.Frame) {
+			f.Conn.Write([]byte("Shutting down\n"))
+		})
+	})
+	server.Serve()
+}
+
+func handleWS(wg *sync.WaitGroup, s *Server) {
+
+	// Create a WebSocket server
+	ln, err := net.Listen("tcp", ":8080")
+	if err != nil {
+		log.Fatalf("Failed to listen: %v", err)
+	}
+	defer ln.Close()
+
+	fmt.Println("WebSocket server is running on :8080")
+	wg.Done()
+
+	for {
+		// Accept a new connection
+		conn, err := ln.Accept()
+		if err != nil {
+			log.Printf("Failed to accept connection: %v", err)
+			continue
+		}
+
+		// Upgrade the connection to a WebSocket connection
+		_, err = ws.Upgrade(conn)
+		if err != nil {
+			log.Printf("Failed to upgrade connection: %v", err)
+			conn.Close()
+			continue
+		}
+
+		// Handle the WebSocket connection
+		s.AddConnection(&GobwasConn{conn: conn})
+	}
+}
+
+func handleTCP(wg *sync.WaitGroup, s *Server) {
+	ln, err := net.Listen("tcp", ":8081")
+	if err != nil {
+		fmt.Printf("Failed to start TCP server: %v\n", err)
+		return
+	}
+	defer ln.Close()
+
+	fmt.Println("TCP server is running on :8081")
+	wg.Done()
+
+	for {
+		conn, err := ln.Accept()
+		if err != nil {
+			fmt.Printf("Failed to accept TCP connection: %v\n", err)
+			continue
+		}
+
+		log.Println("TCP Ready for connection")
+		s.AddConnection(&TCPConn{conn: conn})
+	}
+}

examples/basic/server.go

@@ -0,0 +1,68 @@
+//go:build ignore
+// +build ignore
+
+package main
+
+import (
+	"fmt"
+	"github.com/olekukonko/ruta"
+	"sync"
+)
+
+// Server handles connection management
+type Server struct {
+	router ruta.RouteBase
+	conns  []ruta.Connection // Keep this for reference, but not used in Serve()
+	connCh chan ruta.Connection
+	mu     sync.Mutex
+}
+
+// NewServer creates a new Server instance
+func NewServer(router ruta.RouteBase) *Server {
+	return &Server{
+		router: router,
+		conns:  make([]ruta.Connection, 0),
+		connCh: make(chan ruta.Connection, 10), // Buffered channel to avoid blocking
+	}
+}
+
+// AddConnection adds a connection to the server
+func (s *Server) AddConnection(conn ruta.Connection) {
+	s.mu.Lock()
+	s.conns = append(s.conns, conn) // Optional: keep track of connections
+	s.mu.Unlock()
+	s.connCh <- conn // Send to channel for processing
+}
+
+// Serve starts handling connections in a non-blocking way
+func (s *Server) Serve() {
+	fmt.Printf("Serve was called\n")
+
+	for conn := range s.connCh {
+		go func(c ruta.Connection) {
+			defer c.Close()
+
+			for {
+				msg, err := c.Read()
+				if err != nil {
+					fmt.Printf("Read error: %v\n", err)
+					return
+				}
+
+				// Log the received message
+				fmt.Printf("Received message: %s\n", string(msg))
+
+				// Create a context and delegate to the router
+				ctx := &ruta.Frame{
+					Conn:    c,
+					Payload: ruta.NewPayload(msg),
+					Params:  ruta.NewParams(),
+					Values:  make(map[string]interface{}),
+				}
+
+				// Let the router handle the message
+				s.router.Handle(ctx)
+			}
+		}(conn)
+	}
+}