protocol, protocol/dataunit: protocol.Server

Author: ydnar

protocol/dataunit/conn.go

@@ -24,6 +24,12 @@ type Writer interface {
 	WriteDataUnit([]byte) error
 }
 
+type writerFunc func(data []byte) error
+
+func (f writerFunc) WriteDataUnit(data []byte) error {
+	return f(data)
+}
+
 // Conn is the interface implemented by any type that can read and write EPP data units.
 // Concurrent operations on a Conn are implementation-specific and should
 // be protected by a synchronization mechanism.

protocol/dataunit/server.go

@@ -5,12 +5,10 @@ import (
 )
 
 // Server provides an ordered queue of client requests coupled with a [Writer]
-// to respond to the request. The Writer returned from ServeDataUnit can be called once.
-// Calling WriteDataUnit more than once is undefined.
+// to respond to the request.
 // Server enforces ordering of responses, writing each response in the same
 // order as the requests received from the client.
-// A Server is safe to call from multiple goroutines, and each client request
-// may be handled in a separate goroutine.
+// ServeDataUnit is safe to be called from multiple goroutines.
 type Server struct {
 	// reading protects Conn and reading
 	reading sync.Mutex
@@ -24,6 +22,11 @@ type Server struct {
 	Conn Conn
 }
 
+// ServeDataUnit reads one data unit from the client and provides a [Writer] to respond.
+// The returned Writer can only be called once. The returned Writer will always
+// be non-nil, so the caller can respond to a malformed client request.
+// ServeDataUnit is safe to be called from multiple goroutines, and each client request
+// may be handled in a separate goroutine.
 func (s *Server) ServeDataUnit() ([]byte, Writer, error) {
 	s.reading.Lock()
 	defer s.reading.Unlock()
@@ -92,9 +95,3 @@ type transaction struct {
 	res []byte
 	err chan error
 }
-
-type writerFunc func(data []byte) error
-
-func (f writerFunc) WriteDataUnit(data []byte) error {
-	return f(data)
-}

protocol/server.go

@@ -0,0 +1,83 @@
+package protocol
+
+import (
+	"github.com/domainr/epp2/protocol/dataunit"
+	"github.com/domainr/epp2/schema"
+	"github.com/domainr/epp2/schema/epp"
+)
+
+// Writer is the interface implemented by any type that can write an EPP message body.
+type Writer interface {
+	WriteEPP(epp.Body) error
+}
+
+type writerFunc func(body epp.Body) error
+
+func (f writerFunc) WriteEPP(body epp.Body) error {
+	return f(body)
+}
+
+// Server is a low-level server for the Extensible Provisioning Protocol (EPP)
+// as defined in [RFC 5730]. A Server is safe to use from multiple goroutines.
+//
+// [RFC 5730]: https://datatracker.ietf.org/doc/rfc5730/
+type Server interface {
+	// ServeEPP provides an client EPP request and a mechanism to respond to the request.
+	// It blocks until a response is received or the underlying connection is closed.
+	// The returned [Writer] should only be used once. The returned Writer will always
+	// be non-nil, so the caller can respond to a malformed client request.
+	ServeEPP() (epp.Body, Writer, error)
+
+	// Close closes the connection.
+	Close() error
+}
+
+type server struct {
+	server dataunit.Server
+	coder  coder
+}
+
+// Serve services conn as an EPP server, sending greeting as the initial <greeting>
+// message to the client.
+// EPP requests from the client will be decoded using [schemas.Schema] schemas.
+// If no schemas are provided, a set of reasonable defaults will be used.
+func Serve(conn dataunit.Conn, greeting epp.Body, schemas ...schema.Schema) (Server, error) {
+	s := newServer(conn, schemas)
+	// Send the initial <greeting> to the client.
+	data, err := s.coder.marshalXML(greeting)
+	if err != nil {
+		return nil, err
+	}
+	return s, conn.WriteDataUnit(data)
+}
+
+func newServer(conn dataunit.Conn, schemas schema.Schemas) *server {
+	if len(schemas) == 0 {
+		schemas = DefaultSchemas()
+	}
+	return &server{
+		server: dataunit.Server{Conn: conn},
+		coder:  coder{schemas},
+	}
+}
+
+// Close closes the connection, interrupting any in-flight requests.
+func (s *server) Close() error {
+	return s.server.Conn.Close()
+}
+
+func (s *server) ServeEPP() (epp.Body, Writer, error) {
+	data, w, err := s.server.ServeDataUnit()
+	f := writerFunc(func(body epp.Body) error {
+		data, err := s.coder.marshalXML(body)
+		if err != nil {
+			return err
+		}
+		return w.WriteDataUnit(data)
+	})
+	if err != nil {
+		return nil, f, err
+	}
+	body, err := s.coder.umarshalXML(data)
+	return body, f, err
+}