toy with middlewares

gemini/gemini.go

@@ -130,7 +130,6 @@ func (s *Server) handleConnection(conn net.Conn, sem chan struct{}) {
 	go requestChannel(conn, reqChan)
 	select {
 	case header := <-reqChan:
-		fmt.Println("serve")
 		if header.err != nil {
 			s.handleRequestError(conn, header)
 			return

gemini/mux.go

@@ -0,0 +1,46 @@
+package gemini
+
+import "io"
+
+// Middlewares type is a slice of gemini middleware handlers.
+type Middleware func(Handler) Handler
+
+type Mux struct {
+	middlewares []Middleware
+	handler     Handler
+}
+
+func NewMux() *Mux {
+	return &Mux{}
+}
+
+// Use appends a handler to the Mux handler stack.
+func (m *Mux) Use(handlers ...Middleware) {
+	m.middlewares = append(m.middlewares, handlers...)
+}
+
+func (m *Mux) Handle(endpoint Handler) Handler {
+	m.handler = chain(m.middlewares, endpoint)
+	return m.handler
+}
+
+func (m *Mux) ServeGemini(w io.Writer, r *Request) {
+	m.handler.ServeGemini(w, r)
+}
+
+// chain builds a Handler composed of an inline middleware stack and endpoint
+// handler in the order they are passed.
+func chain(middlewares []Middleware, endpoint Handler) Handler {
+	// Return ahead of time if there aren't any middlewares for the chain
+	if len(middlewares) == 0 {
+		return endpoint
+	}
+
+	// Wrap the end handler with the middleware chain
+	h := middlewares[len(middlewares)-1](endpoint)
+	for i := len(middlewares) - 2; i >= 0; i-- {
+		h = middlewares[i](h)
+	}
+
+	return h
+}

main.go

@@ -63,11 +63,15 @@ func main() {
 		os.Exit(1)
 	}
 
+	mux := gemini.NewMux()
+	mux.Use(logger)
+	mux.Handle(gemini.HandlerFunc(fileserver(root)))
+
 	server := &gemini.Server{
 		Addr:         addr,
 		Hostname:     host,
 		TLSConfig:    gemini.TLSConfig(host, cert),
-		Handler:      gemini.HandlerFunc(fileserver(root)),
+		Handler:      mux,
 		MaxOpenConns: maxconns,
 		ReadTimeout:  time.Duration(timeout) * time.Second,
 	}
@@ -106,6 +110,13 @@ func main() {
 	*/
 }
 
+func logger(next gemini.Handler) gemini.Handler {
+	fn := func(w io.Writer, r *gemini.Request) {
+		log.Println(r.URL)
+	}
+	return gemini.HandlerFunc(fn)
+}
+
 func fileserver(root string) func(w io.Writer, r *gemini.Request) {
 	return func(w io.Writer, r *gemini.Request) {
 		fullpath, err := fullPath(root, r.URL.Path)