Skip to content

C
caddy
Commit 995edf05 authored by Matthew Holt's avatar Matthew Holt
Browse files
Options

Bringing in latest from master; refactoring under way

parent 5f32f9b1
Hide whitespace changes
Inline Side-by-side
Showing with 169 additions and 2426 deletions
config/config.go
View file @ 995edf05
// Package config contains utilities and types necessary for
// launching specially-configured server instances.
package config
import (
"io"
"log"
"net"
"os"
"github.com/mholt/caddy/config/parse"
"github.com/mholt/caddy/config/setup"
"github.com/mholt/caddy/middleware"
"github.com/mholt/caddy/server"
)
const (
......@@ -19,110 +19,89 @@ const (
DefaultConfigFile = "Caddyfile"
)
// Host and Port are configurable via command line flag
// These three defaults are configurable through the command line
var (
Root = DefaultRoot
Host = DefaultHost
Port = DefaultPort
)
// config represents a server configuration. It
// is populated by parsing a config file (via the
// Load function).
type Config struct {
// The hostname or IP on which to serve
Host string
// The port to listen on
Port string
// The directory from which to serve files
Root string
// HTTPS configuration
TLS TLSConfig
// Middleware stack
Middleware map[string][]middleware.Middleware
// Functions (or methods) to execute at server start; these
// are executed before any parts of the server are configured,
// and the functions are blocking
Startup []func() error
// Functions (or methods) to execute when the server quits;
// these are executed in response to SIGINT and are blocking
Shutdown []func() error
// The path to the configuration file from which this was loaded
ConfigFile string
}
// Address returns the host:port of c as a string.
func (c Config) Address() string {
return net.JoinHostPort(c.Host, c.Port)
}
// TLSConfig describes how TLS should be configured and used,
// if at all. A certificate and key are both required.
type TLSConfig struct {
Enabled bool
Certificate string
Key string
}
// Load loads a configuration file, parses it,
// and returns a slice of Config structs which
// can be used to create and configure server
// instances.
func Load(filename string) ([]Config, error) {
file, err := os.Open(filename)
if err != nil {
return nil, err
}
defer file.Close()
func Load(filename string, input io.Reader) ([]server.Config, error) {
var configs []server.Config
// turn off timestamp for parsing
flags := log.Flags()
log.SetFlags(0)
p, err := newParser(file)
serverBlocks, err := parse.ServerBlocks(filename, input)
if err != nil {
return nil, err
return configs, err
}
cfgs, err := p.parse()
if err != nil {
return []Config{}, err
}
for i := 0; i < len(cfgs); i++ {
cfgs[i].ConfigFile = filename
// Each server block represents a single server/address.
// Iterate each server block and make a config for each one,
// executing the directives that were parsed.
for _, sb := range serverBlocks {
config := server.Config{
Host: sb.Host,
Port: sb.Port,
Middleware: make(map[string][]middleware.Middleware),
}
// It is crucial that directives are executed in the proper order.
for _, dir := range directiveOrder {
// Execute directive if it is in the server block
if tokens, ok := sb.Tokens[dir.name]; ok {
// Each setup function gets a controller, which is the
// server config and the dispenser containing only
// this directive's tokens.
controller := &setup.Controller{
Config: &config,
Dispenser: parse.NewDispenserTokens(filename, tokens),
}
midware, err := dir.setup(controller)
if err != nil {
return configs, err
}
if midware != nil {
// TODO: For now, we only support the default path scope /
config.Middleware["/"] = append(config.Middleware["/"], midware)
}
}
}
if config.Port == "" {
config.Port = Port
}
configs = append(configs, config)
}
// restore logging settings
log.SetFlags(flags)
return cfgs, nil
return configs, nil
}
// IsNotFound returns whether or not the error is
// one which indicates that the configuration file
// was not found. (Useful for checking the error
// returned from Load).
func IsNotFound(err error) bool {
return os.IsNotExist(err)
// validDirective returns true if d is a valid
// directive; false otherwise.
func validDirective(d string) bool {
for _, dir := range directiveOrder {
if dir.name == d {
return true
}
}
return false
}
// Default makes a default configuration
// that's empty except for root, host, and port,
// which are essential for serving the cwd.
func Default() []Config {
cfg := []Config{
Config{
Root: DefaultRoot,
Host: Host,
Port: Port,
},
// Default makes a default configuration which
// is empty except for root, host, and port,
// which are essentials for serving the cwd.
func Default() server.Config {
return server.Config{
Root: Root,
Host: Host,
Port: Port,
}
return cfg
}
config/controller.go deleted 100644 → 0
View file @ 5f32f9b1
package config
import "github.com/mholt/caddy/middleware"
// controller is a dispenser of tokens and also
// facilitates setup with the server by providing
// access to its configuration. It implements
// the middleware.Controller interface.
type controller struct {
dispenser
parser *parser
pathScope string
}
// newController returns a new controller.
func newController(p *parser) *controller {
return &controller{
dispenser: dispenser{
cursor: -1,
filename: p.filename,
},
parser: p,
}
}
// Startup registers a function to execute when the server starts.
func (c *controller) Startup(fn func() error) {
c.parser.cfg.Startup = append(c.parser.cfg.Startup, fn)
}
// Shutdown registers a function to execute when the server exits.
func (c *controller) Shutdown(fn func() error) {
c.parser.cfg.Shutdown = append(c.parser.cfg.Shutdown, fn)
}
// Root returns the server root file path.
func (c *controller) Root() string {
if c.parser.cfg.Root == "" {
return "."
} else {
return c.parser.cfg.Root
}
}
// Context returns the path scope that the Controller is in.
func (c *controller) Context() middleware.Path {
return middleware.Path(c.pathScope)
}
config/controller_test.go deleted 100644 → 0
View file @ 5f32f9b1
package config
import "testing"
func TestController(t *testing.T) {
p := &parser{filename: "test"}
c := newController(p)
if c == nil || c.parser == nil {
t.Fatal("Expected newController to return a non-nil controller with a non-nil parser")
}
if c.dispenser.cursor != -1 {
t.Errorf("Dispenser not initialized properly; expecting cursor at -1, got %d", c.dispenser.cursor)
}
if c.dispenser.filename != p.filename {
t.Errorf("Dispenser's filename should be same as parser's (%s); got '%s'", p.filename, c.dispenser.filename)
}
c.Startup(func() error { return nil })
if n := len(c.parser.cfg.Startup); n != 1 {
t.Errorf("Expected length of startup functions to be 1, got %d", n)
}
if root := c.Root(); root != "." {
t.Errorf("Expected defualt root path to be '.', got '%s'", root)
}
c.parser.cfg.Root = "foobar/test"
if root := c.Root(); root != c.parser.cfg.Root {
t.Errorf("Expected established root path to be '%s', got '%s'", c.parser.cfg.Root, root)
}
c.pathScope = "unused"
if context := c.Context(); string(context) != c.pathScope {
t.Errorf("Expected context to be '%s', got '%s'", c.pathScope, context)
}
}
config/directives.go
View file @ 995edf05
package config
import (
"fmt"
"log"
"os"
"os/exec"
"github.com/mholt/caddy/config/parse"
"github.com/mholt/caddy/config/setup"
"github.com/mholt/caddy/middleware"
)
// dirFunc is a type of parsing function which processes
// a particular directive and populates the config.
type dirFunc func(*parser) error
// validDirectives is a map of valid, built-in directive names
// to their parsing function. Built-in directives cannot be
// ordered, so they should only be used for internal server
// configuration; not directly handling requests.
var validDirectives map[string]dirFunc
func init() {
// This has to be in the init function
// to avoid an initialization loop error because
// the 'import' directive (key) in this map
// invokes a method that uses this map.
validDirectives = map[string]dirFunc{
"root": func(p *parser) error {
if !p.nextArg() {
return p.argErr()
}
p.cfg.Root = p.tkn()
// Ensure root folder exists
_, err := os.Stat(p.cfg.Root)
if err != nil {
if os.IsNotExist(err) {
// Allow this, because the folder might appear later.
// But make sure the user knows!
log.Printf("Warning: Root path %s does not exist", p.cfg.Root)
} else {
return p.err("Path", fmt.Sprintf("Unable to access root path '%s': %s", p.cfg.Root, err.Error()))
}
}
return nil
},
"import": func(p *parser) error {
if !p.nextArg() {
return p.argErr()
}
filename := p.tkn()
file, err := os.Open(filename)
if err != nil {
return p.err("Parse", err.Error())
}
defer file.Close()
p2, err := newParser(file)
if err != nil {
return p.err("Parse", "Could not import "+filename+"; "+err.Error())
}
p2.cfg = p.cfg
err = p2.directives()
if err != nil {
return err
}
p.cfg = p2.cfg
return nil
},
"tls": func(p *parser) error {
tls := TLSConfig{Enabled: true}
if !p.nextArg() {
return p.argErr()
}
tls.Certificate = p.tkn()
if !p.nextArg() {
return p.argErr()
}
tls.Key = p.tkn()
p.cfg.TLS = tls
return nil
},
"startup": func(p *parser) error {
// TODO: This code is duplicated with the shutdown directive below
if !p.nextArg() {
return p.argErr()
}
command, args, err := middleware.SplitCommandAndArgs(p.tkn())
if err != nil {
return p.err("Parse", err.Error())
}
startupfn := func() error {
cmd := exec.Command(command, args...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err := cmd.Run()
if err != nil {
return err
}
return nil
}
p.cfg.Startup = append(p.cfg.Startup, startupfn)
return nil
},
"shutdown": func(p *parser) error {
if !p.nextArg() {
return p.argErr()
}
command, args, err := middleware.SplitCommandAndArgs(p.tkn())
if err != nil {
return p.err("Parse", err.Error())
}
// The parse package must know which directives
// are valid, but it must not import the setup
// or config package.
for _, dir := range directiveOrder {
parse.ValidDirectives[dir.name] = struct{}{}
}
}
shutdownfn := func() error {
cmd := exec.Command(command, args...)
cmd.Stdout = os.Stdout
cmd.Stderr = os.Stderr
err := cmd.Run()
if err != nil {
return err
}
return nil
}
var directiveOrder = []directive{
{"root", setup.Root},
{"tls", setup.TLS},
{"startup", setup.Startup},
{"shutdown", setup.Shutdown},
{"log", setup.Log},
{"gzip", setup.Gzip},
{"errors", setup.Errors},
{"header", setup.Headers},
{"rewrite", setup.Rewrite},
{"redir", setup.Redir},
{"ext", setup.Ext},
{"basicauth", setup.BasicAuth},
//{"proxy", setup.Proxy},
// {"fastcgi", setup.FastCGI},
// {"websocket", setup.WebSocket},
// {"markdown", setup.Markdown},
// {"templates", setup.Templates},
// {"browse", setup.Browse},
}
p.cfg.Shutdown = append(p.cfg.Shutdown, shutdownfn)
return nil
},
}
type directive struct {
name string
setup setupFunc
}
type setupFunc func(c *setup.Controller) (middleware.Middleware, error)
config/dispenser.go deleted 100644 → 0
View file @ 5f32f9b1
package config
import (
"errors"
"fmt"
)
// dispenser is a type that dispenses tokens, similarly to
// a lexer, except that it can do so with some notion of
// structure. Its methods implement part of the
// middleware.Controller interface, so refer to that
// documentation for more info.
type dispenser struct {
filename string
cursor int
nesting int
tokens []token
}
// Next loads the next token. Returns true if a token
// was loaded; false otherwise. If false, all tokens
// have already been consumed.
func (d *dispenser) Next() bool {
if d.cursor < len(d.tokens)-1 {
d.cursor++
return true
}
return false
}
// NextArg loads the next token if it is on the same
// line. Returns true if a token was loaded; false
// otherwise. If false, all tokens on the line have
// been consumed.
func (d *dispenser) NextArg() bool {
if d.cursor < 0 {
d.cursor++
return true
}
if d.cursor >= len(d.tokens) {
return false
}
if d.cursor < len(d.tokens)-1 &&
d.tokens[d.cursor].line == d.tokens[d.cursor+1].line {
d.cursor++
return true
}
return false
}
// NextLine loads the next token only if it is not on the same
// line as the current token, and returns true if a token was
// loaded; false otherwise. If false, there is not another token
// or it is on the same line.
func (d *dispenser) NextLine() bool {
if d.cursor < 0 {
d.cursor++
return true
}
if d.cursor >= len(d.tokens) {
return false
}
if d.cursor < len(d.tokens)-1 &&
d.tokens[d.cursor].line < d.tokens[d.cursor+1].line {
d.cursor++
return true
}
return false
}
// NextBlock can be used as the condition of a for loop
// to load the next token as long as it opens a block or
// is already in a block. It returns true if a token was
// loaded, or false when the block's closing curly brace
// was loaded and thus the block ended. Nested blocks are
// not (currently) supported.
func (d *dispenser) NextBlock() bool {
if d.nesting > 0 {
d.Next()
if d.Val() == "}" {
d.nesting--
return false
}
return true
}
if !d.NextArg() { // block must open on same line
return false
}
if d.Val() != "{" {
d.cursor-- // roll back if not opening brace
return false
}
d.Next()
d.nesting++
return true
}
// Val gets the text of the current token. If there is no token
// loaded, it returns empty string.
func (d *dispenser) Val() string {
if d.cursor < 0 || d.cursor >= len(d.tokens) {
return ""
} else {
return d.tokens[d.cursor].text
}
}
// Args is a convenience function that loads the next arguments
// (tokens on the same line) into an arbitrary number of strings
// pointed to in targets. If there are fewer tokens available
// than string pointers, the remaining strings will not be changed
// and false will be returned. If there were enough tokens available
// to fill the arguments, then true will be returned.
func (d *dispenser) Args(targets ...*string) bool {
enough := true
for i := 0; i < len(targets); i++ {
if !d.NextArg() {
enough = false
break
}
*targets[i] = d.Val()
}
return enough
}
// RemainingArgs loads any more arguments (tokens on the same line)
// into a slice and returns them. Open curly brace tokens also indicate
// the end of arguments, and the curly brace is not included in
// the return value nor is it loaded.
func (d *dispenser) RemainingArgs() []string {
var args []string
for d.NextArg() {
if d.Val() == "{" {
d.cursor--
break
}
args = append(args, d.Val())
}
return args
}
// ArgErr returns an argument error, meaning that another
// argument was expected but not found. In other words,
// a line break or open curly brace was encountered instead of
// an argument.
func (d *dispenser) ArgErr() error {
if d.Val() == "{" {
return d.Err("Unexpected token '{', expecting argument")
}
return d.Err("Wrong argument count or unexpected line ending after '" + d.Val() + "'")
}
// Err generates a custom parse error with a message of msg.
func (d *dispenser) Err(msg string) error {
msg = fmt.Sprintf("%s:%d - Parse error: %s", d.filename, d.tokens[d.cursor].line, msg)
return errors.New(msg)
}
config/dispenser_test.go deleted 100644 → 0
View file @ 5f32f9b1
package config
import (
"reflect"
"strings"
"testing"
)
func TestDispenser_Val_Next(t *testing.T) {
input := `host:port
dir1 arg1
dir2 arg2 arg3
dir3`
d := makeTestDispenser("test", input)
if val := d.Val(); val != "" {
t.Fatalf("Val(): Should return empty string when no token loaded; got '%s'", val)
}
assertNext := func(shouldLoad bool, expectedCursor int, expectedVal string) {
if loaded := d.Next(); loaded != shouldLoad {
t.Errorf("Next(): Expected %v but got %v instead (val '%s')", shouldLoad, loaded, d.Val())
}
if d.cursor != expectedCursor {
t.Errorf("Expected cursor to be %d, but was %d", expectedCursor, d.cursor)
}
if d.nesting != 0 {
t.Errorf("Nesting should be 0, was %d instead", d.nesting)
}
if val := d.Val(); val != expectedVal {
t.Errorf("Val(): Expected '%s' but got '%s'", expectedVal, val)
}
}
assertNext(true, 0, "host:port")
assertNext(true, 1, "dir1")
assertNext(true, 2, "arg1")
assertNext(true, 3, "dir2")
assertNext(true, 4, "arg2")
assertNext(true, 5, "arg3")
assertNext(true, 6, "dir3")
// Note: This next test simply asserts existing behavior.
// If desired, we may wish to empty the token value after
// reading past the EOF. Open an issue if you want this change.
assertNext(false, 6, "dir3")
}
func TestDispenser_NextArg(t *testing.T) {
input := `dir1 arg1
dir2 arg2 arg3
dir3`
d := makeTestDispenser("test", input)
assertNext := func(shouldLoad bool, expectedVal string, expectedCursor int) {
if d.Next() != shouldLoad {
t.Errorf("Next(): Should load token but got false instead (val: '%s')", d.Val())
}
if d.cursor != expectedCursor {
t.Errorf("Next(): Expected cursor to be at %d, but it was %d", expectedCursor, d.cursor)
}
if val := d.Val(); val != expectedVal {
t.Errorf("Val(): Expected '%s' but got '%s'", expectedVal, val)
}
}
assertNextArg := func(expectedVal string, loadAnother bool, expectedCursor int) {
if d.NextArg() != true {
t.Error("NextArg(): Should load next argument but got false instead")
}
if d.cursor != expectedCursor {
t.Errorf("NextArg(): Expected cursor to be at %d, but it was %d", expectedCursor, d.cursor)
}
if val := d.Val(); val != expectedVal {
t.Errorf("Val(): Expected '%s' but got '%s'", expectedVal, val)
}
if !loadAnother {
if d.NextArg() != false {
t.Fatalf("NextArg(): Should NOT load another argument, but got true instead (val: '%s')", d.Val())
}
if d.cursor != expectedCursor {
t.Errorf("NextArg(): Expected cursor to remain at %d, but it was %d", expectedCursor, d.cursor)
}
}
}
assertNext(true, "dir1", 0)
assertNextArg("arg1", false, 1)
assertNext(true, "dir2", 2)
assertNextArg("arg2", true, 3)
assertNextArg("arg3", false, 4)
assertNext(true, "dir3", 5)
assertNext(false, "dir3", 5)
}
func TestDispenser_NextLine(t *testing.T) {
input := `host:port
dir1 arg1
dir2 arg2 arg3`
d := makeTestDispenser("test", input)
assertNextLine := func(shouldLoad bool, expectedVal string, expectedCursor int) {
if d.NextLine() != shouldLoad {
t.Errorf("NextLine(): Should load token but got false instead (val: '%s')", d.Val())
}
if d.cursor != expectedCursor {
t.Errorf("NextLine(): Expected cursor to be %d, instead was %d", expectedCursor, d.cursor)
}
if val := d.Val(); val != expectedVal {
t.Errorf("Val(): Expected '%s' but got '%s'", expectedVal, val)
}
}
assertNextLine(true, "host:port", 0)
assertNextLine(true, "dir1", 1)
assertNextLine(false, "dir1", 1)
d.Next() // arg1
assertNextLine(true, "dir2", 3)
assertNextLine(false, "dir2", 3)
d.Next() // arg2
assertNextLine(false, "arg2", 4)
d.Next() // arg3
assertNextLine(false, "arg3", 5)
}
func TestDispenser_NextBlock(t *testing.T) {
input := `foobar1 {
sub1 arg1
sub2
}
foobar2 {
}`
d := makeTestDispenser("test", input)
assertNextBlock := func(shouldLoad bool, expectedCursor, expectedNesting int) {
if loaded := d.NextBlock(); loaded != shouldLoad {
t.Errorf("NextBlock(): Should return %v but got %v", shouldLoad, loaded)
}
if d.cursor != expectedCursor {
t.Errorf("NextBlock(): Expected cursor to be %d, was %d", expectedCursor, d.cursor)
}
if d.nesting != expectedNesting {
t.Errorf("NextBlock(): Nesting should be %d, not %d", expectedNesting, d.nesting)
}
}
assertNextBlock(false, -1, 0)
d.Next() // foobar1
assertNextBlock(true, 2, 1)
assertNextBlock(true, 3, 1)
assertNextBlock(true, 4, 1)
assertNextBlock(false, 5, 0)
d.Next() // foobar2
assertNextBlock(true, 8, 1)
assertNextBlock(false, 8, 0)
}
func TestDispenser_Args(t *testing.T) {
var s1, s2, s3 string
input := `dir1 arg1 arg2 arg3
dir2 arg4 arg5
dir3 arg6 arg7
dir4`
d := makeTestDispenser("test", input)
d.Next() // dir1
// As many strings as arguments
if all := d.Args(&s1, &s2, &s3); !all {
t.Error("Args(): Expected true, got false")
}
if s1 != "arg1" {
t.Errorf("Args(): Expected s1 to be 'arg1', got '%s'", s1)
}
if s2 != "arg2" {
t.Errorf("Args(): Expected s2 to be 'arg2', got '%s'", s2)
}
if s3 != "arg3" {
t.Errorf("Args(): Expected s3 to be 'arg3', got '%s'", s3)
}
d.Next() // dir2
// More strings than arguments
if all := d.Args(&s1, &s2, &s3); all {
t.Error("Args(): Expected false, got true")
}
if s1 != "arg4" {
t.Errorf("Args(): Expected s1 to be 'arg4', got '%s'", s1)
}
if s2 != "arg5" {
t.Errorf("Args(): Expected s2 to be 'arg5', got '%s'", s2)
}
if s3 != "arg3" {
t.Errorf("Args(): Expected s3 to be unchanged ('arg3'), instead got '%s'", s3)
}
// (quick cursor check just for kicks and giggles)
if d.cursor != 6 {
t.Errorf("Cursor should be 6, but is %d", d.cursor)
}
d.Next() // dir3
// More arguments than strings
if all := d.Args(&s1); !all {
t.Error("Args(): Expected true, got false")
}
if s1 != "arg6" {
t.Errorf("Args(): Expected s1 to be 'arg6', got '%s'", s1)
}
d.Next() // dir4
// No arguments or strings
if all := d.Args(); !all {
t.Error("Args(): Expected true, got false")
}
// No arguments but at least one string
if all := d.Args(&s1); all {
t.Error("Args(): Expected false, got true")
}
}
func TestDispenser_RemainingArgs(t *testing.T) {
input := `dir1 arg1 arg2 arg3
dir2 arg4 arg5
dir3 arg6 { arg7
dir4`
d := makeTestDispenser("test", input)
d.Next() // dir1
args := d.RemainingArgs()
if expected := []string{"arg1", "arg2", "arg3"}; !reflect.DeepEqual(args, expected) {
t.Errorf("RemainingArgs(): Expected %v, got %v", expected, args)
}
d.Next() // dir2
args = d.RemainingArgs()
if expected := []string{"arg4", "arg5"}; !reflect.DeepEqual(args, expected) {
t.Errorf("RemainingArgs(): Expected %v, got %v", expected, args)
}
d.Next() // dir3
args = d.RemainingArgs()
if expected := []string{"arg6"}; !reflect.DeepEqual(args, expected) {
t.Errorf("RemainingArgs(): Expected %v, got %v", expected, args)
}
d.Next() // {
d.Next() // arg7
d.Next() // dir4
args = d.RemainingArgs()
if len(args) != 0 {
t.Errorf("RemainingArgs(): Expected %v, got %v", []string{}, args)
}
}
func TestDispenser_ArgErr_Err(t *testing.T) {
input := `dir1 {
}
dir2 arg1 arg2`
d := makeTestDispenser("test", input)
d.cursor = 1 // {
if err := d.ArgErr(); err == nil || !strings.Contains(err.Error(), "{") {
t.Errorf("ArgErr(): Expected an error message with { in it, but got '%v'", err)
}
d.cursor = 5 // arg2
if err := d.ArgErr(); err == nil || !strings.Contains(err.Error(), "arg2") {
t.Errorf("ArgErr(): Expected an error message with 'arg2' in it; got '%v'", err)
}
err := d.Err("foobar")
if err == nil {
t.Fatalf("Err(): Expected an error, got nil")
}
if !strings.Contains(err.Error(), "test:3") {
t.Errorf("Expected error message with filename:line in it; got '%v'", err)
}
if !strings.Contains(err.Error(), "foobar") {
t.Errorf("Expected error message with custom message in it ('foobar'); got '%v'", err)
}
}
func makeTestDispenser(filename, input string) dispenser {
return dispenser{
filename: filename,
cursor: -1,
tokens: getTokens(input),
}
}
func getTokens(input string) (tokens []token) {
var l lexer
l.load(strings.NewReader(input))
for l.next() {
tokens = append(tokens, l.token)
}
return
}
config/import_test.txt deleted 100644 → 0
View file @ 5f32f9b1
root /test/imported/public_html
\ No newline at end of file
config/lexer.go deleted 100644 → 0
View file @ 5f32f9b1
package config
import (
"bufio"
"io"
"unicode"
)
type (
// lexer is a utility which can get values, token by
// token, from a reader. A token is a word, and tokens
// are separated by whitespace. A word can be enclosed in
// quotes if it contains whitespace.
lexer struct {
reader *bufio.Reader
token token
line int
}
// token represents a single processable unit.
token struct {
line int
text string
}
)
// load prepares the lexer to scan a file for tokens.
func (l *lexer) load(file io.Reader) error {
l.reader = bufio.NewReader(file)
l.line = 1
return nil
}
// next loads the next token into the lexer.
// A token is delimited by whitespace, unless
// the token starts with a quotes character (")
// in which case the token goes until the closing
// quotes (the enclosing quotes are not included).
// The rest of the line is skipped if a "#"
// character is read in. Returns true if a token
// was loaded; false otherwise.
func (l *lexer) next() bool {
var val []rune
var comment, quoted, escaped bool
makeToken := func() bool {
l.token.text = string(val)
return true
}
for {
ch, _, err := l.reader.ReadRune()
if err != nil {
if len(val) > 0 {
return makeToken()
}
if err == io.EOF {
return false
} else {
panic(err)
}
}
if quoted {
if !escaped {
if ch == '\\' {
escaped = true
continue
} else if ch == '"' {
quoted = false
return makeToken()
}
}
if ch == '\n' {
l.line++
}
val = append(val, ch)
escaped = false
continue
}
if unicode.IsSpace(ch) {
if ch == '\r' {
continue
}
if ch == '\n' {
l.line++
comment = false
}
if len(val) > 0 {
return makeToken()
}
continue
}
if ch == '#' {
comment = true
}
if comment {
continue
}
if len(val) == 0 {
l.token = token{line: l.line}
if ch == '"' {
quoted = true
continue
}
}
val = append(val, ch)
}
}
config/lexer_test.go deleted 100644 → 0
View file @ 5f32f9b1
package config
import (
"strings"
"testing"
)
type lexerTestCase struct {
input string
expected []token
}
func TestLexer(t *testing.T) {
testCases := []lexerTestCase{
{
input: `host:123`,
expected: []token{
{line: 1, text: "host:123"},
},
},
{
input: `host:123
directive`,
expected: []token{
{line: 1, text: "host:123"},
{line: 3, text: "directive"},
},
},
{
input: `host:123 {
directive
}`,
expected: []token{
{line: 1, text: "host:123"},
{line: 1, text: "{"},
{line: 2, text: "directive"},
{line: 3, text: "}"},
},
},
{
input: `host:123 { directive }`,
expected: []token{
{line: 1, text: "host:123"},
{line: 1, text: "{"},
{line: 1, text: "directive"},
{line: 1, text: "}"},
},
},
{
input: `host:123 {
#comment
directive
# comment
foobar # another comment
}`,
expected: []token{
{line: 1, text: "host:123"},
{line: 1, text: "{"},
{line: 3, text: "directive"},
{line: 5, text: "foobar"},
{line: 6, text: "}"},
},
},
{
input: `a "quoted value" b
foobar`,
expected: []token{
{line: 1, text: "a"},
{line: 1, text: "quoted value"},
{line: 1, text: "b"},
{line: 2, text: "foobar"},
},
},
{
input: `A "quoted \"value\" inside" B`,
expected: []token{
{line: 1, text: "A"},
{line: 1, text: `quoted "value" inside`},
{line: 1, text: "B"},
},
},
{
input: `A "quoted value with line
break inside" {
foobar
}`,
expected: []token{
{line: 1, text: "A"},
{line: 1, text: "quoted value with line\n\t\t\t\t\tbreak inside"},
{line: 2, text: "{"},
{line: 3, text: "foobar"},
{line: 4, text: "}"},
},
},
{
input: "skip those\r\nCR characters",
expected: []token{
{line: 1, text: "skip"},
{line: 1, text: "those"},
{line: 2, text: "CR"},
{line: 2, text: "characters"},
},
},
}
for i, testCase := range testCases {
actual := tokenize(testCase.input)
lexerCompare(t, i, testCase.expected, actual)
}
}
func tokenize(input string) (tokens []token) {
l := lexer{}
l.load(strings.NewReader(input))
for l.next() {
tokens = append(tokens, l.token)
}
return
}
func lexerCompare(t *testing.T, n int, expected, actual []token) {
if len(expected) != len(actual) {
t.Errorf("Test case %d: expected %d token(s) but got %d", n, len(expected), len(actual))
}
for i := 0; i < len(actual) && i < len(expected); i++ {
if actual[i].line != expected[i].line {
t.Errorf("Test case %d token %d ('%s'): expected line %d but was line %d",
n, i, expected[i].text, expected[i].line, actual[i].line)
break
}
if actual[i].text != expected[i].text {
t.Errorf("Test case %d token %d: expected text '%s' but was '%s'",
n, i, expected[i].text, actual[i].text)
break
}
}
}
config/middleware.go deleted 100644 → 0
View file @ 5f32f9b1
package config
import (
"github.com/mholt/caddy/middleware"
"github.com/mholt/caddy/middleware/basicauth"
"github.com/mholt/caddy/middleware/browse"
"github.com/mholt/caddy/middleware/errors"
"github.com/mholt/caddy/middleware/extensions"
"github.com/mholt/caddy/middleware/fastcgi"
"github.com/mholt/caddy/middleware/git"
"github.com/mholt/caddy/middleware/gzip"
"github.com/mholt/caddy/middleware/headers"
"github.com/mholt/caddy/middleware/log"
"github.com/mholt/caddy/middleware/markdown"
"github.com/mholt/caddy/middleware/proxy"
"github.com/mholt/caddy/middleware/redirect"
"github.com/mholt/caddy/middleware/rewrite"
"github.com/mholt/caddy/middleware/templates"
"github.com/mholt/caddy/middleware/websockets"
)
// This init function registers middleware. Register
// middleware in the order they should be executed
// during a request (A, B, C...). Middleware execute
// in the order A-B-C-*-C-B-A, assuming they call
// the Next handler in the chain.
//
// Note: Ordering is VERY important. Every middleware
// will feel the effects of all other middleware below
// (after) them, but must not care what middleware above
// them are doing.
//
// For example, log needs to know the status code and exactly
// how many bytes were written to the client, which every
// other middleware can affect, so it gets registered first.
// The errors middleware does not care if gzip or log modifies
// its response, so it gets registered below them. Gzip, on the
// other hand, DOES care what errors does to the response since
// it must compress every output to the client, even error pages,
// so it must be registered before the errors middleware and any
// others that would write to the response.
func init() {
register("log", log.New)
register("gzip", gzip.New)
register("errors", errors.New)
register("header", headers.New)
register("rewrite", rewrite.New)
register("redir", redirect.New)
register("ext", extensions.New)
register("basicauth", basicauth.New)
register("proxy", proxy.New)
register("git", git.New)
register("fastcgi", fastcgi.New)
register("websocket", websockets.New)
register("markdown", markdown.New)
register("templates", templates.New)
register("browse", browse.New)
}
// registry stores the registered middleware:
// both the order and the directives to which they
// are bound.
var registry = struct {
directiveMap map[string]middleware.Generator
ordered []string
}{
directiveMap: make(map[string]middleware.Generator),
}
// register binds a middleware generator (outer function)
// to a directive. Upon each request, middleware will be
// executed in the order they are registered.
func register(directive string, generator middleware.Generator) {
registry.directiveMap[directive] = generator
registry.ordered = append(registry.ordered, directive)
}
// middlewareRegistered returns whether or not a directive is registered.
func middlewareRegistered(directive string) bool {
_, ok := registry.directiveMap[directive]
return ok
}
config/parser.go deleted 100644 → 0
View file @ 5f32f9b1
package config
import (
"errors"
"fmt"
"os"
"github.com/mholt/caddy/middleware"
)
type (
// parser is a type which can parse config files.
parser struct {
filename string // the name of the file that we're parsing
lexer lexer // the lexer that is giving us tokens from the raw input
hosts []hostPort // the list of host:port combinations current tokens apply to
cfg Config // each virtual host gets one Config; this is the one we're currently building
cfgs []Config // after a Config is created, it may need to be copied for multiple hosts
other []locationContext // tokens to be 'parsed' later by middleware generators
scope *locationContext // the current location context (path scope) being populated
unused *token // sometimes a token will be read but not immediately consumed
eof bool // if we encounter a valid EOF in a hard place
}
// locationContext represents a location context
// (path block) in a config file. If no context
// is explicitly defined, the default location
// context is "/".
locationContext struct {
path string
directives map[string]*controller
}
// hostPort just keeps a hostname and port together
hostPort struct {
host, port string
}
)
// newParser makes a new parser and prepares it for parsing, given
// the input to parse.
func newParser(file *os.File) (*parser, error) {
stat, err := file.Stat()
if err != nil {
return nil, err
}
p := &parser{filename: stat.Name()}
p.lexer.load(file)
return p, nil
}
// Parse parses the configuration file. It produces a slice of Config
// structs which can be used to create and configure server instances.
func (p *parser) parse() ([]Config, error) {
var configs []Config
for p.lexer.next() {
err := p.parseOne()
if err != nil {
return nil, err
}
configs = append(configs, p.cfgs...)
}
return configs, nil
}
// nextArg loads the next token if it is on the same line.
// Returns true if a token was loaded; false otherwise.
func (p *parser) nextArg() bool {
if p.unused != nil {
return false
}
line, tkn := p.line(), p.lexer.token
if p.next() {
if p.line() > line {
p.unused = &tkn
return false
}
return true
}
return false
}
// next loads the next token and returns true if a token
// was loaded; false otherwise.
func (p *parser) next() bool {
if p.unused != nil {
p.unused = nil
return true
} else {
return p.lexer.next()
}
}
// parseOne parses the contents of a configuration
// file for a single Config object (each server or
// virtualhost instance gets their own Config struct),
// which is until the next address/server block.
// Call this only when you know that the lexer has another
// another token and you're not in another server
// block already.
func (p *parser) parseOne() error {
p.cfgs = []Config{}
p.cfg = Config{
Middleware: make(map[string][]middleware.Middleware),
}
p.other = []locationContext{}
err := p.begin()
if err != nil {
return err
}
err = p.unwrap()
if err != nil {
return err
}
// Make a copy of the config for each
// address that will be using it
for _, hostport := range p.hosts {
cfgCopy := p.cfg
cfgCopy.Host = hostport.host
cfgCopy.Port = hostport.port
p.cfgs = append(p.cfgs, cfgCopy)
}
return nil
}
// unwrap gets the middleware generators from the middleware
// package in the order in which they are registered, and
// executes the top-level functions (the generator function)
// to expose the second layers which are the actual middleware.
// This function should be called only after p has filled out
// p.other and the entire server block has already been consumed.
func (p *parser) unwrap() error {
if len(p.other) == 0 {
// no middlewares were invoked
return nil
}
for _, directive := range registry.ordered {
// TODO: For now, we only support the first and default path scope ("/", held in p.other[0])
// but when we implement support for path scopes, we will have to change this logic
// to loop over them and order them. We need to account for situations where multiple
// path scopes overlap, regex (??), etc...
if disp, ok := p.other[0].directives[directive]; ok {
if generator, ok := registry.directiveMap[directive]; ok {
mid, err := generator(disp)
if err != nil {
return err
}
if mid != nil {
// TODO: Again, we assume the default path scope here...
p.cfg.Middleware[p.other[0].path] = append(p.cfg.Middleware[p.other[0].path], mid)
}
} else {
return errors.New("No middleware bound to directive '" + directive + "'")
}
}
}
return nil
}
// tkn is shorthand to get the text/value of the current token.
func (p *parser) tkn() string {
if p.unused != nil {
return p.unused.text
}
return p.lexer.token.text
}
// line is shorthand to get the line number of the current token.
func (p *parser) line() int {
if p.unused != nil {
return p.unused.line
}
return p.lexer.token.line
}
// syntaxErr creates a syntax error which explains what was
// found and expected.
func (p *parser) syntaxErr(expected string) error {
return p.err("Syntax", fmt.Sprintf("Unexpected token '%s', expecting '%s'", p.tkn(), expected))
}
// syntaxErr creates a syntax error that explains that there
// weren't enough arguments on the line.
func (p *parser) argErr() error {
return p.err("Syntax", "Unexpected line break after '"+p.tkn()+"' (missing arguments?)")
}
// eofErr creates a syntax error describing an unexpected EOF.
func (p *parser) eofErr() error {
return p.err("Syntax", "Unexpected EOF")
}
// err creates an error with a custom message msg: "{{kind}} error: {{msg}}". The
// file name and line number are included in the error message.
func (p *parser) err(kind, msg string) error {
msg = fmt.Sprintf("%s:%d - %s error: %s", p.filename, p.line(), kind, msg)
return errors.New(msg)
}
config/parser_test.go deleted 100644 → 0
View file @ 5f32f9b1
package config
import (
"os"
"strings"
"testing"
)
func TestNewParser(t *testing.T) {
filePath := "./parser_test.go"
expected := "parser_test.go"
file, err := os.Open(filePath)
if err != nil {
t.Fatal("Could not open file")
}
defer file.Close()
p, err := newParser(file)
if err != nil {
t.Fatal(err)
}
if p.filename != expected {
t.Errorf("Expected parser to have filename '%s' but had '%s'", expected, p.filename)
}
if p == nil {
t.Error("Expected parser to not be nil, but it was")
}
}
func TestParserBasic(t *testing.T) {
p := &parser{filename: "test"}
input := `localhost:1234
root /test/www
tls cert.pem key.pem`
p.lexer.load(strings.NewReader(input))
confs, err := p.parse()
if err != nil {
t.Fatalf("Expected no errors, but got '%s'", err)
}
conf := confs[0]
if conf.Host != "localhost" {
t.Errorf("Expected host to be 'localhost', got '%s'", conf.Host)
}
if conf.Port != "1234" {
t.Errorf("Expected port to be '1234', got '%s'", conf.Port)
}
if conf.Root != "/test/www" {
t.Errorf("Expected root to be '/test/www', got '%s'", conf.Root)
}
if !conf.TLS.Enabled {
t.Error("Expected TLS to be enabled, but it wasn't")
}
if conf.TLS.Certificate != "cert.pem" {
t.Errorf("Expected TLS certificate to be 'cert.pem', got '%s'", conf.TLS.Certificate)
}
if conf.TLS.Key != "key.pem" {
t.Errorf("Expected TLS server key to be 'key.pem', got '%s'", conf.TLS.Key)
}
}
func TestParserBasicWithMultipleServerBlocks(t *testing.T) {
p := &parser{filename: "test"}
input := `host1.com:443 {
root /test/www
tls cert.pem key.pem
}
host2:80 {
root "/test/my site"
}`
p.lexer.load(strings.NewReader(input))
confs, err := p.parse()
if err != nil {
t.Fatalf("Expected no errors, but got '%s'", err)
}
if len(confs) != 2 {
t.Fatalf("Expected 2 configurations, but got %d: %#v", len(confs), confs)
}
// First server
if confs[0].Host != "host1.com" {
t.Errorf("Expected first host to be 'host1.com', got '%s'", confs[0].Host)
}
if confs[0].Port != "443" {
t.Errorf("Expected first port to be '443', got '%s'", confs[0].Port)
}
if confs[0].Root != "/test/www" {
t.Errorf("Expected first root to be '/test/www', got '%s'", confs[0].Root)
}
if !confs[0].TLS.Enabled {
t.Error("Expected first TLS to be enabled, but it wasn't")
}
if confs[0].TLS.Certificate != "cert.pem" {
t.Errorf("Expected first TLS certificate to be 'cert.pem', got '%s'", confs[0].TLS.Certificate)
}
if confs[0].TLS.Key != "key.pem" {
t.Errorf("Expected first TLS server key to be 'key.pem', got '%s'", confs[0].TLS.Key)
}
// Second server
if confs[1].Host != "host2" {
t.Errorf("Expected second host to be 'host2', got '%s'", confs[1].Host)
}
if confs[1].Port != "80" {
t.Errorf("Expected second port to be '80', got '%s'", confs[1].Port)
}
if confs[1].Root != "/test/my site" {
t.Errorf("Expected second root to be '/test/my site', got '%s'", confs[1].Root)
}
if confs[1].TLS.Enabled {
t.Error("Expected second TLS to be disabled, but it was enabled")
}
if confs[1].TLS.Certificate != "" {
t.Errorf("Expected second TLS certificate to be '', got '%s'", confs[1].TLS.Certificate)
}
if confs[1].TLS.Key != "" {
t.Errorf("Expected second TLS server key to be '', got '%s'", confs[1].TLS.Key)
}
}
func TestParserBasicWithMultipleHostsPerBlock(t *testing.T) {
// This test is table-driven; it is expected that each
// input string produce the same set of configs.
for _, input := range []string{
`host1.com host2.com:1234
root /public_html`, // space-separated, no block
`host1.com, host2.com:1234
root /public_html`, // comma-separated, no block
`host1.com,
host2.com:1234
root /public_html`, // comma-separated, newlines, no block
`host1.com host2.com:1234 {
root /public_html
}`, // space-separated, block
`host1.com, host2.com:1234 {
root /public_html
}`, // comma-separated, block
`host1.com,
host2.com:1234 {
root /public_html
}`, // comma-separated, newlines, block
} {
p := &parser{filename: "test"}
p.lexer.load(strings.NewReader(input))
confs, err := p.parse()
if err != nil {
t.Fatalf("Expected no errors, but got '%s'", err)
}
if len(confs) != 2 {
t.Fatalf("Expected 2 configurations, but got %d: %#v", len(confs), confs)
}
if confs[0].Host != "host1.com" {
t.Errorf("Expected host of first conf to be 'host1.com', got '%s'", confs[0].Host)
}
if confs[0].Port != DefaultPort {
t.Errorf("Expected port of first conf to be '%s', got '%s'", DefaultPort, confs[0].Port)
}
if confs[0].Root != "/public_html" {
t.Errorf("Expected root of first conf to be '/public_html', got '%s'", confs[0].Root)
}
if confs[1].Host != "host2.com" {
t.Errorf("Expected host of second conf to be 'host2.com', got '%s'", confs[1].Host)
}
if confs[1].Port != "1234" {
t.Errorf("Expected port of second conf to be '1234', got '%s'", confs[1].Port)
}
if confs[1].Root != "/public_html" {
t.Errorf("Expected root of second conf to be '/public_html', got '%s'", confs[1].Root)
}
}
}
func TestParserBasicWithAlternateAddressStyles(t *testing.T) {
p := &parser{filename: "test"}
input := `http://host1.com, https://host2.com,
host3.com:http, host4.com:1234 {
root /test/www
}`
p.lexer.load(strings.NewReader(input))
confs, err := p.parse()
if err != nil {
t.Fatalf("Expected no errors, but got '%s'", err)
}
if len(confs) != 4 {
t.Fatalf("Expected 4 configurations, but got %d: %#v", len(confs), confs)
}
for _, conf := range confs {
if conf.Root != "/test/www" {
t.Fatalf("Expected root for conf of %s to be '/test/www', but got: %s", conf.Address(), conf.Root)
}
}
p = &parser{filename: "test"}
input = `host:port, http://host:port, http://host, https://host:port, host`
p.lexer.load(strings.NewReader(input))
confs, err = p.parse()
if err != nil {
t.Fatalf("Expected no errors, but got '%s'", err)
}
if len(confs) != 5 {
t.Fatalf("Expected 5 configurations, but got %d: %#v", len(confs), confs)
}
if confs[0].Host != "host" {
t.Errorf("Expected conf[0] Host='host', got '%#v'", confs[0])
}
if confs[0].Port != "port" {
t.Errorf("Expected conf[0] Port='port', got '%#v'", confs[0])
}
if confs[1].Host != "host" {
t.Errorf("Expected conf[1] Host='host', got '%#v'", confs[1])
}
if confs[1].Port != "port" {
t.Errorf("Expected conf[1] Port='port', got '%#v'", confs[1])
}
if confs[2].Host != "host" {
t.Errorf("Expected conf[2] Host='host', got '%#v'", confs[2])
}
if confs[2].Port != "http" {
t.Errorf("Expected conf[2] Port='http', got '%#v'", confs[2])
}
if confs[3].Host != "host" {
t.Errorf("Expected conf[3] Host='host', got '%#v'", confs[3])
}
if confs[3].Port != "port" {
t.Errorf("Expected conf[3] Port='port', got '%#v'", confs[3])
}
if confs[4].Host != "host" {
t.Errorf("Expected conf[4] Host='host', got '%#v'", confs[4])
}
if confs[4].Port != DefaultPort {
t.Errorf("Expected conf[4] Port='%s', got '%#v'", DefaultPort, confs[4].Port)
}
}
func TestParserImport(t *testing.T) {
p := &parser{filename: "test"}
input := `host:123
import import_test.txt`
p.lexer.load(strings.NewReader(input))
confs, err := p.parse()
if err != nil {
t.Fatalf("Expected no errors, but got '%s'", err)
}
conf := confs[0]
if conf.Host != "host" {
t.Errorf("Expected host to be 'host', got '%s'", conf.Host)
}
if conf.Port != "123" {
t.Errorf("Expected port to be '123', got '%s'", conf.Port)
}
if conf.Root != "/test/imported/public_html" {
t.Errorf("Expected root to be '/test/imported/public_html', got '%s'", conf.Root)
}
if conf.TLS.Enabled {
t.Error("Expected TLS to be disabled, but it was enabled")
}
if conf.TLS.Certificate != "" {
t.Errorf("Expected TLS certificate to be '', got '%s'", conf.TLS.Certificate)
}
if conf.TLS.Key != "" {
t.Errorf("Expected TLS server key to be '', got '%s'", conf.TLS.Key)
}
}
func TestParserLocationContext(t *testing.T) {
p := &parser{filename: "test"}
input := `host:123 {
/scope {
gzip
}
}`
p.lexer.load(strings.NewReader(input))
confs, err := p.parse()
if err != nil {
t.Fatalf("Expected no errors, but got '%s'", err)
}
if len(confs) != 1 {
t.Fatalf("Expected 1 configuration, but got %d: %#v", len(confs), confs)
}
if len(p.other) != 2 {
t.Fatalf("Expected 2 path scopes, but got %d: %#v", len(p.other), p.other)
}
if p.other[0].path != "/" {
t.Fatalf("Expected first path scope to be default '/', but got %v: %#v", p.other[0].path, p.other)
}
if p.other[1].path != "/scope" {
t.Fatalf("Expected first path scope to be '/scope', but got %v: %#v", p.other[0].path, p.other)
}
if dir, ok := p.other[1].directives["gzip"]; !ok {
t.Fatalf("Expected scoped directive to be gzip, but got %v: %#v", dir, p.other[1].directives)
}
}
config/parsing.go deleted 100644 → 0
View file @ 5f32f9b1
package config
import (
"errors"
"net"
"strings"
)
// This file contains the recursive-descent parsing
// functions.
// begin is the top of the recursive-descent parsing.
// It parses at most one server configuration (an address
// and its directives).
func (p *parser) begin() error {
err := p.addresses()
if err != nil {
return err
}
err = p.addressBlock()
if err != nil {
return err
}
return nil
}
// addresses expects that the current token is a
// "scheme://host:port" combination (the "scheme://"
// and/or ":port" portions may be omitted). If multiple
// addresses are specified, they must be space-
// separated on the same line, or each token must end
// with a comma.
func (p *parser) addresses() error {
var expectingAnother bool
p.hosts = []hostPort{}
// address gets host and port in a format accepted by net.Dial
address := func(str string) (host, port string, err error) {
var schemePort string
if strings.HasPrefix(str, "https://") {
schemePort = "https"
str = str[8:]
} else if strings.HasPrefix(str, "http://") {
schemePort = "http"
str = str[7:]
} else if !strings.Contains(str, ":") {
str += ":" + Port
}
host, port, err = net.SplitHostPort(str)
if err != nil && schemePort != "" {
host = str
port = schemePort // assume port from scheme
err = nil
}
return
}
for {
tkn, startLine := p.tkn(), p.line()
// Open brace definitely indicates end of addresses
if tkn == "{" {
if expectingAnother {
return p.err("Syntax", "Expected another address but had '"+tkn+"' - check for extra comma")
}
break
}
// Trailing comma indicates another address will follow, which
// may possibly be on the next line
if tkn[len(tkn)-1] == ',' {
tkn = tkn[:len(tkn)-1]
expectingAnother = true
} else {
expectingAnother = false // but we may still see another one on this line
}
// Parse and save this address
host, port, err := address(tkn)
if err != nil {
return err
}
p.hosts = append(p.hosts, hostPort{host, port})
// Advance token and possibly break out of loop or return error
hasNext := p.next()
if expectingAnother && !hasNext {
return p.eofErr()
}
if !expectingAnother && p.line() > startLine {
break
}
if !hasNext {
p.eof = true
break // EOF
}
}
return nil
}
// addressBlock leads into parsing directives, including
// possible opening/closing curly braces around the block.
// It handles directives enclosed by curly braces and
// directives not enclosed by curly braces. It is expected
// that the current token is already the beginning of
// the address block.
func (p *parser) addressBlock() error {
errOpenCurlyBrace := p.openCurlyBrace()
if errOpenCurlyBrace != nil {
// meh, single-server configs don't need curly braces
// but we read a token and we won't consume it; mark it unused
p.unused = &p.lexer.token
}
// When we enter an address block, we also implicitly
// enter a path block where the path is all paths ("/")
p.other = append(p.other, locationContext{
path: "/",
directives: make(map[string]*controller),
})
p.scope = &p.other[0]
if p.eof {
// this happens if the Caddyfile consists of only
// a line of addresses and nothing else
return nil
}
err := p.directives()
if err != nil {
return err
}
// Only look for close curly brace if there was an opening
if errOpenCurlyBrace == nil {
err = p.closeCurlyBrace()
if err != nil {
return err
}
}
return nil
}
// openCurlyBrace expects the current token to be an
// opening curly brace. This acts like an assertion
// because it returns an error if the token is not
// a opening curly brace. It does not advance the token.
func (p *parser) openCurlyBrace() error {
if p.tkn() != "{" {
return p.syntaxErr("{")
}
return nil
}
// closeCurlyBrace expects the current token to be
// a closing curly brace. This acts like an assertion
// because it returns an error if the token is not
// a closing curly brace. It does not advance the token.
func (p *parser) closeCurlyBrace() error {
if p.tkn() != "}" {
return p.syntaxErr("}")
}
return nil
}
// directives parses through all the directives
// and it expects the current token to be the first
// directive. It goes until EOF or closing curly
// brace which ends the address block.
func (p *parser) directives() error {
for p.next() {
if p.tkn() == "}" {
// end of address scope
break
}
if p.tkn()[0] == '/' || p.tkn()[0] == '*' {
// Path scope (a.k.a. location context)
// Starts with / ('starts with') or * ('ends with').
// TODO: The parser can handle the syntax (obviously), but the
// implementation is incomplete. This is intentional,
// until we can better decide what kind of feature set we
// want to support and how exactly we want these location
// scopes to work. Until this is ready, we leave this
// syntax undocumented. Some changes will need to be
// made in parser.go also (the unwrap function) and
// probably in server.go when we do this... see those TODOs.
var scope *locationContext
// If the path block is a duplicate, append to existing one
for i := 0; i < len(p.other); i++ {
if p.other[i].path == p.tkn() {
scope = &p.other[i]
break
}
}
// Otherwise, for a new path we haven't seen before, create a new context
if scope == nil {
scope = &locationContext{
path: p.tkn(),
directives: make(map[string]*controller),
}
}
// Consume the opening curly brace
if !p.next() {
return p.eofErr()
}
err := p.openCurlyBrace()
if err != nil {
return err
}
// Use this path scope as our current context for just a moment
p.scope = scope
// Consume each directive in the path block
for p.next() {
err := p.closeCurlyBrace()
if err == nil {
break
}
err = p.directive()
if err != nil {
return err
}
}
// Save the new scope and put the current scope back to "/"
p.other = append(p.other, *scope)
p.scope = &p.other[0]
} else if err := p.directive(); err != nil {
return err
}
}
return nil
}
// directive asserts that the current token is either a built-in
// directive or a registered middleware directive; otherwise an error
// will be returned. If it is a valid directive, tokens will be
// collected.
func (p *parser) directive() error {
if fn, ok := validDirectives[p.tkn()]; ok {
// Built-in (standard, or 'core') directive
err := fn(p)
if err != nil {
return err
}
} else if middlewareRegistered(p.tkn()) {
// Middleware directive
err := p.collectTokens()
if err != nil {
return err
}
} else {
return p.err("Syntax", "Unexpected token '"+p.tkn()+"', expecting a valid directive")
}
return nil
}
// collectTokens consumes tokens until the directive's scope
// closes (either end of line or end of curly brace block).
// It creates a controller which is stored in the parser for
// later use by the middleware.
func (p *parser) collectTokens() error {
if p.scope == nil {
return errors.New("Current scope cannot be nil")
}
directive := p.tkn()
line := p.line()
nesting := 0
cont := newController(p)
// Re-use a duplicate directive's controller from before
// (the parsing logic in the middleware generator must
// account for multiple occurrences of its directive, even
// if that means returning an error or overwriting settings)
if existing, ok := p.scope.directives[directive]; ok {
cont = existing
}
// The directive is appended as a relevant token
cont.tokens = append(cont.tokens, p.lexer.token)
for p.next() {
if p.tkn() == "{" {
nesting++
} else if p.line() > line && nesting == 0 {
p.unused = &p.lexer.token
break
} else if p.tkn() == "}" && nesting > 0 {
nesting--
} else if p.tkn() == "}" && nesting == 0 {
return p.err("Syntax", "Unexpected '}' because no matching opening brace")
}
cont.tokens = append(cont.tokens, p.lexer.token)
}
if nesting > 0 {
return p.eofErr()
}
p.scope.directives[directive] = cont
return nil
}
main.go
View file @ 995edf05
......@@ -6,6 +6,8 @@ import (
"fmt"
"log"
"net"
"os"
"path"
"runtime"
"strconv"
"strings"
......@@ -23,10 +25,11 @@ var (
)
func init() {
flag.StringVar(&conf, "conf", config.DefaultConfigFile, "the configuration file to use")
flag.BoolVar(&http2, "http2", true, "enable HTTP/2 support") // TODO: temporary flag until http2 merged into std lib
flag.BoolVar(&quiet, "quiet", false, "quiet mode (no initialization output)")
flag.StringVar(&conf, "conf", config.DefaultConfigFile, "The configuration file to use")
flag.BoolVar(&http2, "http2", true, "Enable HTTP/2 support") // TODO: temporary flag until http2 merged into std lib
flag.BoolVar(&quiet, "quiet", false, "Quiet mode (no initialization output)")
flag.StringVar(&cpu, "cpu", "100%", "CPU cap")
flag.StringVar(&config.Root, "root", config.DefaultRoot, "Root path to default site")
flag.StringVar(&config.Host, "host", config.DefaultHost, "Default host")
flag.StringVar(&config.Port, "port", config.DefaultPort, "Default port")
flag.Parse()
......@@ -42,16 +45,9 @@ func main() {
}
// Load config from file
allConfigs, err := config.Load(conf)
allConfigs, err := loadConfigs(conf)
if err != nil {
if config.IsNotFound(err) {
allConfigs = config.Default()
} else {
log.Fatal(err)
}
}
if len(allConfigs) == 0 {
allConfigs = config.Default()
log.Fatal(err)
}
// Group by address (virtual hosts)
......@@ -86,13 +82,45 @@ func main() {
wg.Wait()
}
// loadConfigs loads configuration from a file.
func loadConfigs(confPath string) ([]server.Config, error) {
var allConfigs []server.Config
file, err := os.Open(confPath)
if err == nil {
defer file.Close()
allConfigs, err = config.Load(path.Base(confPath), file)
if err != nil {
return allConfigs, err
}
} else {
if os.IsNotExist(err) {
// This is only a problem if the user
// explicitly specified a config file
if confPath != config.DefaultConfigFile {
return allConfigs, err
}
} else {
// ... but anything else is always a problem
return allConfigs, err
}
}
// If config file was empty or didn't exist, use default
if len(allConfigs) == 0 {
allConfigs = []server.Config{config.Default()}
}
return allConfigs, nil
}
// arrangeBindings groups configurations by their bind address. For example,
// a server that should listen on localhost and another on 127.0.0.1 will
// be grouped into the same address: 127.0.0.1. It will return an error
// if the address lookup fails or if a TLS listener is configured on the
// same address as a plaintext HTTP listener.
func arrangeBindings(allConfigs []config.Config) (map[string][]config.Config, error) {
addresses := make(map[string][]config.Config)
func arrangeBindings(allConfigs []server.Config) (map[string][]server.Config, error) {
addresses := make(map[string][]server.Config)
// Group configs by bind address
for _, conf := range allConfigs {
......
middleware/basicauth/basicauth.go
View file @ 995edf05
......@@ -7,21 +7,14 @@ import (
"github.com/mholt/caddy/middleware"
)
// New constructs a new BasicAuth middleware instance.
func New(c middleware.Controller) (middleware.Middleware, error) {
rules, err := parse(c)
if err != nil {
return nil, err
}
basic := BasicAuth{
Rules: rules,
}
return func(next middleware.Handler) middleware.Handler {
basic.Next = next
return basic
}, nil
// BasicAuth is middleware to protect resources with a username and password.
// Note that HTTP Basic Authentication is not secure by itself and should
// not be used to protect important assets without HTTPS. Even then, the
// security of HTTP Basic Auth is disputed. Use discretion when deciding
// what to protect with BasicAuth.
type BasicAuth struct {
Next middleware.Handler
Rules []Rule
}
// ServeHTTP implements the middleware.Handler interface.
......@@ -50,48 +43,6 @@ func (a BasicAuth) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error
return a.Next.ServeHTTP(w, r)
}
func parse(c middleware.Controller) ([]Rule, error) {
var rules []Rule
for c.Next() {
var rule Rule
args := c.RemainingArgs()
switch len(args) {
case 2:
rule.Username = args[0]
rule.Password = args[1]
for c.NextBlock() {
rule.Resources = append(rule.Resources, c.Val())
if c.NextArg() {
return rules, c.Err("Expecting only one resource per line (extra '" + c.Val() + "')")
}
}
case 3:
rule.Resources = append(rule.Resources, args[0])
rule.Username = args[1]
rule.Password = args[2]
default:
return rules, c.ArgErr()
}
rules = append(rules, rule)
}
return rules, nil
}
// BasicAuth is middleware to protect resources with a username and password.
// Note that HTTP Basic Authentication is not secure by itself and should
// not be used to protect important assets without HTTPS. Even then, the
// security of HTTP Basic Auth is disputed. Use discretion when deciding
// what to protect with BasicAuth.
type BasicAuth struct {
Next middleware.Handler
Rules []Rule
}
// Rule represents a BasicAuth rule. A username and password
// combination protect the associated resources, which are
// file or directory paths.
......
middleware/errors/errors.go
View file @ 995edf05
......@@ -7,45 +7,10 @@ import (
"log"
"net/http"
"os"
"path"
"strconv"
"github.com/mholt/caddy/middleware"
)
// New instantiates a new instance of error-handling middleware.
func New(c middleware.Controller) (middleware.Middleware, error) {
handler, err := parse(c)
if err != nil {
return nil, err
}
// Open the log file for writing when the server starts
c.Startup(func() error {
var err error
var file *os.File
if handler.LogFile == "stdout" {
file = os.Stdout
} else if handler.LogFile == "stderr" {
file = os.Stderr
} else if handler.LogFile != "" {
file, err = os.OpenFile(handler.LogFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
return err
}
}
handler.Log = log.New(file, "", 0)
return nil
})
return func(next middleware.Handler) middleware.Handler {
handler.Next = next
return handler
}, nil
}
// ErrorHandler handles HTTP errors (or errors from other middleware).
type ErrorHandler struct {
Next middleware.Handler
......@@ -113,63 +78,4 @@ func (h ErrorHandler) errorPage(w http.ResponseWriter, code int) {
http.Error(w, defaultBody, code)
}
func parse(c middleware.Controller) (*ErrorHandler, error) {
// Very important that we make a pointer because the Startup
// function that opens the log file must have access to the
// same instance of the handler, not a copy.
handler := &ErrorHandler{ErrorPages: make(map[int]string)}
optionalBlock := func() (bool, error) {
var hadBlock bool
for c.NextBlock() {
hadBlock = true
what := c.Val()
if !c.NextArg() {
return hadBlock, c.ArgErr()
}
where := c.Val()
if what == "log" {
handler.LogFile = where
} else {
// Error page; ensure it exists
where = path.Join(c.Root(), where)
f, err := os.Open(where)
if err != nil {
return hadBlock, c.Err("Unable to open error page '" + where + "': " + err.Error())
}
f.Close()
whatInt, err := strconv.Atoi(what)
if err != nil {
return hadBlock, c.Err("Expecting a numeric status code, got '" + what + "'")
}
handler.ErrorPages[whatInt] = where
}
}
return hadBlock, nil
}
for c.Next() {
// Configuration may be in a block
hadBlock, err := optionalBlock()
if err != nil {
return handler, err
}
// Otherwise, the only argument would be an error log file name
if !hadBlock {
if c.NextArg() {
handler.LogFile = c.Val()
} else {
handler.LogFile = defaultLogFilename
}
}
}
return handler, nil
}
const defaultLogFilename = "error.log"
const DefaultLogFilename = "error.log"
middleware/gzip/gzip.go
View file @ 995edf05
......@@ -20,13 +20,6 @@ type Gzip struct {
Next middleware.Handler
}
// New creates a new gzip middleware instance.
func New(c middleware.Controller) (middleware.Middleware, error) {
return func(next middleware.Handler) middleware.Handler {
return Gzip{Next: next}
}, nil
}
// ServeHTTP serves a gzipped response if the client supports it.
func (g Gzip) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
if !strings.Contains(r.Header.Get("Accept-Encoding"), "gzip") {
......
middleware/headers/headers.go
View file @ 995edf05
......@@ -13,7 +13,7 @@ import (
// for requests matching a certain path.
type Headers struct {
Next middleware.Handler
Rules []HeaderRule
Rules []Rule
}
// ServeHTTP implements the middleware.Handler interface and serves requests,
......@@ -30,9 +30,9 @@ func (h Headers) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error)
}
type (
// HeaderRule groups a slice of HTTP headers by a URL pattern.
// Rule groups a slice of HTTP headers by a URL pattern.
// TODO: use http.Header type instead?
HeaderRule struct {
Rule struct {
Url string
Headers []Header
}
......
middleware/headers/new.go deleted 100644 → 0
View file @ 5f32f9b1
package headers
import "github.com/mholt/caddy/middleware"
// New constructs and configures a new headers middleware instance.
func New(c middleware.Controller) (middleware.Middleware, error) {
rules, err := parse(c)
if err != nil {
return nil, err
}
return func(next middleware.Handler) middleware.Handler {
return Headers{Next: next, Rules: rules}
}, nil
}
middleware/headers/parse.go deleted 100644 → 0
View file @ 5f32f9b1
package headers
import "github.com/mholt/caddy/middleware"
func parse(c middleware.Controller) ([]HeaderRule, error) {
var rules []HeaderRule
for c.NextLine() {
var head HeaderRule
var isNewPattern bool
if !c.NextArg() {
return rules, c.ArgErr()
}
pattern := c.Val()
// See if we already have a definition for this URL pattern...
for _, h := range rules {
if h.Url == pattern {
head = h
break
}
}
// ...otherwise, this is a new pattern
if head.Url == "" {
head.Url = pattern
isNewPattern = true
}
for c.NextBlock() {
// A block of headers was opened...
h := Header{Name: c.Val()}
if c.NextArg() {
h.Value = c.Val()
}
head.Headers = append(head.Headers, h)
}
if c.NextArg() {
// ... or single header was defined as an argument instead.
h := Header{Name: c.Val()}
h.Value = c.Val()
if c.NextArg() {
h.Value = c.Val()
}
head.Headers = append(head.Headers, h)
}
if isNewPattern {
rules = append(rules, head)
} else {
for i := 0; i < len(rules); i++ {
if rules[i].Url == pattern {
rules[i] = head
break
}
}
}
}
return rules, nil
}
middleware/log/log.go
View file @ 995edf05
......@@ -4,44 +4,13 @@ package log
import (
"log"
"net/http"
"os"
"github.com/mholt/caddy/middleware"
)
// New instantiates a new instance of logging middleware.
func New(c middleware.Controller) (middleware.Middleware, error) {
rules, err := parse(c)
if err != nil {
return nil, err
}
// Open the log files for writing when the server starts
c.Startup(func() error {
for i := 0; i < len(rules); i++ {
var err error
var file *os.File
if rules[i].OutputFile == "stdout" {
file = os.Stdout
} else if rules[i].OutputFile == "stderr" {
file = os.Stderr
} else {
file, err = os.OpenFile(rules[i].OutputFile, os.O_RDWR|os.O_CREATE|os.O_APPEND, 0644)
if err != nil {
return err
}
}
rules[i].Log = log.New(file, "", 0)
}
return nil
})
return func(next middleware.Handler) middleware.Handler {
return Logger{Next: next, Rules: rules}
}, nil
type Logger struct {
Next middleware.Handler
Rules []LogRule
}
func (l Logger) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
......@@ -57,58 +26,6 @@ func (l Logger) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
return l.Next.ServeHTTP(w, r)
}
func parse(c middleware.Controller) ([]LogRule, error) {
var rules []LogRule
for c.Next() {
args := c.RemainingArgs()
if len(args) == 0 {
// Nothing specified; use defaults
rules = append(rules, LogRule{
PathScope: "/",
OutputFile: defaultLogFilename,
Format: defaultLogFormat,
})
} else if len(args) == 1 {
// Only an output file specified
rules = append(rules, LogRule{
PathScope: "/",
OutputFile: args[0],
Format: defaultLogFormat,
})
} else {
// Path scope, output file, and maybe a format specified
format := defaultLogFormat
if len(args) > 2 {
switch args[2] {
case "{common}":
format = commonLogFormat
case "{combined}":
format = combinedLogFormat
default:
format = args[2]
}
}
rules = append(rules, LogRule{
PathScope: args[0],
OutputFile: args[1],
Format: format,
})
}
}
return rules, nil
}
type Logger struct {
Next middleware.Handler
Rules []LogRule
}
type LogRule struct {
PathScope string
OutputFile string
......@@ -117,8 +34,8 @@ type LogRule struct {
}
const (
defaultLogFilename = "access.log"
commonLogFormat = `{remote} ` + middleware.EmptyStringReplacer + ` [{when}] "{method} {uri} {proto}" {status} {size}`
combinedLogFormat = commonLogFormat + ` "{>Referer}" "{>User-Agent}"`
defaultLogFormat = commonLogFormat
DefaultLogFilename = "access.log"
CommonLogFormat = `{remote} ` + middleware.EmptyStringReplacer + ` [{when}] "{method} {uri} {proto}" {status} {size}`
CombinedLogFormat = CommonLogFormat + ` "{>Referer}" "{>User-Agent}"`
DefaultLogFormat = CommonLogFormat
)
middleware/redirect/redirect.go
View file @ 995edf05
......@@ -9,18 +9,6 @@ import (
"github.com/mholt/caddy/middleware"
)
// New instantiates a new Redirect middleware.
func New(c middleware.Controller) (middleware.Middleware, error) {
rules, err := parse(c)
if err != nil {
return nil, err
}
return func(next middleware.Handler) middleware.Handler {
return Redirect{Next: next, Rules: rules}
}, nil
}
// Redirect is middleware to respond with HTTP redirects
type Redirect struct {
Next middleware.Handler
......@@ -43,65 +31,8 @@ func (rd Redirect) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error
return rd.Next.ServeHTTP(w, r)
}
func parse(c middleware.Controller) ([]Rule, error) {
var redirects []Rule
for c.Next() {
var rule Rule
args := c.RemainingArgs()
switch len(args) {
case 1:
// To specified
rule.From = "/"
rule.To = args[0]
rule.Code = http.StatusMovedPermanently
case 2:
// To and Code specified
rule.From = "/"
rule.To = args[0]
if code, ok := httpRedirs[args[1]]; !ok {
return redirects, c.Err("Invalid redirect code '" + args[1] + "'")
} else {
rule.Code = code
}
case 3:
// From, To, and Code specified
rule.From = args[0]
rule.To = args[1]
if code, ok := httpRedirs[args[2]]; !ok {
return redirects, c.Err("Invalid redirect code '" + args[2] + "'")
} else {
rule.Code = code
}
default:
return redirects, c.ArgErr()
}
if rule.From == rule.To {
return redirects, c.Err("Redirect rule cannot allow From and To arguments to be the same.")
}
redirects = append(redirects, rule)
}
return redirects, nil
}
// Rule describes an HTTP redirect rule.
type Rule struct {
From, To string
Code int
}
// httpRedirs is a list of supported HTTP redirect codes.
var httpRedirs = map[string]int{
"300": 300,
"301": 301,
"302": 302,
"303": 303,
"304": 304,
"305": 305,
"307": 307,
"308": 308,
}
middleware/rewrite/rewrite.go
View file @ 995edf05
......@@ -8,22 +8,10 @@ import (
"github.com/mholt/caddy/middleware"
)
// New instantiates a new Rewrites middleware.
func New(c middleware.Controller) (middleware.Middleware, error) {
rewrites, err := parse(c)
if err != nil {
return nil, err
}
return func(next middleware.Handler) middleware.Handler {
return Rewrite{Next: next, Rules: rewrites}
}, nil
}
// Rewrite is middleware to rewrite request locations internally before being handled.
type Rewrite struct {
Next middleware.Handler
Rules []RewriteRule
Rules []Rule
}
// ServeHTTP implements the middleware.Handler interface.
......@@ -37,29 +25,7 @@ func (rw Rewrite) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error)
return rw.Next.ServeHTTP(w, r)
}
func parse(c middleware.Controller) ([]RewriteRule, error) {
var rewrites []RewriteRule
for c.Next() {
var rule RewriteRule
if !c.NextArg() {
return rewrites, c.ArgErr()
}
rule.From = c.Val()
if !c.NextArg() {
return rewrites, c.ArgErr()
}
rule.To = c.Val()
rewrites = append(rewrites, rule)
}
return rewrites, nil
}
// RewriteRule describes an internal location rewrite rule.
type RewriteRule struct {
// A Rule describes an internal location rewrite rule.
type Rule struct {
From, To string
}
server/server.go
View file @ 995edf05
......@@ -13,7 +13,6 @@ import (
"os/signal"
"github.com/bradfitz/http2"
"github.com/mholt/caddy/config"
)
// Server represents an instance of a server, which serves
......@@ -28,7 +27,7 @@ type Server struct {
// New creates a new Server which will bind to addr and serve
// the sites/hosts configured in configs. This function does
// not start serving.
func New(addr string, configs []config.Config, tls bool) (*Server, error) {
func New(addr string, configs []Config, tls bool) (*Server, error) {
s := &Server{
address: addr,
tls: tls,
......@@ -93,7 +92,7 @@ func (s *Server) Serve() error {
}
if s.tls {
var tlsConfigs []config.TLSConfig
var tlsConfigs []TLSConfig
for _, vh := range s.vhosts {
tlsConfigs = append(tlsConfigs, vh.config.TLS)
}
......@@ -107,7 +106,7 @@ func (s *Server) Serve() error {
// multiple sites (different hostnames) to be served from the same address. This method is
// adapted directly from the std lib's net/http ListenAndServeTLS function, which was
// written by the Go Authors. It has been modified to support multiple certificate/key pairs.
func ListenAndServeTLSWithSNI(srv *http.Server, tlsConfigs []config.TLSConfig) error {
func ListenAndServeTLSWithSNI(srv *http.Server, tlsConfigs []TLSConfig) error {
addr := srv.Addr
if addr == "" {
addr = ":https"
......
server/virtualhost.go
View file @ 995edf05
......@@ -3,7 +3,6 @@ package server
import (
"net/http"
"github.com/mholt/caddy/config"
"github.com/mholt/caddy/middleware"
)
......@@ -12,7 +11,7 @@ import (
// multiple sites on a single address, and this is what a
// virtualHost allows us to do.
type virtualHost struct {
config config.Config
config Config
fileServer middleware.Handler
stack middleware.Handler
}
......
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment
GitLab Nexedi Edition | About GitLab | About Nexedi | 沪ICP备2021021310号-2 | 沪ICP备2021021310号-7