Early prototype; initial commit

server/server.go

@@ -0,0 +1,176 @@
+package server
+
+import (
+	"errors"
+	"log"
+	"net/http"
+	"os"
+
+	"github.com/mholt/caddy/config"
+	"github.com/mholt/caddy/middleware"
+)
+
+// servers maintains a registry of running servers.
+var servers = make(map[string]*Server)
+
+// Server represents an instance of a server, which serves
+// static content at a particular address (host and port).
+type Server struct {
+	config     config.Config
+	reqlog     *log.Logger
+	errlog     *log.Logger
+	fileServer http.Handler
+	stack      http.HandlerFunc
+}
+
+// New creates a new Server and registers it with the list
+// of servers created. Each server must have a unique host:port
+// combination. This function does not start serving.
+func New(conf config.Config) (*Server, error) {
+	addr := conf.Address()
+
+	// Unique address check
+	if _, exists := servers[addr]; exists {
+		return nil, errors.New("Address " + addr + " is already in use")
+	}
+
+	// Initialize
+	s := new(Server)
+	s.config = conf
+
+	// Register the server
+	servers[addr] = s
+
+	return s, nil
+}
+
+// Serve starts the server. It blocks until the server quits.
+func (s *Server) Serve() error {
+	err := s.configureStack()
+	if err != nil {
+		return err
+	}
+
+	if s.config.TLS.Enabled {
+		return http.ListenAndServeTLS(s.config.Address(), s.config.TLS.Certificate, s.config.TLS.Key, s)
+	} else {
+		return http.ListenAndServe(s.config.Address(), s)
+	}
+}
+
+// ServeHTTP is the entry point for each request to s.
+func (s *Server) ServeHTTP(w http.ResponseWriter, r *http.Request) {
+	s.stack(w, r)
+}
+
+// Log writes a message to the server's configured error log,
+// if there is one, or if there isn't, to the default stderr log.
+func (s *Server) Log(v ...interface{}) {
+	if s.errlog != nil {
+		s.errlog.Println(v)
+	} else {
+		log.Println(v)
+	}
+}
+
+// configureStack builds the server's middleware stack based
+// on its config. This method should be called last before
+// ListenAndServe begins.
+func (s *Server) configureStack() error {
+	var mid []middleware.Middleware
+	var err error
+	conf := s.config
+
+	// FileServer is the main application layer
+	s.fileServer = http.FileServer(http.Dir(conf.Root))
+
+	// push prepends each middleware to the stack so the
+	// compilation can iterate them in a natural, increasing order
+	push := func(m middleware.Middleware) {
+		mid = append(mid, nil)
+		copy(mid[1:], mid[0:])
+		mid[0] = m
+	}
+
+	// BEGIN ADDING MIDDLEWARE
+	// Middleware will be executed in the order they're added.
+
+	if conf.RequestLog.Enabled {
+		if conf.RequestLog.Enabled {
+			s.reqlog, err = enableLogging(conf.RequestLog)
+			if err != nil {
+				return err
+			}
+		}
+		push(middleware.RequestLog(s.reqlog, conf.RequestLog.Format))
+	}
+
+	if conf.ErrorLog.Enabled {
+		if conf.ErrorLog.Enabled {
+			s.errlog, err = enableLogging(conf.ErrorLog)
+			if err != nil {
+				return err
+			}
+		}
+		push(middleware.ErrorLog(s.errlog, conf.ErrorLog.Format))
+	}
+
+	if len(conf.Rewrites) > 0 {
+		push(middleware.Rewrite(conf.Rewrites))
+	}
+
+	if len(conf.Redirects) > 0 {
+		push(middleware.Redirect(conf.Redirects))
+	}
+
+	if len(conf.Extensions) > 0 {
+		push(middleware.Extensionless(conf.Root, conf.Extensions))
+	}
+
+	if len(conf.Headers) > 0 {
+		push(middleware.Headers(conf.Headers))
+	}
+
+	if conf.Gzip {
+		push(middleware.Gzip)
+	}
+
+	// END ADDING MIDDLEWARE
+
+	// Compiling the middleware unwraps each HandlerFunc,
+	// fully configured, ready to serve every request.
+	s.compile(mid)
+
+	return nil
+}
+
+// compile is an elegant alternative to nesting middleware generator
+// function calls like handler1(handler2(handler3(finalHandler))).
+func (s *Server) compile(layers []middleware.Middleware) {
+	s.stack = s.fileServer.ServeHTTP // core app layer
+	for _, layer := range layers {
+		s.stack = layer(s.stack)
+	}
+}
+
+// enableLogging opens a log file and keeps it open for the lifetime
+// of the server. In fact, the log file is never closed as long as
+// the program is running, since the server will be running for
+// that long. If that ever changes, the log file should be closed.
+func enableLogging(l config.Log) (*log.Logger, error) {
+	var file *os.File
+	var err error
+
+	if l.OutputFile == "stdout" {
+		file = os.Stdout
+	} else if l.OutputFile == "stderr" {
+		file = os.Stderr
+	} else {
+		file, err = os.OpenFile(l.OutputFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0666)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	return log.New(file, "", 0), nil
+}