Initial commit - SOGOMS v1.0.0

- sogoctl: supervisor avec health checks et restart auto
- sogoway: gateway HTTP, auth JWT, routing par hostname
- sogoms-db: microservice MariaDB avec pool par application
- Protocol IPC Unix socket JSON length-prefixed
- Config YAML multi-application (prokov)
- Deploy script pour container Alpine gw3

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <noreply@anthropic.com>

internal/protocol/server.go

@@ -0,0 +1,174 @@
+package protocol
+
+import (
+	"context"
+	"encoding/binary"
+	"fmt"
+	"io"
+	"log"
+	"net"
+	"os"
+	"sync"
+)
+
+// Handler traite une requête et retourne une réponse.
+type Handler func(ctx context.Context, req *Request) *Response
+
+// Server écoute sur un Unix socket et dispatch les requêtes.
+type Server struct {
+	socketPath string
+	handler    Handler
+	listener   net.Listener
+	wg         sync.WaitGroup
+	ctx        context.Context
+	cancel     context.CancelFunc
+}
+
+// NewServer crée un nouveau serveur.
+func NewServer(socketPath string, handler Handler) *Server {
+	ctx, cancel := context.WithCancel(context.Background())
+	return &Server{
+		socketPath: socketPath,
+		handler:    handler,
+		ctx:        ctx,
+		cancel:     cancel,
+	}
+}
+
+// Start démarre le serveur.
+func (s *Server) Start() error {
+	// Supprimer le socket existant
+	if err := os.RemoveAll(s.socketPath); err != nil {
+		return fmt.Errorf("remove socket: %w", err)
+	}
+
+	listener, err := net.Listen("unix", s.socketPath)
+	if err != nil {
+		return fmt.Errorf("listen: %w", err)
+	}
+	s.listener = listener
+
+	// Permissions socket
+	if err := os.Chmod(s.socketPath, 0660); err != nil {
+		return fmt.Errorf("chmod socket: %w", err)
+	}
+
+	log.Printf("[server] listening on %s", s.socketPath)
+
+	go s.acceptLoop()
+	return nil
+}
+
+// Stop arrête le serveur proprement.
+func (s *Server) Stop() {
+	s.cancel()
+	if s.listener != nil {
+		s.listener.Close()
+	}
+	s.wg.Wait()
+	os.RemoveAll(s.socketPath)
+	log.Printf("[server] stopped")
+}
+
+// acceptLoop accepte les connexions entrantes.
+func (s *Server) acceptLoop() {
+	for {
+		conn, err := s.listener.Accept()
+		if err != nil {
+			select {
+			case <-s.ctx.Done():
+				return
+			default:
+				log.Printf("[server] accept error: %v", err)
+				continue
+			}
+		}
+		s.wg.Add(1)
+		go s.handleConn(conn)
+	}
+}
+
+// handleConn gère une connexion client.
+func (s *Server) handleConn(conn net.Conn) {
+	defer s.wg.Done()
+	defer conn.Close()
+
+	for {
+		select {
+		case <-s.ctx.Done():
+			return
+		default:
+		}
+
+		// Lire la requête
+		data, err := readMessage(conn)
+		if err != nil {
+			if err != io.EOF {
+				log.Printf("[server] read error: %v", err)
+			}
+			return
+		}
+
+		// Décoder la requête
+		req, err := DecodeRequest(data)
+		if err != nil {
+			resp := Failure("", "DECODE_ERROR", err.Error())
+			writeResponse(conn, resp)
+			continue
+		}
+
+		// Traiter la requête
+		resp := s.handler(s.ctx, req)
+
+		// Envoyer la réponse
+		if err := writeResponse(conn, resp); err != nil {
+			log.Printf("[server] write error: %v", err)
+			return
+		}
+	}
+}
+
+// readMessage lit un message length-prefixed.
+func readMessage(r io.Reader) ([]byte, error) {
+	// Lire les 4 bytes de longueur
+	lengthBuf := make([]byte, 4)
+	if _, err := io.ReadFull(r, lengthBuf); err != nil {
+		return nil, err
+	}
+
+	length := binary.BigEndian.Uint32(lengthBuf)
+	if length == 0 || length > 10*1024*1024 { // Max 10MB
+		return nil, fmt.Errorf("invalid message length: %d", length)
+	}
+
+	// Lire le payload
+	data := make([]byte, length)
+	if _, err := io.ReadFull(r, data); err != nil {
+		return nil, err
+	}
+
+	return data, nil
+}
+
+// writeResponse écrit une réponse.
+func writeResponse(w io.Writer, resp *Response) error {
+	data, err := Encode(resp)
+	if err != nil {
+		return err
+	}
+	return writeMessage(w, data)
+}
+
+// writeMessage écrit un message length-prefixed.
+func writeMessage(w io.Writer, data []byte) error {
+	// Écrire la longueur
+	lengthBuf := make([]byte, 4)
+	binary.BigEndian.PutUint32(lengthBuf, uint32(len(data)))
+	if _, err := w.Write(lengthBuf); err != nil {
+		return err
+	}
+
+	// Écrire le payload
+	_, err := w.Write(data)
+	return err
+}