first set of corpuses

.gitignore

@@ -1,14 +0,0 @@
-.DS_Store
-Thumbs.db
-_gitignore/
-Vagrantfile
-.vagrant/
-
-dist/builds/
-dist/release/
-
-error.log
-access.log
-
-/*.conf
-Caddyfile

.travis.yml

@@ -1,2 +0,0 @@
-language: go
-script: go test ./...

CONTRIBUTING.md

@@ -1,32 +0,0 @@
-## Contributing to Caddy
-
-**[Join us on Slack](https://gophers.slack.com/messages/caddy/)** to chat with other Caddy developers! ([Request an invite](http://bit.ly/go-slack-signup), then join the #caddy channel.)
-
-This project gladly accepts contributions and we encourage interested users to get involved!
-
-
-#### For small tweaks, bug fixes, and tests
-
-Submit [pull requests](https://github.com/mholt/caddy/pulls) at any time. Thank you for helping out in simple ways! Bug fixes should be under test to assert correct behavior.
-
-
-#### Ideas, questions, bug reports
-
-You should totally [open an issue](https://github.com/mholt/caddy/issues) with your ideas, questions, and bug reports, if one does not already exist for it. Bug reports should state expected behavior and contain clear instructions for reproducing the problem.
-
-
-#### New features
-
-Before submitting a pull request, please open an issue first to discuss it and claim it. This prevents overlapping efforts and keeps the project in-line with its goals. If you prefer to discuss the feature privately, you can reach other developers on Slack or you may email me directly. (My email address is below.)
-
-And don't forget to write tests for new features!
-
-
-#### Vulnerabilities
-
-If you've found a vulnerability that is serious, please email me: Matthew dot Holt at Gmail. If it's not a big deal, a pull request will probably be faster.
-
-
-## Thank you
-
-Thanks for your help! Caddy would not be what it is today without your contributions.

LICENSE.md

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright {yyyy} {name of copyright owner}
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

README.md

@@ -1,129 +0,0 @@
-[![Caddy](https://caddyserver.com/resources/images/caddy-boxed.png)](https://caddyserver.com)
-
-[![Documentation](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat-square)](https://godoc.org/github.com/mholt/caddy) [![Build Status](https://img.shields.io/travis/mholt/caddy.svg?style=flat-square)](https://travis-ci.org/mholt/caddy)
-
-Caddy is a lightweight, general-purpose web server for Windows, Mac, Linux, BSD, and [Android](https://github.com/mholt/caddy/wiki/Running-Caddy-on-Android). It is a capable alternative to other popular and easy to use web servers.
-
-The most notable features are HTTP/2, Virtual Hosts, TLS + SNI, and easy configuration with a [Caddyfile](https://caddyserver.com/docs/caddyfile). Usually, you have one Caddyfile per site. Most directives for the Caddyfile invoke a layer of middleware which can be [used in your own Go programs](https://github.com/mholt/caddy/wiki/Using-Caddy-Middleware-in-Your-Own-Programs).
-
-[Download](https://github.com/mholt/caddy/releases) · [User Guide](https://caddyserver.com/docs)
-
-
-
-
-### Menu
-
-- [Getting Caddy](#getting-caddy)
-- [Running from Source](#running-from-source)
-- [Quick Start](#quick-start)
-- [Contributing](#contributing)
-- [About the Project](#about-the-project)
-
-
-
-
-## Getting Caddy
-
-Caddy binaries have no dependencies and are available for nearly every platform.
-
-[Latest release](https://github.com/mholt/caddy/releases/latest)
-
-
-## Running from Source
-
-Note: You will need **[Go 1.4](https://golang.org/dl)** or newer
-
-1. `$ go get github.com/mholt/caddy`
-2. `cd` into your website's directory
-3. Run `caddy` (assumes `$GOPATH/bin` is in your `$PATH`)
-
-If you're tinkering, you can also use `go run main.go`.
-
-By default, Caddy serves the current directory at [localhost:2015](http://localhost:2015). You can place a Caddyfile to configure Caddy for serving your site.
-
-Caddy accepts some flags from the command line. Run `caddy -h` to view the help for flags. You can also pipe a Caddyfile into the caddy command.
-
-
-
-#### Docker Container
-
-Caddy is available as a Docker container from any of these sources:
-
-- [abiosoft/caddy](https://registry.hub.docker.com/u/abiosoft/caddy/)
-- [darron/caddy](https://registry.hub.docker.com/u/darron/caddy/)
-- [jumanjiman/caddy](https://registry.hub.docker.com/u/jumanjiman/caddy/)
-
-
-
-#### 3rd-party libraries
-
-Although Caddy's binaries are completely static, Caddy relies on some excellent libraries. [Godoc.org](https://godoc.org/github.com/mholt/caddy) shows the packages that each Caddy package imports.
-
-
-
-
-## Quick Start
-
-The website has [full documentation](https://caddyserver.com/docs) but this will get you started in about 30 seconds:
-
-Place a file named "Caddyfile" with your site. Paste this into it and save:
-
-```
-localhost
-
-gzip
-browse
-ext .html
-websocket /echo cat
-log ../access.log
-header /api Access-Control-Allow-Origin *
-```
-
-Run `caddy` from that directory, and it will automatically use that Caddyfile to configure itself.
-
-That simple file enables compression, allows directory browsing (for folders without an index file), serves clean URLs, hosts an echo server for WebSocket connections at /echo, logs accesses to access.log, and adds the coveted `Access-Control-Allow-Origin: *` header for all responses from some API.
-
-Wow! Caddy can do a lot with just a few lines.
-
-#### Defining multiple sites
-
-You can run multiple sites from the same Caddyfile, too:
-
-```
-http://mysite.com,
-http://www.mysite.com {
-	redir https://mysite.com
-}
-
-https://mysite.com {
-	tls mysite.crt mysite.key
-	# ...
-}
-```
-
-Note that the secure host will automatically be served with HTTP/2 if the client supports it.
-
-For more documentation, please view [the website](https://caddyserver.com/docs). You may also be interested in the [developer guide](https://github.com/mholt/caddy/wiki) on this project's GitHub wiki.
-
-
-
-
-
-
-## Contributing
-
-**[Join us on Slack](https://gophers.slack.com/messages/caddy/)** to chat with other Caddy developers! ([Request an invite](http://bit.ly/go-slack-signup), then join the #caddy channel.)
-
-This project would not be what it is without your help. Please see the [contributing guidelines](https://github.com/mholt/caddy/blob/master/CONTRIBUTING.md) if you haven't already.
-
-Thanks for making Caddy -- and the Web -- better!
-
-
-
-
-## About the project
-
-Caddy was born out of the need for a "batteries-included" web server that runs anywhere and doesn't have to take its configuration with it. Caddy took inspiration from [spark](https://github.com/rif/spark), nginx, lighttpd, Websocketd, and Vagrant, and provides a pleasant mixture of features from each of them.
-
-
-*Twitter: [@mholt6](https://twitter.com/mholt6)*

app/app.go

@@ -1,76 +0,0 @@
-// Package app holds application-global state to make it accessible
-// by other packages in the application.
-//
-// This package differs from config in that the things in app aren't
-// really related to server configuration.
-package app
-
-import (
-	"errors"
-	"runtime"
-	"strconv"
-	"strings"
-	"sync"
-
-	"github.com/mholt/caddy/server"
-)
-
-const (
-	// Name is the program name
-	Name = "Caddy"
-
-	// Version is the program version
-	Version = "0.7.2"
-)
-
-var (
-	// Servers is a list of all the currently-listening servers
-	Servers []*server.Server
-
-	// ServersMutex protects the Servers slice during changes
-	ServersMutex sync.Mutex
-
-	// Wg is used to wait for all servers to shut down
-	Wg sync.WaitGroup
-
-	// Http2 indicates whether HTTP2 is enabled or not
-	Http2 bool // TODO: temporary flag until http2 is standard
-
-	// Quiet mode hides non-error initialization output
-	Quiet bool
-)
-
-// SetCPU parses string cpu and sets GOMAXPROCS
-// according to its value. It accepts either
-// a number (e.g. 3) or a percent (e.g. 50%).
-func SetCPU(cpu string) error {
-	var numCPU int
-
-	availCPU := runtime.NumCPU()
-
-	if strings.HasSuffix(cpu, "%") {
-		// Percent
-		var percent float32
-		pctStr := cpu[:len(cpu)-1]
-		pctInt, err := strconv.Atoi(pctStr)
-		if err != nil || pctInt < 1 || pctInt > 100 {
-			return errors.New("invalid CPU value: percentage must be between 1-100")
-		}
-		percent = float32(pctInt) / 100
-		numCPU = int(float32(availCPU) * percent)
-	} else {
-		// Number
-		num, err := strconv.Atoi(cpu)
-		if err != nil || num < 1 {
-			return errors.New("invalid CPU value: provide a number or percent greater than 0")
-		}
-		numCPU = num
-	}
-
-	if numCPU > availCPU {
-		numCPU = availCPU
-	}
-
-	runtime.GOMAXPROCS(numCPU)
-	return nil
-}

config/config.go

@@ -1,225 +0,0 @@
-package config
-
-import (
-	"fmt"
-	"io"
-	"log"
-	"net"
-
-	"github.com/mholt/caddy/app"
-	"github.com/mholt/caddy/config/parse"
-	"github.com/mholt/caddy/config/setup"
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/server"
-)
-
-const (
-	DefaultHost = "0.0.0.0"
-	DefaultPort = "2015"
-	DefaultRoot = "."
-
-	// DefaultConfigFile is the name of the configuration file that is loaded
-	// by default if no other file is specified.
-	DefaultConfigFile = "Caddyfile"
-)
-
-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)
-
-	serverBlocks, err := parse.ServerBlocks(filename, input)
-	if err != nil {
-		return configs, err
-	}
-
-	// 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,
-			Root:       Root,
-			Middleware: make(map[string][]middleware.Middleware),
-			ConfigFile: filename,
-			AppName:    app.Name,
-			AppVersion: app.Version,
-		}
-
-		// 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 configs, 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 an address is malformed or a TLS listener is configured on the
-// same address as a plaintext HTTP listener. The return value is a map of
-// bind address to list of configs that would become VirtualHosts on that
-// server. Use the keys of the returned map to create listeners, and use
-// the associated values to set up the virtualhosts.
-func ArrangeBindings(allConfigs []server.Config) (map[*net.TCPAddr][]server.Config, error) {
-	addresses := make(map[*net.TCPAddr][]server.Config)
-
-	// Group configs by bind address
-	for _, conf := range allConfigs {
-		newAddr, warnErr, fatalErr := resolveAddr(conf)
-		if fatalErr != nil {
-			return addresses, fatalErr
-		}
-		if warnErr != nil {
-			log.Println("[Warning]", warnErr)
-		}
-
-		// Make sure to compare the string representation of the address,
-		// not the pointer, since a new *TCPAddr is created each time.
-		var existing bool
-		for addr := range addresses {
-			if addr.String() == newAddr.String() {
-				addresses[addr] = append(addresses[addr], conf)
-				existing = true
-				break
-			}
-		}
-		if !existing {
-			addresses[newAddr] = append(addresses[newAddr], conf)
-		}
-	}
-
-	// Don't allow HTTP and HTTPS to be served on the same address
-	for _, configs := range addresses {
-		isTLS := configs[0].TLS.Enabled
-		for _, config := range configs {
-			if config.TLS.Enabled != isTLS {
-				thisConfigProto, otherConfigProto := "HTTP", "HTTP"
-				if config.TLS.Enabled {
-					thisConfigProto = "HTTPS"
-				}
-				if configs[0].TLS.Enabled {
-					otherConfigProto = "HTTPS"
-				}
-				return addresses, fmt.Errorf("configuration error: Cannot multiplex %s (%s) and %s (%s) on same address",
-					configs[0].Address(), otherConfigProto, config.Address(), thisConfigProto)
-			}
-		}
-	}
-
-	return addresses, nil
-}
-
-// resolveAddr determines the address (host and port) that a config will
-// bind to. The returned address, resolvAddr, should be used to bind the
-// listener or group the config with other configs using the same address.
-// The first error, if not nil, is just a warning and should be reported
-// but execution may continue. The second error, if not nil, is a real
-// problem and the server should not be started.
-//
-// This function handles edge cases gracefully. If a port name like
-// "http" or "https" is unknown to the system, this function will
-// change them to 80 or 443 respectively. If a hostname fails to
-// resolve, that host can still be served but will be listening on
-// the wildcard host instead. This function takes care of this for you.
-func resolveAddr(conf server.Config) (resolvAddr *net.TCPAddr, warnErr error, fatalErr error) {
-	// The host to bind to may be different from the (virtual)host to serve
-	bindHost := conf.BindHost
-	if bindHost == "" {
-		bindHost = conf.Host
-	}
-
-	resolvAddr, warnErr = net.ResolveTCPAddr("tcp", net.JoinHostPort(bindHost, conf.Port))
-	if warnErr != nil {
-		// Most likely the host lookup failed or the port is unknown
-		tryPort := conf.Port
-
-		switch errVal := warnErr.(type) {
-		case *net.AddrError:
-			if errVal.Err == "unknown port" {
-				// some odd Linux machines don't support these port names; see issue #136
-				switch conf.Port {
-				case "http":
-					tryPort = "80"
-				case "https":
-					tryPort = "443"
-				}
-			}
-			resolvAddr, fatalErr = net.ResolveTCPAddr("tcp", net.JoinHostPort(bindHost, tryPort))
-			if fatalErr != nil {
-				return
-			}
-		default:
-			// the hostname probably couldn't be resolved, just bind to wildcard then
-			resolvAddr, fatalErr = net.ResolveTCPAddr("tcp", net.JoinHostPort("0.0.0.0", tryPort))
-			if fatalErr != nil {
-				return
-			}
-		}
-
-		return
-	}
-
-	return
-}
-
-// 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 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,
-	}
-}
-
-// These three defaults are configurable through the command line
-var (
-	Root = DefaultRoot
-	Host = DefaultHost
-	Port = DefaultPort
-)

config/config_test.go

@@ -1,62 +0,0 @@
-package config
-
-import (
-	"testing"
-
-	"github.com/mholt/caddy/server"
-)
-
-func TestReolveAddr(t *testing.T) {
-	// NOTE: If tests fail due to comparing to string "127.0.0.1",
-	// it's possible that system env resolves with IPv6, or ::1.
-	// If that happens, maybe we should use actualAddr.IP.IsLoopback()
-	// for the assertion, rather than a direct string comparison.
-
-	// NOTE: Tests with {Host: "", Port: ""} and {Host: "localhost", Port: ""}
-	// will not behave the same cross-platform, so they have been omitted.
-
-	for i, test := range []struct {
-		config         server.Config
-		shouldWarnErr  bool
-		shouldFatalErr bool
-		expectedIP     string
-		expectedPort   int
-	}{
-		{server.Config{Host: "localhost", Port: "1234"}, false, false, "127.0.0.1", 1234},
-		{server.Config{Host: "127.0.0.1", Port: "1234"}, false, false, "127.0.0.1", 1234},
-		{server.Config{Host: "should-not-resolve", Port: "1234"}, true, false, "0.0.0.0", 1234},
-		{server.Config{Host: "localhost", Port: "http"}, false, false, "127.0.0.1", 80},
-		{server.Config{Host: "localhost", Port: "https"}, false, false, "127.0.0.1", 443},
-		{server.Config{Host: "", Port: "1234"}, false, false, "<nil>", 1234},
-		{server.Config{Host: "localhost", Port: "abcd"}, false, true, "", 0},
-		{server.Config{BindHost: "127.0.0.1", Host: "should-not-be-used", Port: "1234"}, false, false, "127.0.0.1", 1234},
-		{server.Config{BindHost: "localhost", Host: "should-not-be-used", Port: "1234"}, false, false, "127.0.0.1", 1234},
-		{server.Config{BindHost: "should-not-resolve", Host: "localhost", Port: "1234"}, true, false, "0.0.0.0", 1234},
-	} {
-		actualAddr, warnErr, fatalErr := resolveAddr(test.config)
-
-		if test.shouldFatalErr && fatalErr == nil {
-			t.Errorf("Test %d: Expected error, but there wasn't any", i)
-		}
-		if !test.shouldFatalErr && fatalErr != nil {
-			t.Errorf("Test %d: Expected no error, but there was one: %v", i, fatalErr)
-		}
-		if fatalErr != nil {
-			continue
-		}
-
-		if test.shouldWarnErr && warnErr == nil {
-			t.Errorf("Test %d: Expected warning, but there wasn't any", i)
-		}
-		if !test.shouldWarnErr && warnErr != nil {
-			t.Errorf("Test %d: Expected no warning, but there was one: %v", i, warnErr)
-		}
-
-		if actual, expected := actualAddr.IP.String(), test.expectedIP; actual != expected {
-			t.Errorf("Test %d: IP was %s but expected %s", i, actual, expected)
-		}
-		if actual, expected := actualAddr.Port, test.expectedPort; actual != expected {
-			t.Errorf("Test %d: Port was %d but expected %d", i, actual, expected)
-		}
-	}
-}

config/directives.go

@@ -1,79 +0,0 @@
-package config
-
-import (
-	"github.com/mholt/caddy/config/parse"
-	"github.com/mholt/caddy/config/setup"
-	"github.com/mholt/caddy/middleware"
-)
-
-func init() {
-	// The parse package must know which directives
-	// are valid, but it must not import the setup
-	// or config package. To solve this problem, we
-	// fill up this map in our init function here.
-	// The parse package does not need to know the
-	// ordering of the directives.
-	for _, dir := range directiveOrder {
-		parse.ValidDirectives[dir.name] = struct{}{}
-	}
-}
-
-// Directives are registered in the order they should be
-// executed. Middleware (directives that inject a handler)
-// are executed in the order A-B-C-*-C-B-A, assuming
-// they all call the Next handler in the chain.
-//
-// Ordering is VERY important. Every middleware will
-// feel the effects of all other middleware below
-// (after) them during a request, but they 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.
-var directiveOrder = []directive{
-	// Essential directives that initialize vital configuration settings
-	{"root", setup.Root},
-	{"tls", setup.TLS},
-	{"bind", setup.BindHost},
-
-	// Other directives that don't create HTTP handlers
-	{"startup", setup.Startup},
-	{"shutdown", setup.Shutdown},
-
-	// Directives that inject handlers (middleware)
-	{"log", setup.Log},
-	{"gzip", setup.Gzip},
-	{"errors", setup.Errors},
-	{"header", setup.Headers},
-	{"rewrite", setup.Rewrite},
-	{"redir", setup.Redir},
-	{"ext", setup.Ext},
-	{"basicauth", setup.BasicAuth},
-	{"internal", setup.Internal},
-	{"proxy", setup.Proxy},
-	{"fastcgi", setup.FastCGI},
-	{"websocket", setup.WebSocket},
-	{"markdown", setup.Markdown},
-	{"templates", setup.Templates},
-	{"browse", setup.Browse},
-}
-
-// directive ties together a directive name with its setup function.
-type directive struct {
-	name  string
-	setup SetupFunc
-}
-
-// A setup function takes a setup controller. Its return values may
-// both be nil. If middleware is not nil, it will be chained into
-// the HTTP handlers in the order specified in this package.
-type SetupFunc func(c *setup.Controller) (middleware.Middleware, error)

config/parse/dispenser.go

@@ -1,217 +0,0 @@
-package parse
-
-import (
-	"errors"
-	"fmt"
-	"io"
-	"strings"
-)
-
-// Dispenser is a type that dispenses tokens, similarly to a lexer,
-// except that it can do so with some notion of structure and has
-// some really convenient methods.
-type Dispenser struct {
-	filename string
-	tokens   []token
-	cursor   int
-	nesting  int
-}
-
-// NewDispenser returns a Dispenser, ready to use for parsing the given input.
-func NewDispenser(filename string, input io.Reader) Dispenser {
-	return Dispenser{
-		filename: filename,
-		tokens:   allTokens(input),
-		cursor:   -1,
-	}
-}
-
-// NewDispenserTokens returns a Dispenser filled with the given tokens.
-func NewDispenserTokens(filename string, tokens []token) Dispenser {
-	return Dispenser{
-		filename: filename,
-		tokens:   tokens,
-		cursor:   -1,
-	}
-}
-
-// 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.numLineBreaks(d.cursor) == 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.numLineBreaks(d.cursor) < 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 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()
-	if d.Val() == "}" {
-		// Open and then closed right away
-		return false
-	}
-	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 ""
-	}
-	return d.tokens[d.cursor].text
-}
-
-// Line gets the line number of the current token. If there is no token
-// loaded, it returns 0.
-func (d *Dispenser) Line() int {
-	if d.cursor < 0 || d.cursor >= len(d.tokens) {
-		return 0
-	}
-	return d.tokens[d.cursor].line
-}
-
-// 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.Errf("Wrong argument count or unexpected line ending after '%s'", d.Val())
-}
-
-// SyntaxErr creates a generic syntax error which explains what was
-// found and what was expected.
-func (d *Dispenser) SyntaxErr(expected string) error {
-	msg := fmt.Sprintf("%s:%d - Syntax error: Unexpected token '%s', expecting '%s'", d.filename, d.Line(), d.Val(), expected)
-	return errors.New(msg)
-}
-
-// EofErr returns an EOF error, meaning that end of input
-// was found when another token was expected.
-func (d *Dispenser) EofErr() error {
-	return d.Errf("Unexpected EOF")
-}
-
-// 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.Line(), msg)
-	return errors.New(msg)
-}
-
-// Errf is like Err, but for formatted error messages
-func (d *Dispenser) Errf(format string, args ...interface{}) error {
-	return d.Err(fmt.Sprintf(format, args...))
-}
-
-// numLineBreaks counts how many line breaks are in the token
-// value given by the token index tknIdx. It returns 0 if the
-// token does not exist or there are no line breaks.
-func (d *Dispenser) numLineBreaks(tknIdx int) int {
-	if tknIdx < 0 || tknIdx >= len(d.tokens) {
-		return 0
-	}
-	return strings.Count(d.tokens[tknIdx].text, "\n")
-}

config/parse/dispenser_test.go

@@ -1,292 +0,0 @@
-package parse
-
-import (
-	"reflect"
-	"strings"
-	"testing"
-)
-
-func TestDispenser_Val_Next(t *testing.T) {
-	input := `host:port
-			  dir1 arg1
-			  dir2 arg2 arg3
-			  dir3`
-	d := NewDispenser("Testfile", strings.NewReader(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 := NewDispenser("Testfile", strings.NewReader(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 := NewDispenser("Testfile", strings.NewReader(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 := NewDispenser("Testfile", strings.NewReader(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(false, 8, 0) // empty block is as if it didn't exist
-}
-
-func TestDispenser_Args(t *testing.T) {
-	var s1, s2, s3 string
-	input := `dir1 arg1 arg2 arg3
-			  dir2 arg4 arg5
-			  dir3 arg6 arg7
-			  dir4`
-	d := NewDispenser("Testfile", strings.NewReader(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 := NewDispenser("Testfile", strings.NewReader(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 := NewDispenser("Testfile", strings.NewReader(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(), "Testfile: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)
-	}
-}

config/parse/lexer.go

@@ -1,121 +0,0 @@
-package parse
-
-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 parsable unit.
-	token struct {
-		line int
-		text string
-	}
-)
-
-// load prepares the lexer to scan an input for tokens.
-func (l *lexer) load(input io.Reader) error {
-	l.reader = bufio.NewReader(input)
-	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).
-// Inside quoted strings, quotes may be escaped
-// with a preceding \ character. No other chars
-// may be escaped. 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
-			}
-			panic(err)
-		}
-
-		if quoted {
-			if !escaped {
-				if ch == '\\' {
-					escaped = true
-					continue
-				} else if ch == '"' {
-					quoted = false
-					return makeToken()
-				}
-			}
-			if ch == '\n' {
-				l.line++
-			}
-			if escaped {
-				// only escape quotes
-				if ch != '"' {
-					val = append(val, '\\')
-				}
-			}
-			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/parse/lexer_test.go

@@ -1,165 +0,0 @@
-package parse
-
-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: `"don't\escape"`,
-			expected: []token{
-				{line: 1, text: `don't\escape`},
-			},
-		},
-		{
-			input: `"don't\\escape"`,
-			expected: []token{
-				{line: 1, text: `don't\\escape`},
-			},
-		},
-		{
-			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: `"C:\php\php-cgi.exe"`,
-			expected: []token{
-				{line: 1, text: `C:\php\php-cgi.exe`},
-			},
-		},
-		{
-			input: `empty "" string`,
-			expected: []token{
-				{line: 1, text: `empty`},
-				{line: 1, text: ``},
-				{line: 1, text: `string`},
-			},
-		},
-		{
-			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/parse/parse.go

@@ -1,29 +0,0 @@
-// Package parse provides facilities for parsing configuration files.
-package parse
-
-import "io"
-
-// ServerBlocks parses the input just enough to organize tokens,
-// in order, by server block. No further parsing is performed.
-// Server blocks are returned in the order in which they appear.
-func ServerBlocks(filename string, input io.Reader) ([]serverBlock, error) {
-	p := parser{Dispenser: NewDispenser(filename, input)}
-	blocks, err := p.parseAll()
-	return blocks, err
-}
-
-// allTokens lexes the entire input, but does not parse it.
-// It returns all the tokens from the input, unstructured
-// and in order.
-func allTokens(input io.Reader) (tokens []token) {
-	l := new(lexer)
-	l.load(input)
-	for l.next() {
-		tokens = append(tokens, l.token)
-	}
-	return
-}
-
-// Set of directives that are valid (unordered). Populated
-// by config package's init function.
-var ValidDirectives = make(map[string]struct{})

config/parse/parse_test.go

@@ -1,22 +0,0 @@
-package parse
-
-import (
-	"strings"
-	"testing"
-)
-
-func TestAllTokens(t *testing.T) {
-	input := strings.NewReader("a b c\nd e")
-	expected := []string{"a", "b", "c", "d", "e"}
-	tokens := allTokens(input)
-
-	if len(tokens) != len(expected) {
-		t.Fatalf("Expected %d tokens, got %d", len(expected), len(tokens))
-	}
-
-	for i, val := range expected {
-		if tokens[i].text != val {
-			t.Errorf("Token %d should be '%s' but was '%s'", i, val, tokens[i].text)
-		}
-	}
-}

config/parse/parsing.go

@@ -1,310 +0,0 @@
-package parse
-
-import (
-	"net"
-	"os"
-	"strings"
-)
-
-type parser struct {
-	Dispenser
-	block multiServerBlock // current server block being parsed
-	eof   bool             // if we encounter a valid EOF in a hard place
-}
-
-func (p *parser) parseAll() ([]serverBlock, error) {
-	var blocks []serverBlock
-
-	for p.Next() {
-		err := p.parseOne()
-		if err != nil {
-			return blocks, err
-		}
-
-		// explode the multiServerBlock into multiple serverBlocks
-		for _, addr := range p.block.addresses {
-			blocks = append(blocks, serverBlock{
-				Host:   addr.host,
-				Port:   addr.port,
-				Tokens: p.block.tokens,
-			})
-		}
-	}
-
-	return blocks, nil
-}
-
-func (p *parser) parseOne() error {
-	p.block = multiServerBlock{tokens: make(map[string][]token)}
-
-	err := p.begin()
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (p *parser) begin() error {
-	if len(p.tokens) == 0 {
-		return nil
-	}
-
-	err := p.addresses()
-	if err != nil {
-		return err
-	}
-
-	if p.eof {
-		// this happens if the Caddyfile consists of only
-		// a line of addresses and nothing else
-		return nil
-	}
-
-	err = p.blockContents()
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (p *parser) addresses() error {
-	var expectingAnother bool
-
-	for {
-		tkn, startLine := p.Val(), p.Line()
-
-		// Open brace definitely indicates end of addresses
-		if tkn == "{" {
-			if expectingAnother {
-				return p.Errf("Expected another address but had '%s' - check for extra comma", tkn)
-			}
-			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 := standardAddress(tkn)
-		if err != nil {
-			return err
-		}
-		p.block.addresses = append(p.block.addresses, address{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
-}
-
-func (p *parser) blockContents() error {
-	errOpenCurlyBrace := p.openCurlyBrace()
-	if errOpenCurlyBrace != nil {
-		// single-server configs don't need curly braces
-		p.cursor--
-	}
-
-	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
-}
-
-// directives parses through all the lines for directives
-// and it expects the next token to be the first
-// directive. It goes until EOF or closing curly brace
-// which ends the server block.
-func (p *parser) directives() error {
-	for p.Next() {
-		// end of server block
-		if p.Val() == "}" {
-			break
-		}
-
-		// special case: import directive replaces tokens during parse-time
-		if p.Val() == "import" {
-			err := p.doImport()
-			if err != nil {
-				return err
-			}
-			continue
-		}
-
-		// normal case: parse a directive on this line
-		if err := p.directive(); err != nil {
-			return err
-		}
-	}
-	return nil
-}
-
-// doImport swaps out the import directive and its argument
-// (a total of 2 tokens) with the tokens in the file specified.
-// When the function returns, the cursor is on the token before
-// where the import directive was. In other words, call Next()
-// to access the first token that was imported.
-func (p *parser) doImport() error {
-	if !p.NextArg() {
-		return p.ArgErr()
-	}
-	importFile := p.Val()
-	if p.NextArg() {
-		return p.Err("Import allows only one file to import")
-	}
-
-	file, err := os.Open(importFile)
-	if err != nil {
-		return p.Errf("Could not import %s - %v", importFile, err)
-	}
-	defer file.Close()
-	importedTokens := allTokens(file)
-
-	// Splice out the import directive and its argument (2 tokens total)
-	// and insert the imported tokens.
-	tokensBefore := p.tokens[:p.cursor-1]
-	tokensAfter := p.tokens[p.cursor+1:]
-	p.tokens = append(tokensBefore, append(importedTokens, tokensAfter...)...)
-	p.cursor -= 2
-
-	return nil
-}
-
-// directive collects tokens until the directive's scope
-// closes (either end of line or end of curly brace block).
-// It expects the currently-loaded token to be a directive
-// (or } that ends a server block). The collected tokens
-// are loaded into the current server block for later use
-// by directive setup functions.
-func (p *parser) directive() error {
-	dir := p.Val()
-	line := p.Line()
-	nesting := 0
-
-	if _, ok := ValidDirectives[dir]; !ok {
-		return p.Errf("Unknown directive '%s'", dir)
-	}
-
-	// The directive itself is appended as a relevant token
-	p.block.tokens[dir] = append(p.block.tokens[dir], p.tokens[p.cursor])
-
-	for p.Next() {
-		if p.Val() == "{" {
-			nesting++
-		} else if p.Line()+p.numLineBreaks(p.cursor) > line && nesting == 0 {
-			p.cursor-- // read too far
-			break
-		} else if p.Val() == "}" && nesting > 0 {
-			nesting--
-		} else if p.Val() == "}" && nesting == 0 {
-			return p.Err("Unexpected '}' because no matching opening brace")
-		}
-		p.block.tokens[dir] = append(p.block.tokens[dir], p.tokens[p.cursor])
-	}
-
-	if nesting > 0 {
-		return p.EofErr()
-	}
-	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.Val() != "{" {
-		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.Val() != "}" {
-		return p.SyntaxErr("}")
-	}
-	return nil
-}
-
-// standardAddress turns the accepted host and port patterns
-// into a format accepted by net.Dial.
-func standardAddress(str string) (host, port string, err error) {
-	var schemePort, splitPort string
-
-	if strings.HasPrefix(str, "https://") {
-		schemePort = "https"
-		str = str[8:]
-	} else if strings.HasPrefix(str, "http://") {
-		schemePort = "http"
-		str = str[7:]
-	}
-
-	host, splitPort, err = net.SplitHostPort(str)
-	if err != nil {
-		host, splitPort, err = net.SplitHostPort(str + ":") // tack on empty port
-	}
-	if err != nil {
-		// ¯\_(ツ)_/¯
-		host = str
-	}
-
-	if splitPort != "" {
-		port = splitPort
-	} else {
-		port = schemePort
-	}
-
-	return
-}
-
-type (
-	// serverBlock stores tokens by directive name for a
-	// single host:port (address)
-	serverBlock struct {
-		Host, Port string
-		Tokens     map[string][]token // directive name to tokens (including directive)
-	}
-
-	// multiServerBlock is the same as serverBlock but for
-	// multiple addresses that share the same tokens
-	multiServerBlock struct {
-		addresses []address
-		tokens    map[string][]token
-	}
-
-	address struct {
-		host, port string
-	}
-)

config/parse/parsing_test.go

@@ -1,365 +0,0 @@
-package parse
-
-import (
-	"reflect"
-	"strings"
-	"testing"
-)
-
-func TestStandardAddress(t *testing.T) {
-	for i, test := range []struct {
-		input      string
-		host, port string
-		shouldErr  bool
-	}{
-		{`localhost`, "localhost", "", false},
-		{`localhost:1234`, "localhost", "1234", false},
-		{`localhost:`, "localhost", "", false},
-		{`0.0.0.0`, "0.0.0.0", "", false},
-		{`127.0.0.1:1234`, "127.0.0.1", "1234", false},
-		{`:1234`, "", "1234", false},
-		{`[::1]`, "::1", "", false},
-		{`[::1]:1234`, "::1", "1234", false},
-		{`:`, "", "", false},
-		{`localhost:http`, "localhost", "http", false},
-		{`localhost:https`, "localhost", "https", false},
-		{`:http`, "", "http", false},
-		{`:https`, "", "https", false},
-		{`http://localhost`, "localhost", "http", false},
-		{`https://localhost`, "localhost", "https", false},
-		{`http://127.0.0.1`, "127.0.0.1", "http", false},
-		{`https://127.0.0.1`, "127.0.0.1", "https", false},
-		{`http://[::1]`, "::1", "http", false},
-		{`http://localhost:1234`, "localhost", "1234", false},
-		{`https://127.0.0.1:1234`, "127.0.0.1", "1234", false},
-		{`http://[::1]:1234`, "::1", "1234", false},
-		{``, "", "", false},
-		{`::1`, "::1", "", true},
-		{`localhost::`, "localhost::", "", true},
-		{`#$%@`, "#$%@", "", true},
-	} {
-		host, port, err := standardAddress(test.input)
-
-		if err != nil && !test.shouldErr {
-			t.Errorf("Test %d: Expected no error, but had error: %v", i, err)
-		}
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d: Expected error, but had none", i)
-		}
-
-		if host != test.host {
-			t.Errorf("Test %d: Expected host '%s', got '%s'", i, test.host, host)
-		}
-
-		if port != test.port {
-			t.Errorf("Test %d: Expected port '%s', got '%s'", i, test.port, port)
-		}
-	}
-}
-
-func TestParseOne(t *testing.T) {
-	setupParseTests()
-
-	testParseOne := func(input string) (multiServerBlock, error) {
-		p := testParser(input)
-		p.Next()
-		err := p.parseOne()
-		return p.block, err
-	}
-
-	for i, test := range []struct {
-		input     string
-		shouldErr bool
-		addresses []address
-		tokens    map[string]int // map of directive name to number of tokens expected
-	}{
-		{`localhost`, false, []address{
-			{"localhost", ""},
-		}, map[string]int{}},
-
-		{`localhost
-		  dir1`, false, []address{
-			{"localhost", ""},
-		}, map[string]int{
-			"dir1": 1,
-		}},
-
-		{`localhost:1234
-		  dir1 foo bar`, false, []address{
-			{"localhost", "1234"},
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`localhost {
-		    dir1
-		  }`, false, []address{
-			{"localhost", ""},
-		}, map[string]int{
-			"dir1": 1,
-		}},
-
-		{`localhost:1234 {
-		    dir1 foo bar
-		    dir2
-		  }`, false, []address{
-			{"localhost", "1234"},
-		}, map[string]int{
-			"dir1": 3,
-			"dir2": 1,
-		}},
-
-		{`http://localhost https://localhost
-		  dir1 foo bar`, false, []address{
-			{"localhost", "http"},
-			{"localhost", "https"},
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`http://localhost https://localhost {
-		    dir1 foo bar
-		  }`, false, []address{
-			{"localhost", "http"},
-			{"localhost", "https"},
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`http://localhost, https://localhost {
-		    dir1 foo bar
-		  }`, false, []address{
-			{"localhost", "http"},
-			{"localhost", "https"},
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`http://localhost, {
-		  }`, true, []address{
-			{"localhost", "http"},
-		}, map[string]int{}},
-
-		{`host1:80, http://host2.com
-		  dir1 foo bar
-		  dir2 baz`, false, []address{
-			{"host1", "80"},
-			{"host2.com", "http"},
-		}, map[string]int{
-			"dir1": 3,
-			"dir2": 2,
-		}},
-
-		{`http://host1.com,
-		  http://host2.com,
-		  https://host3.com`, false, []address{
-			{"host1.com", "http"},
-			{"host2.com", "http"},
-			{"host3.com", "https"},
-		}, map[string]int{}},
-
-		{`http://host1.com:1234, https://host2.com
-		  dir1 foo {
-		    bar baz
-		  }
-		  dir2`, false, []address{
-			{"host1.com", "1234"},
-			{"host2.com", "https"},
-		}, map[string]int{
-			"dir1": 6,
-			"dir2": 1,
-		}},
-
-		{`127.0.0.1
-		  dir1 {
-		    bar baz
-		  }
-		  dir2 {
-		    foo bar
-		  }`, false, []address{
-			{"127.0.0.1", ""},
-		}, map[string]int{
-			"dir1": 5,
-			"dir2": 5,
-		}},
-
-		{`127.0.0.1
-		  unknown_directive`, true, []address{
-			{"127.0.0.1", ""},
-		}, map[string]int{}},
-
-		{`localhost
-		  dir1 {
-		    foo`, true, []address{
-			{"localhost", ""},
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`localhost
-		  dir1 {
-		  }`, false, []address{
-			{"localhost", ""},
-		}, map[string]int{
-			"dir1": 3,
-		}},
-
-		{`localhost
-		  dir1 {
-		    nested {
-		      foo
-		    }
-		  }
-		  dir2 foo bar`, false, []address{
-			{"localhost", ""},
-		}, map[string]int{
-			"dir1": 7,
-			"dir2": 3,
-		}},
-
-		{``, false, []address{}, map[string]int{}},
-	} {
-		result, err := testParseOne(test.input)
-
-		if test.shouldErr && err == nil {
-			t.Errorf("Test %d: Expected an error, but didn't get one", i)
-		}
-		if !test.shouldErr && err != nil {
-			t.Errorf("Test %d: Expected no error, but got: %v", i, err)
-		}
-
-		if len(result.addresses) != len(test.addresses) {
-			t.Errorf("Test %d: Expected %d addresses, got %d",
-				i, len(test.addresses), len(result.addresses))
-			continue
-		}
-		for j, addr := range result.addresses {
-			if addr.host != test.addresses[j].host {
-				t.Errorf("Test %d, address %d: Expected host to be '%s', but was '%s'",
-					i, j, test.addresses[j].host, addr.host)
-			}
-			if addr.port != test.addresses[j].port {
-				t.Errorf("Test %d, address %d: Expected port to be '%s', but was '%s'",
-					i, j, test.addresses[j].port, addr.port)
-			}
-		}
-
-		if len(result.tokens) != len(test.tokens) {
-			t.Errorf("Test %d: Expected %d directives, had %d",
-				i, len(test.tokens), len(result.tokens))
-			continue
-		}
-		for directive, tokens := range result.tokens {
-			if len(tokens) != test.tokens[directive] {
-				t.Errorf("Test %d, directive '%s': Expected %d tokens, counted %d",
-					i, directive, test.tokens[directive], len(tokens))
-				continue
-			}
-		}
-	}
-}
-
-func TestParseAll(t *testing.T) {
-	setupParseTests()
-
-	for i, test := range []struct {
-		input     string
-		shouldErr bool
-		addresses []address // one per expected server block, in order
-	}{
-		{`localhost`, false, []address{
-			{"localhost", ""},
-		}},
-
-		{`localhost:1234`, false, []address{
-			{"localhost", "1234"},
-		}},
-
-		{`localhost:1234 {
-		  }
-		  localhost:2015 {
-		  }`, false, []address{
-			{"localhost", "1234"},
-			{"localhost", "2015"},
-		}},
-
-		{`localhost:1234, http://host2`, false, []address{
-			{"localhost", "1234"},
-			{"host2", "http"},
-		}},
-
-		{`localhost:1234, http://host2,`, true, []address{}},
-
-		{`http://host1.com, http://host2.com {
-		  }
-		  https://host3.com, https://host4.com {
-		  }`, false, []address{
-			{"host1.com", "http"},
-			{"host2.com", "http"},
-			{"host3.com", "https"},
-			{"host4.com", "https"},
-		}},
-	} {
-		p := testParser(test.input)
-		blocks, err := p.parseAll()
-
-		if test.shouldErr && err == nil {
-			t.Errorf("Test %d: Expected an error, but didn't get one", i)
-		}
-		if !test.shouldErr && err != nil {
-			t.Errorf("Test %d: Expected no error, but got: %v", i, err)
-		}
-
-		if len(blocks) != len(test.addresses) {
-			t.Errorf("Test %d: Expected %d server blocks, got %d",
-				i, len(test.addresses), len(blocks))
-			continue
-		}
-		for j, block := range blocks {
-			if block.Host != test.addresses[j].host {
-				t.Errorf("Test %d, block %d: Expected host to be '%s', but was '%s'",
-					i, j, test.addresses[j].host, block.Host)
-			}
-			if block.Port != test.addresses[j].port {
-				t.Errorf("Test %d, block %d: Expected port to be '%s', but was '%s'",
-					i, j, test.addresses[j].port, block.Port)
-			}
-		}
-	}
-
-	// Exploding the server blocks that have more than one address should replicate/share tokens
-	p := testParser(`host1 {
-	                   dir1 foo bar
-	                 }
-
-	                 host2, host3 {
-	                   dir2 foo bar
-	                   dir3 foo {
-	                     bar
-	                   }
-	                 }`)
-	blocks, err := p.parseAll()
-	if err != nil {
-		t.Fatalf("Expected there to not be an error, but there was: %v", err)
-	}
-
-	if !reflect.DeepEqual(blocks[1].Tokens, blocks[2].Tokens) {
-		t.Errorf("Expected host2 and host3 to have same tokens, but they didn't.\nhost2 Block: %v\nhost3 Block: %v",
-			blocks[1].Tokens, blocks[2].Tokens)
-	}
-}
-
-func setupParseTests() {
-	// Set up some bogus directives for testing
-	ValidDirectives = map[string]struct{}{
-		"dir1": struct{}{},
-		"dir2": struct{}{},
-		"dir3": struct{}{},
-	}
-}
-
-func testParser(input string) parser {
-	buf := strings.NewReader(input)
-	p := parser{Dispenser: NewDispenser("Test", buf)}
-	return p
-}

config/setup/basicauth.go

@@ -1,53 +0,0 @@
-package setup
-
-import (
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/basicauth"
-)
-
-// BasicAuth configures a new BasicAuth middleware instance.
-func BasicAuth(c *Controller) (middleware.Middleware, error) {
-	rules, err := basicAuthParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	basic := basicauth.BasicAuth{Rules: rules}
-
-	return func(next middleware.Handler) middleware.Handler {
-		basic.Next = next
-		return basic
-	}, nil
-}
-
-func basicAuthParse(c *Controller) ([]basicauth.Rule, error) {
-	var rules []basicauth.Rule
-
-	for c.Next() {
-		var rule basicauth.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.Errf("Expecting only one resource per line (extra '%s')", 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
-}

config/setup/basicauth_test.go

@@ -1,100 +0,0 @@
-package setup
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/mholt/caddy/middleware/basicauth"
-)
-
-func TestBasicAuth(t *testing.T) {
-	c := NewTestController(`basicauth user pwd`)
-
-	mid, err := BasicAuth(c)
-	if err != nil {
-		t.Errorf("Expected no errors, but got: %v", err)
-	}
-	if mid == nil {
-		t.Fatal("Expected middleware, was nil instead")
-	}
-
-	handler := mid(EmptyNext)
-	myHandler, ok := handler.(basicauth.BasicAuth)
-	if !ok {
-		t.Fatalf("Expected handler to be type BasicAuth, got: %#v", handler)
-	}
-
-	if !SameNext(myHandler.Next, EmptyNext) {
-		t.Error("'Next' field of handler was not set properly")
-	}
-}
-
-func TestBasicAuthParse(t *testing.T) {
-	tests := []struct {
-		input     string
-		shouldErr bool
-		expected  []basicauth.Rule
-	}{
-		{`basicauth user pwd`, false, []basicauth.Rule{
-			{Username: "user", Password: "pwd"},
-		}},
-		{`basicauth user pwd {
-		}`, false, []basicauth.Rule{
-			{Username: "user", Password: "pwd"},
-		}},
-		{`basicauth user pwd {
-			/resource1
-			/resource2
-		}`, false, []basicauth.Rule{
-			{Username: "user", Password: "pwd", Resources: []string{"/resource1", "/resource2"}},
-		}},
-		{`basicauth /resource user pwd`, false, []basicauth.Rule{
-			{Username: "user", Password: "pwd", Resources: []string{"/resource"}},
-		}},
-		{`basicauth /res1 user1 pwd1
-		  basicauth /res2 user2 pwd2`, false, []basicauth.Rule{
-			{Username: "user1", Password: "pwd1", Resources: []string{"/res1"}},
-			{Username: "user2", Password: "pwd2", Resources: []string{"/res2"}},
-		}},
-		{`basicauth user`, true, []basicauth.Rule{}},
-		{`basicauth`, true, []basicauth.Rule{}},
-		{`basicauth /resource user pwd asdf`, true, []basicauth.Rule{}},
-	}
-
-	for i, test := range tests {
-		c := NewTestController(test.input)
-		actual, err := basicAuthParse(c)
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		}
-
-		if len(actual) != len(test.expected) {
-			t.Fatalf("Test %d expected %d rules, but got %d",
-				i, len(test.expected), len(actual))
-		}
-
-		for j, expectedRule := range test.expected {
-			actualRule := actual[j]
-
-			if actualRule.Username != expectedRule.Username {
-				t.Errorf("Test %d, rule %d: Expected username '%s', got '%s'",
-					i, j, expectedRule.Username, actualRule.Username)
-			}
-
-			if actualRule.Password != expectedRule.Password {
-				t.Errorf("Test %d, rule %d: Expected password '%s', got '%s'",
-					i, j, expectedRule.Password, actualRule.Password)
-			}
-
-			expectedRes := fmt.Sprintf("%v", expectedRule.Resources)
-			actualRes := fmt.Sprintf("%v", actualRule.Resources)
-			if actualRes != expectedRes {
-				t.Errorf("Test %d, rule %d: Expected resource list %s, but got %s",
-					i, j, expectedRes, actualRes)
-			}
-		}
-	}
-}

config/setup/bindhost.go

@@ -1,12 +0,0 @@
-package setup
-
-import "github.com/mholt/caddy/middleware"
-
-func BindHost(c *Controller) (middleware.Middleware, error) {
-	for c.Next() {
-		if !c.Args(&c.BindHost) {
-			return nil, c.ArgErr()
-		}
-	}
-	return nil, nil
-}

config/setup/browse.go

@@ -1,251 +0,0 @@
-package setup
-
-import (
-	"fmt"
-	"html/template"
-	"io/ioutil"
-
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/browse"
-)
-
-// Browse configures a new Browse middleware instance.
-func Browse(c *Controller) (middleware.Middleware, error) {
-	configs, err := browseParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	browse := browse.Browse{
-		Root:    c.Root,
-		Configs: configs,
-	}
-
-	return func(next middleware.Handler) middleware.Handler {
-		browse.Next = next
-		return browse
-	}, nil
-}
-
-func browseParse(c *Controller) ([]browse.Config, error) {
-	var configs []browse.Config
-
-	appendCfg := func(bc browse.Config) error {
-		for _, c := range configs {
-			if c.PathScope == bc.PathScope {
-				return fmt.Errorf("duplicate browsing config for %s", c.PathScope)
-			}
-		}
-		configs = append(configs, bc)
-		return nil
-	}
-
-	for c.Next() {
-		var bc browse.Config
-
-		// First argument is directory to allow browsing; default is site root
-		if c.NextArg() {
-			bc.PathScope = c.Val()
-		} else {
-			bc.PathScope = "/"
-		}
-
-		// Second argument would be the template file to use
-		var tplText string
-		if c.NextArg() {
-			tplBytes, err := ioutil.ReadFile(c.Val())
-			if err != nil {
-				return configs, err
-			}
-			tplText = string(tplBytes)
-		} else {
-			tplText = defaultTemplate
-		}
-
-		// Build the template
-		tpl, err := template.New("listing").Parse(tplText)
-		if err != nil {
-			return configs, err
-		}
-		bc.Template = tpl
-
-		// Save configuration
-		err = appendCfg(bc)
-		if err != nil {
-			return configs, err
-		}
-	}
-
-	return configs, nil
-}
-
-// The default template to use when serving up directory listings
-const defaultTemplate = `<!DOCTYPE html>
-<html>
-	<head>
-		<title>{{.Name}}</title>
-		<meta charset="utf-8">
-<style>
-* { padding: 0; margin: 0; }
-
-body {
-	padding: 1% 2%;
-	font: 16px Arial;
-}
-
-header {
-	font-size: 45px;
-	padding: 25px;
-}
-
-header a {
-	text-decoration: none;
-	color: inherit;
-}
-
-header .up {
-	display: inline-block;
-	height: 50px;
-	width: 50px;
-	text-align: center;
-	margin-right: 20px;
-}
-
-header a.up:hover {
-	background: #000;
-	color: #FFF;
-}
-
-h1 {
-	font-size: 30px;
-	display: inline;
-}
-
-table {
-	border: 0;
-	border-collapse: collapse;
-	max-width: 750px;
-	margin: 0 auto;
-}
-
-th,
-td {
-	padding: 4px 20px;
-	vertical-align: middle;
-	line-height: 1.5em; /* emoji are kind of odd heights */
-}
-
-th {
-	text-align: left;
-}
-
-th a {
-	color: #000;
-	text-decoration: none;
-}
-
-@media (max-width: 700px) {
-	.hideable {
-		display: none;
-	}
-
-	body {
-		padding: 0;
-	}
-
-	header,
-	header h1 {
-		font-size: 16px;
-	}
-
-	header {
-		position: fixed;
-		top: 0;
-		width: 100%;
-		background: #333;
-		color: #FFF;
-		padding: 15px;
-		text-align: center;
-	}
-
-	header .up {
-		height: auto;
-		width: auto;
-		display: none;
-	}
-
-	header a.up {
-		display: inline-block;
-		position: absolute;
-		left: 0;
-		top: 0;
-		width: 40px;
-		height: 48px;
-		font-size: 35px;
-	}
-
-	header h1 {
-		font-weight: normal;
-	}
-
-	main {
-		margin-top: 70px;
-	}
-}
-</style>
-	</head>
-	<body>
-		<header>
-			{{if .CanGoUp}}
-			<a href=".." class="up" title="Up one level">&#11025;</a>
-			{{else}}
-			<div class="up">&nbsp;</div>
-			{{end}}
-
-			<h1>{{.Path}}</h1>
-		</header>
-		<main>
-			<table>
-				<tr>
-					<th>
-						{{if and (eq .Sort "name") (ne .Order "desc")}}
-						<a href="?sort=name&order=desc">Name &#9650;</a>
-						{{else if and (eq .Sort "name") (ne .Order "asc")}}
-						<a href="?sort=name&order=asc">Name &#9660;</a>
-						{{else}}
-						<a href="?sort=name&order=asc">Name</a>
-						{{end}}
-					</th>
-					<th>
-						{{if and (eq .Sort "size") (ne .Order "desc")}}
-						<a href="?sort=size&order=desc">Size &#9650;</a>
-						{{else if and (eq .Sort "size") (ne .Order "asc")}}
-						<a href="?sort=size&order=asc">Size &#9660;</a>
-						{{else}}
-						<a href="?sort=size&order=asc">Size</a>
-						{{end}}
-					</th>
-					<th class="hideable">
-						{{if and (eq .Sort "time") (ne .Order "desc")}}
-						<a href="?sort=time&order=desc">Modified &#9650;</a>
-						{{else if and (eq .Sort "time") (ne .Order "asc")}}
-						<a href="?sort=time&order=asc">Modified &#9660;</a>
-						{{else}}
-						<a href="?sort=time&order=asc">Modified</a>
-						{{end}}
-					</th>
-				</tr>
-				{{range .Items}}
-				<tr>
-					<td>
-						{{if .IsDir}}&#128194;{{else}}&#128196;{{end}}
-						<a href="{{.URL}}">{{.Name}}</a>
-					</td>
-					<td>{{.HumanSize}}</td>
-					<td class="hideable">{{.HumanModTime "01/02/2006 3:04:05 PM -0700"}}</td>
-				</tr>
-				{{end}}
-			</table>
-		</main>
-	</body>
-</html>`

config/setup/controller.go

@@ -1,11 +0,0 @@
-package setup
-
-import (
-	"github.com/mholt/caddy/config/parse"
-	"github.com/mholt/caddy/server"
-)
-
-type Controller struct {
-	*server.Config
-	parse.Dispenser
-}

config/setup/controllertest.go

@@ -1,32 +0,0 @@
-package setup
-
-import (
-	"fmt"
-	"net/http"
-	"strings"
-
-	"github.com/mholt/caddy/config/parse"
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/server"
-)
-
-// NewTestController creates a new *Controller for
-// the input specified, with a filename of "Testfile"
-func NewTestController(input string) *Controller {
-	return &Controller{
-		Config:    &server.Config{},
-		Dispenser: parse.NewDispenser("Testfile", strings.NewReader(input)),
-	}
-}
-
-// EmptyNext is a no-op function that can be passed into
-// middleware.Middleware functions so that the assignment
-// to the Next field of the Handler can be tested.
-var EmptyNext = middleware.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-	return 0, nil
-})
-
-// SameNext does a pointer comparison between next1 and next2.
-func SameNext(next1, next2 middleware.Handler) bool {
-	return fmt.Sprintf("%p", next1) == fmt.Sprintf("%p", next2)
-}

config/setup/errors.go

@@ -1,104 +0,0 @@
-package setup
-
-import (
-	"fmt"
-	"log"
-	"os"
-	"path"
-	"strconv"
-
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/errors"
-)
-
-// Errors configures a new gzip middleware instance.
-func Errors(c *Controller) (middleware.Middleware, error) {
-	handler, err := errorsParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	// Open the log file for writing when the server starts
-	c.Startup = append(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
-}
-
-func errorsParse(c *Controller) (*errors.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 := &errors.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 {
-					fmt.Println("Warning: 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 = errors.DefaultLogFilename
-			}
-		}
-	}
-
-	return handler, nil
-}

config/setup/ext.go

@@ -1,54 +0,0 @@
-package setup
-
-import (
-	"os"
-
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/extensions"
-)
-
-// Ext configures a new instance of 'extensions' middleware for clean URLs.
-func Ext(c *Controller) (middleware.Middleware, error) {
-	root := c.Root
-
-	exts, err := extParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	return func(next middleware.Handler) middleware.Handler {
-		return extensions.Ext{
-			Next:       next,
-			Extensions: exts,
-			Root:       root,
-		}
-	}, nil
-}
-
-// extParse sets up an instance of extension middleware
-// from a middleware controller and returns a list of extensions.
-func extParse(c *Controller) ([]string, error) {
-	var exts []string
-
-	for c.Next() {
-		// At least one extension is required
-		if !c.NextArg() {
-			return exts, c.ArgErr()
-		}
-		exts = append(exts, c.Val())
-
-		// Tack on any other extensions that may have been listed
-		exts = append(exts, c.RemainingArgs()...)
-	}
-
-	return exts, nil
-}
-
-// resourceExists returns true if the file specified at
-// root + path exists; false otherwise.
-func resourceExists(root, path string) bool {
-	_, err := os.Stat(root + path)
-	// technically we should use os.IsNotExist(err)
-	// but we don't handle any other kinds of errors anyway
-	return err == nil
-}

config/setup/ext_test.go

@@ -1,76 +0,0 @@
-package setup
-
-import (
-	"testing"
-
-	"github.com/mholt/caddy/middleware/extensions"
-)
-
-func TestExt(t *testing.T) {
-	c := NewTestController(`ext .html .htm .php`)
-
-	mid, err := Ext(c)
-
-	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-
-	if mid == nil {
-		t.Fatal("Expected middleware, was nil instead")
-	}
-
-	handler := mid(EmptyNext)
-	myHandler, ok := handler.(extensions.Ext)
-
-	if !ok {
-		t.Fatalf("Expected handler to be type Ext, got: %#v", handler)
-	}
-
-	if myHandler.Extensions[0] != ".html" {
-		t.Errorf("Expected .html in the list of Extensions")
-	}
-	if myHandler.Extensions[1] != ".htm" {
-		t.Errorf("Expected .htm in the list of Extensions")
-	}
-	if myHandler.Extensions[2] != ".php" {
-		t.Errorf("Expected .php in the list of Extensions")
-	}
-	if !SameNext(myHandler.Next, EmptyNext) {
-		t.Error("'Next' field of handler was not set properly")
-	}
-
-}
-
-func TestExtParse(t *testing.T) {
-	tests := []struct {
-		inputExts    string
-		shouldErr    bool
-		expectedExts []string
-	}{
-		{`ext .html .htm .php`, false, []string{".html", ".htm", ".php"}},
-		{`ext .php .html .xml`, false, []string{".php", ".html", ".xml"}},
-		{`ext .txt .php .xml`, false, []string{".txt", ".php", ".xml"}},
-	}
-	for i, test := range tests {
-		c := NewTestController(test.inputExts)
-		actualExts, err := extParse(c)
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		}
-
-		if len(actualExts) != len(test.expectedExts) {
-			t.Fatalf("Test %d expected %d rules, but got %d",
-				i, len(test.expectedExts), len(actualExts))
-		}
-		for j, actualExt := range actualExts {
-			if actualExt != test.expectedExts[j] {
-				t.Fatalf("Test %d expected %dth extension to be  %s  , but got %s",
-					i, j, test.expectedExts[j], actualExt)
-			}
-		}
-	}
-
-}

config/setup/fastcgi.go

@@ -1,110 +0,0 @@
-package setup
-
-import (
-	"errors"
-	"net/http"
-	"path/filepath"
-
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/fastcgi"
-)
-
-// FastCGI configures a new FastCGI middleware instance.
-func FastCGI(c *Controller) (middleware.Middleware, error) {
-	absRoot, err := filepath.Abs(c.Root)
-	if err != nil {
-		return nil, err
-	}
-
-	rules, err := fastcgiParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	return func(next middleware.Handler) middleware.Handler {
-		return fastcgi.Handler{
-			Next:            next,
-			Rules:           rules,
-			Root:            c.Root,
-			AbsRoot:         absRoot,
-			FileSys:         http.Dir(c.Root),
-			SoftwareName:    c.AppName,
-			SoftwareVersion: c.AppVersion,
-			ServerName:      c.Host,
-			ServerPort:      c.Port,
-		}
-	}, nil
-}
-
-func fastcgiParse(c *Controller) ([]fastcgi.Rule, error) {
-	var rules []fastcgi.Rule
-
-	for c.Next() {
-		var rule fastcgi.Rule
-
-		args := c.RemainingArgs()
-
-		switch len(args) {
-		case 0:
-			return rules, c.ArgErr()
-		case 1:
-			rule.Path = "/"
-			rule.Address = args[0]
-		case 2:
-			rule.Path = args[0]
-			rule.Address = args[1]
-		case 3:
-			rule.Path = args[0]
-			rule.Address = args[1]
-			err := fastcgiPreset(args[2], &rule)
-			if err != nil {
-				return rules, c.Err("Invalid fastcgi rule preset '" + args[2] + "'")
-			}
-		}
-
-		for c.NextBlock() {
-			switch c.Val() {
-			case "ext":
-				if !c.NextArg() {
-					return rules, c.ArgErr()
-				}
-				rule.Ext = c.Val()
-			case "split":
-				if !c.NextArg() {
-					return rules, c.ArgErr()
-				}
-				rule.SplitPath = c.Val()
-			case "index":
-				args := c.RemainingArgs()
-				if len(args) == 0 {
-					return rules, c.ArgErr()
-				}
-				rule.IndexFiles = args
-			case "env":
-				envArgs := c.RemainingArgs()
-				if len(envArgs) < 2 {
-					return rules, c.ArgErr()
-				}
-				rule.EnvVars = append(rule.EnvVars, [2]string{envArgs[0], envArgs[1]})
-			}
-		}
-
-		rules = append(rules, rule)
-	}
-
-	return rules, nil
-}
-
-// fastcgiPreset configures rule according to name. It returns an error if
-// name is not a recognized preset name.
-func fastcgiPreset(name string, rule *fastcgi.Rule) error {
-	switch name {
-	case "php":
-		rule.Ext = ".php"
-		rule.SplitPath = ".php"
-		rule.IndexFiles = []string{"index.php"}
-	default:
-		return errors.New(name + " is not a valid preset name")
-	}
-	return nil
-}

config/setup/gzip.go

@@ -1,113 +0,0 @@
-package setup
-
-import (
-	"fmt"
-	"strconv"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/gzip"
-)
-
-// Gzip configures a new gzip middleware instance.
-func Gzip(c *Controller) (middleware.Middleware, error) {
-	configs, err := gzipParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	return func(next middleware.Handler) middleware.Handler {
-		return gzip.Gzip{Next: next, Configs: configs}
-	}, nil
-}
-
-func gzipParse(c *Controller) ([]gzip.Config, error) {
-	var configs []gzip.Config
-
-	for c.Next() {
-		config := gzip.Config{}
-
-		pathFilter := gzip.PathFilter{make(gzip.Set)}
-		mimeFilter := gzip.MIMEFilter{make(gzip.Set)}
-		extFilter := gzip.ExtFilter{make(gzip.Set)}
-
-		// no extra args expected
-		if len(c.RemainingArgs()) > 0 {
-			return configs, c.ArgErr()
-		}
-
-		for c.NextBlock() {
-			switch c.Val() {
-			case "mimes":
-				mimes := c.RemainingArgs()
-				if len(mimes) == 0 {
-					return configs, c.ArgErr()
-				}
-				for _, m := range mimes {
-					if !gzip.ValidMIME(m) {
-						return configs, fmt.Errorf("Invalid MIME %v.", m)
-					}
-					mimeFilter.Types.Add(m)
-				}
-			case "ext":
-				exts := c.RemainingArgs()
-				if len(exts) == 0 {
-					return configs, c.ArgErr()
-				}
-				for _, e := range exts {
-					if !strings.HasPrefix(e, ".") {
-						return configs, fmt.Errorf(`Invalid extension %v. Should start with "."`, e)
-					}
-					extFilter.Exts.Add(e)
-				}
-			case "not":
-				paths := c.RemainingArgs()
-				if len(paths) == 0 {
-					return configs, c.ArgErr()
-				}
-				for _, p := range paths {
-					if !strings.HasPrefix(p, "/") {
-						return configs, fmt.Errorf(`Invalid path %v. Should start with "/"`, p)
-					}
-					pathFilter.IgnoredPaths.Add(p)
-					// Warn user if / is used
-					if p == "/" {
-						fmt.Println("Warning: Paths ignored by gzip includes wildcard(/). No request will be gzipped.\nRemoving gzip directive from Caddyfile is preferred if this is intended.")
-					}
-				}
-			case "level":
-				if !c.NextArg() {
-					return configs, c.ArgErr()
-				}
-				level, _ := strconv.Atoi(c.Val())
-				config.Level = level
-			default:
-				return configs, c.ArgErr()
-			}
-		}
-
-		config.Filters = []gzip.Filter{}
-
-		// if ignored paths are specified, put in front to filter with path first
-		if len(pathFilter.IgnoredPaths) > 0 {
-			config.Filters = []gzip.Filter{pathFilter}
-		}
-
-		// if mime types are specified, use it and ignore extensions
-		if len(mimeFilter.Types) > 0 {
-			config.Filters = append(config.Filters, mimeFilter)
-
-			// if extensions are specified, use it
-		} else if len(extFilter.Exts) > 0 {
-			config.Filters = append(config.Filters, extFilter)
-
-			// neither is specified, use default mime types
-		} else {
-			config.Filters = append(config.Filters, gzip.DefaultMIMEFilter())
-		}
-
-		configs = append(configs, config)
-	}
-
-	return configs, nil
-}

config/setup/gzip_test.go

@@ -1,93 +0,0 @@
-package setup
-
-import (
-	"testing"
-
-	"github.com/mholt/caddy/middleware/gzip"
-)
-
-func TestGzip(t *testing.T) {
-	c := NewTestController(`gzip`)
-
-	mid, err := Gzip(c)
-	if err != nil {
-		t.Errorf("Expected no errors, but got: %v", err)
-	}
-	if mid == nil {
-		t.Fatal("Expected middleware, was nil instead")
-	}
-
-	handler := mid(EmptyNext)
-	myHandler, ok := handler.(gzip.Gzip)
-	if !ok {
-		t.Fatalf("Expected handler to be type Gzip, got: %#v", handler)
-	}
-
-	if !SameNext(myHandler.Next, EmptyNext) {
-		t.Error("'Next' field of handler was not set properly")
-	}
-
-	tests := []struct {
-		input     string
-		shouldErr bool
-	}{
-		{`gzip {`, true},
-		{`gzip {}`, true},
-		{`gzip a b`, true},
-		{`gzip a {`, true},
-		{`gzip { not f } `, true},
-		{`gzip { not } `, true},
-		{`gzip { not /file
-		 ext .html
-		 level 1
-		} `, false},
-		{`gzip { level 9 } `, false},
-		{`gzip { ext } `, true},
-		{`gzip { ext /f
-		} `, true},
-		{`gzip { not /file
-		 ext .html
-		 level 1
-		}
-		gzip`, false},
-		{`gzip { not /file
-		 ext .html
-		 level 1
-		}
-		gzip { not /file1
-		 ext .htm
-		 level 3
-		}
-		`, false},
-		{`gzip { mimes text/html
-		}`, false},
-		{`gzip { mimes text/html application/json
-		}`, false},
-		{`gzip { mimes text/html application/
-		}`, true},
-		{`gzip { mimes text/html /json
-		}`, true},
-		{`gzip { mimes /json text/html
-		}`, true},
-		{`gzip { not /file
-		 ext .html
-		 level 1
-		 mimes text/html text/plain
-		}
-		gzip { not /file1
-		 ext .htm
-		 level 3
-		 mimes text/html text/css
-		}
-		`, false},
-	}
-	for i, test := range tests {
-		c := NewTestController(test.input)
-		_, err := gzipParse(c)
-		if test.shouldErr && err == nil {
-			t.Errorf("Test %v: Expected error but found nil", i)
-		} else if !test.shouldErr && err != nil {
-			t.Errorf("Test %v: Expected no error but found error: %v", i, err)
-		}
-	}
-}

config/setup/headers.go

@@ -1,84 +0,0 @@
-package setup
-
-import (
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/headers"
-)
-
-// Headers configures a new Headers middleware instance.
-func Headers(c *Controller) (middleware.Middleware, error) {
-	rules, err := headersParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	return func(next middleware.Handler) middleware.Handler {
-		return headers.Headers{Next: next, Rules: rules}
-	}, nil
-}
-
-func headersParse(c *Controller) ([]headers.Rule, error) {
-	var rules []headers.Rule
-
-	for c.NextLine() {
-		var head headers.Rule
-		var isNewPattern bool
-
-		if !c.NextArg() {
-			return rules, c.ArgErr()
-		}
-		pattern := c.Val()
-
-		// See if we already have a definition for this Path pattern...
-		for _, h := range rules {
-			if h.Path == pattern {
-				head = h
-				break
-			}
-		}
-
-		// ...otherwise, this is a new pattern
-		if head.Path == "" {
-			head.Path = pattern
-			isNewPattern = true
-		}
-
-		for c.NextBlock() {
-			// A block of headers was opened...
-
-			h := headers.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 := headers.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].Path == pattern {
-					rules[i] = head
-					break
-				}
-			}
-		}
-	}
-
-	return rules, nil
-}

config/setup/headers_test.go

@@ -1,85 +0,0 @@
-package setup
-
-import (
-	"fmt"
-	"testing"
-
-	"github.com/mholt/caddy/middleware/headers"
-)
-
-func TestHeaders(t *testing.T) {
-	c := NewTestController(`header / Foo Bar`)
-
-	mid, err := Headers(c)
-	if err != nil {
-		t.Errorf("Expected no errors, but got: %v", err)
-	}
-	if mid == nil {
-		t.Fatal("Expected middleware, was nil instead")
-	}
-
-	handler := mid(EmptyNext)
-	myHandler, ok := handler.(headers.Headers)
-	if !ok {
-		t.Fatalf("Expected handler to be type Headers, got: %#v", handler)
-	}
-
-	if !SameNext(myHandler.Next, EmptyNext) {
-		t.Error("'Next' field of handler was not set properly")
-	}
-}
-
-func TestHeadersParse(t *testing.T) {
-	tests := []struct {
-		input     string
-		shouldErr bool
-		expected  []headers.Rule
-	}{
-		{`header /foo Foo "Bar Baz"`,
-			false, []headers.Rule{
-				{Path: "/foo", Headers: []headers.Header{
-					{"Foo", "Bar Baz"},
-				}},
-			}},
-		{`header /bar { Foo "Bar Baz" Baz Qux }`,
-			false, []headers.Rule{
-				{Path: "/bar", Headers: []headers.Header{
-					{"Foo", "Bar Baz"},
-					{"Baz", "Qux"},
-				}},
-			}},
-	}
-
-	for i, test := range tests {
-		c := NewTestController(test.input)
-		actual, err := headersParse(c)
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		}
-
-		if len(actual) != len(test.expected) {
-			t.Fatalf("Test %d expected %d rules, but got %d",
-				i, len(test.expected), len(actual))
-		}
-
-		for j, expectedRule := range test.expected {
-			actualRule := actual[j]
-
-			if actualRule.Path != expectedRule.Path {
-				t.Errorf("Test %d, rule %d: Expected path %s, but got %s",
-					i, j, expectedRule.Path, actualRule.Path)
-			}
-
-			expectedHeaders := fmt.Sprintf("%v", expectedRule.Headers)
-			actualHeaders := fmt.Sprintf("%v", actualRule.Headers)
-
-			if actualHeaders != expectedHeaders {
-				t.Errorf("Test %d, rule %d: Expected headers %s, but got %s",
-					i, j, expectedHeaders, actualHeaders)
-			}
-		}
-	}
-}

config/setup/internal.go

@@ -1,31 +0,0 @@
-package setup
-
-import (
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/inner"
-)
-
-// Internal configures a new Internal middleware instance.
-func Internal(c *Controller) (middleware.Middleware, error) {
-	paths, err := internalParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	return func(next middleware.Handler) middleware.Handler {
-		return inner.Internal{Next: next, Paths: paths}
-	}, nil
-}
-
-func internalParse(c *Controller) ([]string, error) {
-	var paths []string
-
-	for c.Next() {
-		if !c.NextArg() {
-			return paths, c.ArgErr()
-		}
-		paths = append(paths, c.Val())
-	}
-
-	return paths, nil
-}

config/setup/internal_test.go

@@ -1,72 +0,0 @@
-package setup
-
-import (
-	"testing"
-
-	"github.com/mholt/caddy/middleware/inner"
-)
-
-func TestInternal(t *testing.T) {
-	c := NewTestController(`internal /internal`)
-
-	mid, err := Internal(c)
-
-	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-
-	if mid == nil {
-		t.Fatal("Expected middleware, was nil instead")
-	}
-
-	handler := mid(EmptyNext)
-	myHandler, ok := handler.(inner.Internal)
-
-	if !ok {
-		t.Fatalf("Expected handler to be type Internal, got: %#v", handler)
-	}
-
-	if myHandler.Paths[0] != "/internal" {
-		t.Errorf("Expected internal in the list of internal Paths")
-	}
-
-	if !SameNext(myHandler.Next, EmptyNext) {
-		t.Error("'Next' field of handler was not set properly")
-	}
-
-}
-
-func TestInternalParse(t *testing.T) {
-	tests := []struct {
-		inputInternalPaths    string
-		shouldErr             bool
-		expectedInternalPaths []string
-	}{
-		{`internal /internal`, false, []string{"/internal"}},
-
-		{`internal /internal1
-		  internal /internal2`, false, []string{"/internal1", "/internal2"}},
-	}
-	for i, test := range tests {
-		c := NewTestController(test.inputInternalPaths)
-		actualInternalPaths, err := internalParse(c)
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		}
-
-		if len(actualInternalPaths) != len(test.expectedInternalPaths) {
-			t.Fatalf("Test %d expected %d InternalPaths, but got %d",
-				i, len(test.expectedInternalPaths), len(actualInternalPaths))
-		}
-		for j, actualInternalPath := range actualInternalPaths {
-			if actualInternalPath != test.expectedInternalPaths[j] {
-				t.Fatalf("Test %d expected %dth Internal Path to be  %s  , but got %s",
-					i, j, test.expectedInternalPaths[j], actualInternalPath)
-			}
-		}
-	}
-
-}

config/setup/log.go

@@ -1,92 +0,0 @@
-package setup
-
-import (
-	"log"
-	"os"
-
-	"github.com/mholt/caddy/middleware"
-	caddylog "github.com/mholt/caddy/middleware/log"
-	"github.com/mholt/caddy/server"
-)
-
-// Log sets up the logging middleware.
-func Log(c *Controller) (middleware.Middleware, error) {
-	rules, err := logParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	// Open the log files for writing when the server starts
-	c.Startup = append(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 caddylog.Logger{Next: next, Rules: rules, ErrorFunc: server.DefaultErrorFunc}
-	}, nil
-}
-
-func logParse(c *Controller) ([]caddylog.Rule, error) {
-	var rules []caddylog.Rule
-
-	for c.Next() {
-		args := c.RemainingArgs()
-
-		if len(args) == 0 {
-			// Nothing specified; use defaults
-			rules = append(rules, caddylog.Rule{
-				PathScope:  "/",
-				OutputFile: caddylog.DefaultLogFilename,
-				Format:     caddylog.DefaultLogFormat,
-			})
-		} else if len(args) == 1 {
-			// Only an output file specified
-			rules = append(rules, caddylog.Rule{
-				PathScope:  "/",
-				OutputFile: args[0],
-				Format:     caddylog.DefaultLogFormat,
-			})
-		} else {
-			// Path scope, output file, and maybe a format specified
-
-			format := caddylog.DefaultLogFormat
-
-			if len(args) > 2 {
-				switch args[2] {
-				case "{common}":
-					format = caddylog.CommonLogFormat
-				case "{combined}":
-					format = caddylog.CombinedLogFormat
-				default:
-					format = args[2]
-				}
-			}
-
-			rules = append(rules, caddylog.Rule{
-				PathScope:  args[0],
-				OutputFile: args[1],
-				Format:     format,
-			})
-		}
-	}
-
-	return rules, nil
-}

config/setup/log_test.go

@@ -1,134 +0,0 @@
-package setup
-
-import (
-	"testing"
-
-	caddylog "github.com/mholt/caddy/middleware/log"
-)
-
-func TestLog(t *testing.T) {
-
-	c := NewTestController(`log`)
-
-	mid, err := Log(c)
-
-	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-
-	if mid == nil {
-		t.Fatal("Expected middleware, was nil instead")
-	}
-
-	handler := mid(EmptyNext)
-	myHandler, ok := handler.(caddylog.Logger)
-
-	if !ok {
-		t.Fatalf("Expected handler to be type Logger, got: %#v", handler)
-	}
-
-	if myHandler.Rules[0].PathScope != "/" {
-		t.Errorf("Expected / as the default PathScope")
-	}
-	if myHandler.Rules[0].OutputFile != caddylog.DefaultLogFilename {
-		t.Errorf("Expected %s as the default OutputFile", caddylog.DefaultLogFilename)
-	}
-	if myHandler.Rules[0].Format != caddylog.DefaultLogFormat {
-		t.Errorf("Expected %s as the default Log Format", caddylog.DefaultLogFormat)
-	}
-	if !SameNext(myHandler.Next, EmptyNext) {
-		t.Error("'Next' field of handler was not set properly")
-	}
-
-}
-
-func TestLogParse(t *testing.T) {
-	tests := []struct {
-		inputLogRules    string
-		shouldErr        bool
-		expectedLogRules []caddylog.Rule
-	}{
-		{`log`, false, []caddylog.Rule{{
-			PathScope:  "/",
-			OutputFile: caddylog.DefaultLogFilename,
-			Format:     caddylog.DefaultLogFormat,
-		}}},
-		{`log log.txt`, false, []caddylog.Rule{{
-			PathScope:  "/",
-			OutputFile: "log.txt",
-			Format:     caddylog.DefaultLogFormat,
-		}}},
-		{`log /api log.txt`, false, []caddylog.Rule{{
-			PathScope:  "/api",
-			OutputFile: "log.txt",
-			Format:     caddylog.DefaultLogFormat,
-		}}},
-		{`log /serve stdout`, false, []caddylog.Rule{{
-			PathScope:  "/serve",
-			OutputFile: "stdout",
-			Format:     caddylog.DefaultLogFormat,
-		}}},
-		{`log /myapi log.txt {common}`, false, []caddylog.Rule{{
-			PathScope:  "/myapi",
-			OutputFile: "log.txt",
-			Format:     caddylog.CommonLogFormat,
-		}}},
-		{`log /test accesslog.txt {combined}`, false, []caddylog.Rule{{
-			PathScope:  "/test",
-			OutputFile: "accesslog.txt",
-			Format:     caddylog.CombinedLogFormat,
-		}}},
-		{`log /api1 log.txt 
-		  log /api2 accesslog.txt {combined}`, false, []caddylog.Rule{{
-			PathScope:  "/api1",
-			OutputFile: "log.txt",
-			Format:     caddylog.DefaultLogFormat,
-		}, {
-			PathScope:  "/api2",
-			OutputFile: "accesslog.txt",
-			Format:     caddylog.CombinedLogFormat,
-		}}},
-		{`log /api3 stdout {host}
-		  log /api4 log.txt {when}`, false, []caddylog.Rule{{
-			PathScope:  "/api3",
-			OutputFile: "stdout",
-			Format:     "{host}",
-		}, {
-			PathScope:  "/api4",
-			OutputFile: "log.txt",
-			Format:     "{when}",
-		}}},
-	}
-	for i, test := range tests {
-		c := NewTestController(test.inputLogRules)
-		actualLogRules, err := logParse(c)
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		}
-		if len(actualLogRules) != len(test.expectedLogRules) {
-			t.Fatalf("Test %d expected %d no of Log rules, but got %d ",
-				i, len(test.expectedLogRules), len(actualLogRules))
-		}
-		for j, actualLogRule := range actualLogRules {
-
-			if actualLogRule.PathScope != test.expectedLogRules[j].PathScope {
-				t.Errorf("Test %d expected %dth LogRule PathScope to be  %s  , but got %s",
-					i, j, test.expectedLogRules[j].PathScope, actualLogRule.PathScope)
-			}
-
-			if actualLogRule.OutputFile != test.expectedLogRules[j].OutputFile {
-				t.Errorf("Test %d expected %dth LogRule OutputFile to be  %s  , but got %s",
-					i, j, test.expectedLogRules[j].OutputFile, actualLogRule.OutputFile)
-			}
-
-			if actualLogRule.Format != test.expectedLogRules[j].Format {
-				t.Errorf("Test %d expected %dth LogRule Format to be  %s  , but got %s",
-					i, j, test.expectedLogRules[j].Format, actualLogRule.Format)
-			}
-		}
-	}
-
-}

config/setup/markdown.go

@@ -1,163 +0,0 @@
-package setup
-
-import (
-	"io/ioutil"
-	"net/http"
-	"os"
-	"path"
-	"path/filepath"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/markdown"
-	"github.com/russross/blackfriday"
-)
-
-// Markdown configures a new Markdown middleware instance.
-func Markdown(c *Controller) (middleware.Middleware, error) {
-	mdconfigs, err := markdownParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	md := markdown.Markdown{
-		Root:       c.Root,
-		FileSys:    http.Dir(c.Root),
-		Configs:    mdconfigs,
-		IndexFiles: []string{"index.md"},
-	}
-
-	// For any configs that enabled static site gen, sweep the whole path at startup
-	c.Startup = append(c.Startup, func() error {
-		for _, cfg := range mdconfigs {
-			if cfg.StaticDir == "" {
-				continue
-			}
-
-			// If generated site already exists, clear it out
-			_, err := os.Stat(cfg.StaticDir)
-			if err == nil {
-				err := os.RemoveAll(cfg.StaticDir)
-				if err != nil {
-					return err
-				}
-			}
-
-			fp := filepath.Join(md.Root, cfg.PathScope)
-			filepath.Walk(fp, func(path string, info os.FileInfo, err error) error {
-				for _, ext := range cfg.Extensions {
-					if !info.IsDir() && strings.HasSuffix(info.Name(), ext) {
-						// Load the file
-						body, err := ioutil.ReadFile(path)
-						if err != nil {
-							return err
-						}
-
-						// Get the relative path as if it were a HTTP request,
-						// then prepend with "/" (like a real HTTP request)
-						reqPath, err := filepath.Rel(md.Root, path)
-						if err != nil {
-							return err
-						}
-						reqPath = "/" + reqPath
-
-						// Generate the static file
-						_, err = md.Process(cfg, reqPath, body)
-						if err != nil {
-							return err
-						}
-
-						break // don't try other file extensions
-					}
-				}
-
-				return nil
-			})
-		}
-
-		return nil
-	})
-
-	return func(next middleware.Handler) middleware.Handler {
-		md.Next = next
-		return md
-	}, nil
-}
-
-func markdownParse(c *Controller) ([]markdown.Config, error) {
-	var mdconfigs []markdown.Config
-
-	for c.Next() {
-		md := markdown.Config{
-			Renderer:    blackfriday.HtmlRenderer(0, "", ""),
-			Templates:   make(map[string]string),
-			StaticFiles: make(map[string]string),
-		}
-
-		// Get the path scope
-		if !c.NextArg() || c.Val() == "{" {
-			return mdconfigs, c.ArgErr()
-		}
-		md.PathScope = c.Val()
-
-		// Load any other configuration parameters
-		for c.NextBlock() {
-			switch c.Val() {
-			case "ext":
-				exts := c.RemainingArgs()
-				if len(exts) == 0 {
-					return mdconfigs, c.ArgErr()
-				}
-				md.Extensions = append(md.Extensions, exts...)
-			case "css":
-				if !c.NextArg() {
-					return mdconfigs, c.ArgErr()
-				}
-				md.Styles = append(md.Styles, c.Val())
-			case "js":
-				if !c.NextArg() {
-					return mdconfigs, c.ArgErr()
-				}
-				md.Scripts = append(md.Scripts, c.Val())
-			case "template":
-				tArgs := c.RemainingArgs()
-				switch len(tArgs) {
-				case 0:
-					return mdconfigs, c.ArgErr()
-				case 1:
-					if _, ok := md.Templates[markdown.DefaultTemplate]; ok {
-						return mdconfigs, c.Err("only one default template is allowed, use alias.")
-					}
-					fpath := filepath.Clean(c.Root + string(filepath.Separator) + tArgs[0])
-					md.Templates[markdown.DefaultTemplate] = fpath
-				case 2:
-					fpath := filepath.Clean(c.Root + string(filepath.Separator) + tArgs[1])
-					md.Templates[tArgs[0]] = fpath
-				default:
-					return mdconfigs, c.ArgErr()
-				}
-			case "sitegen":
-				if c.NextArg() {
-					md.StaticDir = path.Join(c.Root, c.Val())
-				} else {
-					md.StaticDir = path.Join(c.Root, markdown.DefaultStaticDir)
-				}
-				if c.NextArg() {
-					// only 1 argument allowed
-					return mdconfigs, c.ArgErr()
-				}
-			default:
-				return mdconfigs, c.Err("Expected valid markdown configuration property")
-			}
-		}
-
-		// If no extensions were specified, assume .md
-		if len(md.Extensions) == 0 {
-			md.Extensions = []string{".md"}
-		}
-
-		mdconfigs = append(mdconfigs, md)
-	}
-
-	return mdconfigs, nil
-}

config/setup/proxy.go

@@ -1,17 +0,0 @@
-package setup
-
-import (
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/proxy"
-)
-
-// Proxy configures a new Proxy middleware instance.
-func Proxy(c *Controller) (middleware.Middleware, error) {
-	if upstreams, err := proxy.NewStaticUpstreams(c.Dispenser); err == nil {
-		return func(next middleware.Handler) middleware.Handler {
-			return proxy.Proxy{Next: next, Upstreams: upstreams}
-		}, nil
-	} else {
-		return nil, err
-	}
-}

config/setup/redir.go

@@ -1,83 +0,0 @@
-package setup
-
-import (
-	"net/http"
-
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/redirect"
-)
-
-// Redir configures a new Redirect middleware instance.
-func Redir(c *Controller) (middleware.Middleware, error) {
-	rules, err := redirParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	return func(next middleware.Handler) middleware.Handler {
-		return redirect.Redirect{Next: next, Rules: rules}
-	}, nil
-}
-
-func redirParse(c *Controller) ([]redirect.Rule, error) {
-	var redirects []redirect.Rule
-
-	for c.Next() {
-		var rule redirect.Rule
-		args := c.RemainingArgs()
-
-		// Always set the default Code, then overwrite
-		rule.Code = http.StatusMovedPermanently
-
-		switch len(args) {
-		case 1:
-			// To specified
-			rule.From = "/"
-			rule.To = args[0]
-		case 2:
-			// To and Code specified
-			rule.From = "/"
-			rule.To = args[0]
-			if "meta" == args[1] {
-				rule.Meta = true
-			} else 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 "meta" == args[2] {
-				rule.Meta = true
-			} else 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
-}
-
-// 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,
-}

config/setup/rewrite.go

@@ -1,79 +0,0 @@
-package setup
-
-import (
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/rewrite"
-)
-
-// Rewrite configures a new Rewrite middleware instance.
-func Rewrite(c *Controller) (middleware.Middleware, error) {
-	rewrites, err := rewriteParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	return func(next middleware.Handler) middleware.Handler {
-		return rewrite.Rewrite{Next: next, Rules: rewrites}
-	}, nil
-}
-
-func rewriteParse(c *Controller) ([]rewrite.Rule, error) {
-	var simpleRules []rewrite.Rule
-	var regexpRules []rewrite.Rule
-
-	for c.Next() {
-		var rule rewrite.Rule
-		var err error
-		var base = "/"
-		var pattern, to string
-		var ext []string
-
-		args := c.RemainingArgs()
-
-		switch len(args) {
-		case 2:
-			rule = rewrite.NewSimpleRule(args[0], args[1])
-			simpleRules = append(simpleRules, rule)
-		case 1:
-			base = args[0]
-			fallthrough
-		case 0:
-			for c.NextBlock() {
-				switch c.Val() {
-				case "r", "regexp":
-					if !c.NextArg() {
-						return nil, c.ArgErr()
-					}
-					pattern = c.Val()
-				case "to":
-					if !c.NextArg() {
-						return nil, c.ArgErr()
-					}
-					to = c.Val()
-				case "ext":
-					args1 := c.RemainingArgs()
-					if len(args1) == 0 {
-						return nil, c.ArgErr()
-					}
-					ext = args1
-				default:
-					return nil, c.ArgErr()
-				}
-			}
-			// ensure pattern and to are specified
-			if pattern == "" || to == "" {
-				return nil, c.ArgErr()
-			}
-			if rule, err = rewrite.NewRegexpRule(base, pattern, to, ext); err != nil {
-				return nil, err
-			}
-			regexpRules = append(regexpRules, rule)
-		default:
-			return nil, c.ArgErr()
-		}
-
-	}
-
-	// put simple rules in front to avoid regexp computation for them
-	return append(simpleRules, regexpRules...), nil
-}

config/setup/rewrite_test.go

@@ -1,185 +0,0 @@
-package setup
-
-import (
-	"testing"
-
-	"fmt"
-	"regexp"
-
-	"github.com/mholt/caddy/middleware/rewrite"
-)
-
-func TestRewrite(t *testing.T) {
-	c := NewTestController(`rewrite /from /to`)
-
-	mid, err := Rewrite(c)
-	if err != nil {
-		t.Errorf("Expected no errors, but got: %v", err)
-	}
-	if mid == nil {
-		t.Fatal("Expected middleware, was nil instead")
-	}
-
-	handler := mid(EmptyNext)
-	myHandler, ok := handler.(rewrite.Rewrite)
-	if !ok {
-		t.Fatalf("Expected handler to be type Rewrite, got: %#v", handler)
-	}
-
-	if !SameNext(myHandler.Next, EmptyNext) {
-		t.Error("'Next' field of handler was not set properly")
-	}
-
-	if len(myHandler.Rules) != 1 {
-		t.Errorf("Expected handler to have %d rule, has %d instead", 1, len(myHandler.Rules))
-	}
-}
-
-func TestRewriteParse(t *testing.T) {
-	simpleTests := []struct {
-		input     string
-		shouldErr bool
-		expected  []rewrite.Rule
-	}{
-		{`rewrite /from /to`, false, []rewrite.Rule{
-			rewrite.SimpleRule{"/from", "/to"},
-		}},
-		{`rewrite /from /to
-		  rewrite a b`, false, []rewrite.Rule{
-			rewrite.SimpleRule{"/from", "/to"},
-			rewrite.SimpleRule{"a", "b"},
-		}},
-		{`rewrite a`, true, []rewrite.Rule{}},
-		{`rewrite`, true, []rewrite.Rule{}},
-		{`rewrite a b c`, true, []rewrite.Rule{
-			rewrite.SimpleRule{"a", "b"},
-		}},
-	}
-
-	for i, test := range simpleTests {
-		c := NewTestController(test.input)
-		actual, err := rewriteParse(c)
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		} else if err != nil && test.shouldErr {
-			continue
-		}
-
-		if len(actual) != len(test.expected) {
-			t.Fatalf("Test %d expected %d rules, but got %d",
-				i, len(test.expected), len(actual))
-		}
-
-		for j, e := range test.expected {
-			actualRule := actual[j].(rewrite.SimpleRule)
-			expectedRule := e.(rewrite.SimpleRule)
-
-			if actualRule.From != expectedRule.From {
-				t.Errorf("Test %d, rule %d: Expected From=%s, got %s",
-					i, j, expectedRule.From, actualRule.From)
-			}
-
-			if actualRule.To != expectedRule.To {
-				t.Errorf("Test %d, rule %d: Expected To=%s, got %s",
-					i, j, expectedRule.To, actualRule.To)
-			}
-		}
-	}
-
-	regexpTests := []struct {
-		input     string
-		shouldErr bool
-		expected  []rewrite.Rule
-	}{
-		{`rewrite {
-			r	.*
-			to	/to
-		 }`, false, []rewrite.Rule{
-			&rewrite.RegexpRule{"/", "/to", nil, regexp.MustCompile(".*")},
-		}},
-		{`rewrite {
-			regexp	.*
-			to		/to
-			ext		/ html txt
-		 }`, false, []rewrite.Rule{
-			&rewrite.RegexpRule{"/", "/to", []string{"/", "html", "txt"}, regexp.MustCompile(".*")},
-		}},
-		{`rewrite /path {
-			r	rr
-			to	/dest
-		 }
-		 rewrite / {
-		 	regexp	[a-z]+
-		 	to 		/to
-		 }
-		 `, false, []rewrite.Rule{
-			&rewrite.RegexpRule{"/path", "/dest", nil, regexp.MustCompile("rr")},
-			&rewrite.RegexpRule{"/", "/to", nil, regexp.MustCompile("[a-z]+")},
-		}},
-		{`rewrite {
-			to	/to
-		 }`, true, []rewrite.Rule{
-			&rewrite.RegexpRule{},
-		}},
-		{`rewrite {
-			r	.*
-		 }`, true, []rewrite.Rule{
-			&rewrite.RegexpRule{},
-		}},
-		{`rewrite {
-
-		 }`, true, []rewrite.Rule{
-			&rewrite.RegexpRule{},
-		}},
-		{`rewrite /`, true, []rewrite.Rule{
-			&rewrite.RegexpRule{},
-		}},
-	}
-
-	for i, test := range regexpTests {
-		c := NewTestController(test.input)
-		actual, err := rewriteParse(c)
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		} else if err != nil && test.shouldErr {
-			continue
-		}
-
-		if len(actual) != len(test.expected) {
-			t.Fatalf("Test %d expected %d rules, but got %d",
-				i, len(test.expected), len(actual))
-		}
-
-		for j, e := range test.expected {
-			actualRule := actual[j].(*rewrite.RegexpRule)
-			expectedRule := e.(*rewrite.RegexpRule)
-
-			if actualRule.Base != expectedRule.Base {
-				t.Errorf("Test %d, rule %d: Expected Base=%s, got %s",
-					i, j, expectedRule.Base, actualRule.Base)
-			}
-
-			if actualRule.To != expectedRule.To {
-				t.Errorf("Test %d, rule %d: Expected To=%s, got %s",
-					i, j, expectedRule.To, actualRule.To)
-			}
-
-			if fmt.Sprint(actualRule.Exts) != fmt.Sprint(expectedRule.Exts) {
-				t.Errorf("Test %d, rule %d: Expected Ext=%v, got %v",
-					i, j, expectedRule.To, actualRule.To)
-			}
-
-			if actualRule.String() != expectedRule.String() {
-				t.Errorf("Test %d, rule %d: Expected Pattern=%s, got %s",
-					i, j, expectedRule.String(), actualRule.String())
-			}
-		}
-	}
-
-}

config/setup/root.go

@@ -1,31 +0,0 @@
-package setup
-
-import (
-	"log"
-	"os"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-func Root(c *Controller) (middleware.Middleware, error) {
-	for c.Next() {
-		if !c.NextArg() {
-			return nil, c.ArgErr()
-		}
-		c.Root = c.Val()
-	}
-
-	// Check if root path exists
-	_, err := os.Stat(c.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 does not exist: %s", c.Root)
-		} else {
-			return nil, c.Errf("Unable to access root path '%s': %v", c.Root, err)
-		}
-	}
-
-	return nil, nil
-}

config/setup/startupshutdown.go

@@ -1,58 +0,0 @@
-package setup
-
-import (
-	"os"
-	"os/exec"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-func Startup(c *Controller) (middleware.Middleware, error) {
-	return nil, registerCallback(c, &c.Startup)
-}
-
-func Shutdown(c *Controller) (middleware.Middleware, error) {
-	return nil, registerCallback(c, &c.Shutdown)
-}
-
-// registerCallback registers a callback function to execute by
-// using c to parse the line. It appends the callback function
-// to the list of callback functions passed in by reference.
-func registerCallback(c *Controller, list *[]func() error) error {
-	for c.Next() {
-		args := c.RemainingArgs()
-		if len(args) == 0 {
-			return c.ArgErr()
-		}
-
-		nonblock := false
-		if len(args) > 1 && args[len(args)-1] == "&" {
-			// Run command in background; non-blocking
-			nonblock = true
-			args = args[:len(args)-1]
-		}
-
-		command, args, err := middleware.SplitCommandAndArgs(strings.Join(args, " "))
-		if err != nil {
-			return c.Err(err.Error())
-		}
-
-		fn := func() error {
-			cmd := exec.Command(command, args...)
-			cmd.Stdin = os.Stdin
-			cmd.Stdout = os.Stdout
-			cmd.Stderr = os.Stderr
-
-			if nonblock {
-				return cmd.Start()
-			} else {
-				return cmd.Run()
-			}
-		}
-
-		*list = append(*list, fn)
-	}
-
-	return nil
-}

config/setup/templates.go

@@ -1,61 +0,0 @@
-package setup
-
-import (
-	"net/http"
-
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/templates"
-)
-
-// Templates configures a new Templates middleware instance.
-func Templates(c *Controller) (middleware.Middleware, error) {
-	rules, err := templatesParse(c)
-	if err != nil {
-		return nil, err
-	}
-
-	tmpls := templates.Templates{
-		Rules:   rules,
-		Root:    c.Root,
-		FileSys: http.Dir(c.Root),
-	}
-
-	return func(next middleware.Handler) middleware.Handler {
-		tmpls.Next = next
-		return tmpls
-	}, nil
-}
-
-func templatesParse(c *Controller) ([]templates.Rule, error) {
-	var rules []templates.Rule
-
-	for c.Next() {
-		var rule templates.Rule
-
-		if c.NextArg() {
-			// First argument would be the path
-			rule.Path = c.Val()
-
-			// Any remaining arguments are extensions
-			rule.Extensions = c.RemainingArgs()
-			if len(rule.Extensions) == 0 {
-				rule.Extensions = defaultTemplateExtensions
-			}
-		} else {
-			rule.Path = defaultTemplatePath
-			rule.Extensions = defaultTemplateExtensions
-		}
-
-		for _, ext := range rule.Extensions {
-			rule.IndexFiles = append(rule.IndexFiles, "index"+ext)
-		}
-
-		rules = append(rules, rule)
-	}
-
-	return rules, nil
-}
-
-const defaultTemplatePath = "/"
-
-var defaultTemplateExtensions = []string{".html", ".htm", ".tmpl", ".tpl", ".txt"}

config/setup/templates_test.go

@@ -1,94 +0,0 @@
-package setup
-
-import (
-	"fmt"
-	"github.com/mholt/caddy/middleware/templates"
-	"testing"
-)
-
-func TestTemplates(t *testing.T) {
-
-	c := NewTestController(`templates`)
-
-	mid, err := Templates(c)
-
-	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-
-	if mid == nil {
-		t.Fatal("Expected middleware, was nil instead")
-	}
-
-	handler := mid(EmptyNext)
-	myHandler, ok := handler.(templates.Templates)
-
-	if !ok {
-		t.Fatalf("Expected handler to be type Templates, got: %#v", handler)
-	}
-
-	if myHandler.Rules[0].Path != defaultTemplatePath {
-		t.Errorf("Expected / as the default Path")
-	}
-	if fmt.Sprint(myHandler.Rules[0].Extensions) != fmt.Sprint(defaultTemplateExtensions) {
-		t.Errorf("Expected %v to be the Default Extensions", defaultTemplateExtensions)
-	}
-	var indexFiles []string
-	for _, extension := range defaultTemplateExtensions {
-		indexFiles = append(indexFiles, "index"+extension)
-	}
-	if fmt.Sprint(myHandler.Rules[0].IndexFiles) != fmt.Sprint(indexFiles) {
-		t.Errorf("Expected %v to be the Default Index files", indexFiles)
-	}
-}
-func TestTemplatesParse(t *testing.T) {
-	tests := []struct {
-		inputTemplateConfig    string
-		shouldErr              bool
-		expectedTemplateConfig []templates.Rule
-	}{
-		{`templates /api1`, false, []templates.Rule{{
-			Path:       "/api1",
-			Extensions: defaultTemplateExtensions,
-		}}},
-		{`templates /api2 .txt .htm`, false, []templates.Rule{{
-			Path:       "/api2",
-			Extensions: []string{".txt", ".htm"},
-		}}},
-
-		{`templates /api3 .htm .html  
-		  templates /api4 .txt .tpl `, false, []templates.Rule{{
-			Path:       "/api3",
-			Extensions: []string{".htm", ".html"},
-		}, {
-			Path:       "/api4",
-			Extensions: []string{".txt", ".tpl"},
-		}}},
-	}
-	for i, test := range tests {
-		c := NewTestController(test.inputTemplateConfig)
-		actualTemplateConfigs, err := templatesParse(c)
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		}
-		if len(actualTemplateConfigs) != len(test.expectedTemplateConfig) {
-			t.Fatalf("Test %d expected %d no of Template configs, but got %d ",
-				i, len(test.expectedTemplateConfig), len(actualTemplateConfigs))
-		}
-		for j, actualTemplateConfig := range actualTemplateConfigs {
-
-			if actualTemplateConfig.Path != test.expectedTemplateConfig[j].Path {
-				t.Errorf("Test %d expected %dth Template Config Path to be  %s  , but got %s",
-					i, j, test.expectedTemplateConfig[j].Path, actualTemplateConfig.Path)
-			}
-
-			if fmt.Sprint(actualTemplateConfig.Extensions) != fmt.Sprint(test.expectedTemplateConfig[j].Extensions) {
-				t.Errorf("Expected %v to be the  Extensions , but got %v instead", test.expectedTemplateConfig[j].Extensions, actualTemplateConfig.Extensions)
-			}
-		}
-	}
-
-}

config/setup/tls.go

@@ -1,139 +0,0 @@
-package setup
-
-import (
-	"crypto/tls"
-	"log"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-func TLS(c *Controller) (middleware.Middleware, error) {
-	c.TLS.Enabled = true
-	if c.Port == "http" {
-		c.TLS.Enabled = false
-		log.Printf("Warning: TLS disabled for %s://%s. To force TLS over the plaintext HTTP port, "+
-			"specify port 80 explicitly (https://%s:80).", c.Port, c.Host, c.Host)
-	}
-
-	for c.Next() {
-		if !c.NextArg() {
-			return nil, c.ArgErr()
-		}
-		c.TLS.Certificate = c.Val()
-
-		if !c.NextArg() {
-			return nil, c.ArgErr()
-		}
-		c.TLS.Key = c.Val()
-
-		// Optional block
-		for c.NextBlock() {
-			switch c.Val() {
-			case "protocols":
-				args := c.RemainingArgs()
-				if len(args) != 2 {
-					return nil, c.ArgErr()
-				}
-				value, ok := supportedProtocols[strings.ToLower(args[0])]
-				if !ok {
-					return nil, c.Errf("Wrong protocol name or protocol not supported '%s'", c.Val())
-				}
-				c.TLS.ProtocolMinVersion = value
-				value, ok = supportedProtocols[strings.ToLower(args[1])]
-				if !ok {
-					return nil, c.Errf("Wrong protocol name or protocol not supported '%s'", c.Val())
-				}
-				c.TLS.ProtocolMaxVersion = value
-			case "ciphers":
-				for c.NextArg() {
-					value, ok := supportedCiphersMap[strings.ToUpper(c.Val())]
-					if !ok {
-						return nil, c.Errf("Wrong cipher name or cipher not supported '%s'", c.Val())
-					}
-					c.TLS.Ciphers = append(c.TLS.Ciphers, value)
-				}
-			case "clients":
-				c.TLS.ClientCerts = c.RemainingArgs()
-				if len(c.TLS.ClientCerts) == 0 {
-					return nil, c.ArgErr()
-				}
-			default:
-				return nil, c.Errf("Unknown keyword '%s'", c.Val())
-			}
-		}
-	}
-
-	// If no ciphers provided, use all that Caddy supports for the protocol
-	if len(c.TLS.Ciphers) == 0 {
-		c.TLS.Ciphers = supportedCiphers
-	}
-
-	// Not a cipher suite, but still important for mitigating protocol downgrade attacks
-	c.TLS.Ciphers = append(c.TLS.Ciphers, tls.TLS_FALLBACK_SCSV)
-
-	// Set default protocol min and max versions - must balance compatibility and security
-	if c.TLS.ProtocolMinVersion == 0 {
-		c.TLS.ProtocolMinVersion = tls.VersionTLS10
-	}
-	if c.TLS.ProtocolMaxVersion == 0 {
-		c.TLS.ProtocolMaxVersion = tls.VersionTLS12
-	}
-
-	// Prefer server cipher suites
-	c.TLS.PreferServerCipherSuites = true
-
-	return nil, nil
-}
-
-// Map of supported protocols
-// SSLv3 will be not supported in future release
-// HTTP/2 only supports TLS 1.2 and higher
-var supportedProtocols = map[string]uint16{
-	"ssl3.0": tls.VersionSSL30,
-	"tls1.0": tls.VersionTLS10,
-	"tls1.1": tls.VersionTLS11,
-	"tls1.2": tls.VersionTLS12,
-}
-
-// Map of supported ciphers, used only for parsing config.
-//
-// Note that, at time of writing, HTTP/2 blacklists 276 cipher suites,
-// including all but two of the suites below (the two GCM suites).
-// See https://http2.github.io/http2-spec/#BadCipherSuites
-//
-// TLS_FALLBACK_SCSV is not in this list because we manually ensure
-// it is always added (even though it is not technically a cipher suite).
-//
-// This map, like any map, is NOT ORDERED. Do not range over this map.
-var supportedCiphersMap = map[string]uint16{
-	"ECDHE-RSA-AES128-GCM-SHA256":   tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-	"ECDHE-ECDSA-AES128-GCM-SHA256": tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-	"ECDHE-RSA-AES128-CBC-SHA":      tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
-	"ECDHE-RSA-AES256-CBC-SHA":      tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
-	"ECDHE-ECDSA-AES256-CBC-SHA":    tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
-	"ECDHE-ECDSA-AES128-CBC-SHA":    tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
-	"RSA-AES128-CBC-SHA":            tls.TLS_RSA_WITH_AES_128_CBC_SHA,
-	"RSA-AES256-CBC-SHA":            tls.TLS_RSA_WITH_AES_256_CBC_SHA,
-	"ECDHE-RSA-3DES-EDE-CBC-SHA":    tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
-	"RSA-3DES-EDE-CBC-SHA":          tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
-}
-
-// List of supported cipher suites in descending order of preference.
-// Ordering is very important! Getting the wrong order will break
-// mainstream clients, especially with HTTP/2.
-//
-// Note that TLS_FALLBACK_SCSV is not in this list since it is always
-// added manually.
-var supportedCiphers = []uint16{
-	tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-	tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-	tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
-	tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
-	tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
-	tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
-	tls.TLS_RSA_WITH_AES_256_CBC_SHA,
-	tls.TLS_RSA_WITH_AES_128_CBC_SHA,
-	tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
-	tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
-}

config/setup/tls_test.go

@@ -1,160 +0,0 @@
-package setup
-
-import (
-	"crypto/tls"
-	"testing"
-)
-
-func TestTLSParseBasic(t *testing.T) {
-	c := NewTestController(`tls cert.pem key.pem`)
-
-	_, err := TLS(c)
-	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-
-	// Basic checks
-	if c.TLS.Certificate != "cert.pem" {
-		t.Errorf("Expected certificate arg to be 'cert.pem', was '%s'", c.TLS.Certificate)
-	}
-	if c.TLS.Key != "key.pem" {
-		t.Errorf("Expected key arg to be 'key.pem', was '%s'", c.TLS.Key)
-	}
-	if !c.TLS.Enabled {
-		t.Error("Expected TLS Enabled=true, but was false")
-	}
-
-	// Security defaults
-	if c.TLS.ProtocolMinVersion != tls.VersionTLS10 {
-		t.Errorf("Expected 'tls1.0 (0x0301)' as ProtocolMinVersion, got %#v", c.TLS.ProtocolMinVersion)
-	}
-	if c.TLS.ProtocolMaxVersion != tls.VersionTLS12 {
-		t.Errorf("Expected 'tls1.2 (0x0303)' as ProtocolMaxVersion, got %v", c.TLS.ProtocolMaxVersion)
-	}
-
-	// Cipher checks
-	expectedCiphers := []uint16{
-		tls.TLS_ECDHE_ECDSA_WITH_AES_128_GCM_SHA256,
-		tls.TLS_ECDHE_RSA_WITH_AES_128_GCM_SHA256,
-		tls.TLS_ECDHE_RSA_WITH_AES_256_CBC_SHA,
-		tls.TLS_ECDHE_RSA_WITH_AES_128_CBC_SHA,
-		tls.TLS_ECDHE_ECDSA_WITH_AES_256_CBC_SHA,
-		tls.TLS_ECDHE_ECDSA_WITH_AES_128_CBC_SHA,
-		tls.TLS_RSA_WITH_AES_256_CBC_SHA,
-		tls.TLS_RSA_WITH_AES_128_CBC_SHA,
-		tls.TLS_ECDHE_RSA_WITH_3DES_EDE_CBC_SHA,
-		tls.TLS_RSA_WITH_3DES_EDE_CBC_SHA,
-		tls.TLS_FALLBACK_SCSV,
-	}
-
-	// Ensure count is correct (plus one for TLS_FALLBACK_SCSV)
-	if len(c.TLS.Ciphers) != len(supportedCiphers)+1 {
-		t.Errorf("Expected %v Ciphers (including TLS_FALLBACK_SCSV), got %v",
-			len(supportedCiphers)+1, len(c.TLS.Ciphers))
-	}
-
-	// Ensure ordering is correct
-	for i, actual := range c.TLS.Ciphers {
-		if actual != expectedCiphers[i] {
-			t.Errorf("Expected cipher in position %d to be %0x, got %0x", i, expectedCiphers[i], actual)
-		}
-	}
-
-	if !c.TLS.PreferServerCipherSuites {
-		t.Error("Expected PreferServerCipherSuites = true, but was false")
-	}
-}
-
-func TestTLSParseIncompleteParams(t *testing.T) {
-	c := NewTestController(`tls`)
-
-	_, err := TLS(c)
-	if err == nil {
-		t.Errorf("Expected errors, but no error returned")
-	}
-
-	c = NewTestController(`tls cert.key`)
-
-	_, err = TLS(c)
-	if err == nil {
-		t.Errorf("Expected errors, but no error returned")
-	}
-}
-
-func TestTLSParseWithOptionalParams(t *testing.T) {
-	params := `tls cert.crt cert.key {
-            protocols ssl3.0 tls1.2
-            ciphers RSA-3DES-EDE-CBC-SHA RSA-AES256-CBC-SHA ECDHE-RSA-AES128-GCM-SHA256
-        }`
-	c := NewTestController(params)
-
-	_, err := TLS(c)
-	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-
-	if c.TLS.ProtocolMinVersion != tls.VersionSSL30 {
-		t.Errorf("Expected 'ssl3.0 (0x0300)' as ProtocolMinVersion, got %#v", c.TLS.ProtocolMinVersion)
-	}
-
-	if c.TLS.ProtocolMaxVersion != tls.VersionTLS12 {
-		t.Errorf("Expected 'tls1.2 (0x0302)' as ProtocolMaxVersion, got %#v", c.TLS.ProtocolMaxVersion)
-	}
-
-	if len(c.TLS.Ciphers)-1 != 3 {
-		t.Errorf("Expected 3 Ciphers (not including TLS_FALLBACK_SCSV), got %v", len(c.TLS.Ciphers))
-	}
-}
-
-func TestTLSParseWithWrongOptionalParams(t *testing.T) {
-	// Test protocols wrong params
-	params := `tls cert.crt cert.key {
-			protocols ssl tls
-		}`
-	c := NewTestController(params)
-	_, err := TLS(c)
-	if err == nil {
-		t.Errorf("Expected errors, but no error returned")
-	}
-
-	// Test ciphers wrong params
-	params = `tls cert.crt cert.key {
-			ciphers not-valid-cipher
-		}`
-	c = NewTestController(params)
-	_, err = TLS(c)
-	if err == nil {
-		t.Errorf("Expected errors, but no error returned")
-	}
-}
-
-func TestTLSParseWithClientAuth(t *testing.T) {
-	params := `tls cert.crt cert.key {
-			clients client_ca.crt client2_ca.crt
-		}`
-	c := NewTestController(params)
-	_, err := TLS(c)
-	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-
-	if count := len(c.TLS.ClientCerts); count != 2 {
-		t.Fatalf("Expected two client certs, had %d", count)
-	}
-	if actual := c.TLS.ClientCerts[0]; actual != "client_ca.crt" {
-		t.Errorf("Expected first client cert file to be '%s', but was '%s'", "client_ca.crt", actual)
-	}
-	if actual := c.TLS.ClientCerts[1]; actual != "client2_ca.crt" {
-		t.Errorf("Expected second client cert file to be '%s', but was '%s'", "client2_ca.crt", actual)
-	}
-
-	// Test missing client cert file
-	params = `tls cert.crt cert.key {
-			clients
-		}`
-	c = NewTestController(params)
-	_, err = TLS(c)
-	if err == nil {
-		t.Errorf("Expected an error, but no error returned")
-	}
-}

config/setup/websocket.go

@@ -1,87 +0,0 @@
-package setup
-
-import (
-	"github.com/mholt/caddy/middleware"
-	"github.com/mholt/caddy/middleware/websockets"
-)
-
-// WebSocket configures a new WebSockets middleware instance.
-func WebSocket(c *Controller) (middleware.Middleware, error) {
-
-	websocks, err := webSocketParse(c)
-	if err != nil {
-		return nil, err
-	}
-	websockets.GatewayInterface = c.AppName + "-CGI/1.1"
-	websockets.ServerSoftware = c.AppName + "/" + c.AppVersion
-
-	return func(next middleware.Handler) middleware.Handler {
-		return websockets.WebSockets{Next: next, Sockets: websocks}
-	}, nil
-}
-
-func webSocketParse(c *Controller) ([]websockets.Config, error) {
-	var websocks []websockets.Config
-	var respawn bool
-
-	optionalBlock := func() (hadBlock bool, err error) {
-		for c.NextBlock() {
-			hadBlock = true
-			if c.Val() == "respawn" {
-				respawn = true
-			} else {
-				return true, c.Err("Expected websocket configuration parameter in block")
-			}
-		}
-		return
-	}
-
-	for c.Next() {
-		var val, path, command string
-
-		// Path or command; not sure which yet
-		if !c.NextArg() {
-			return nil, c.ArgErr()
-		}
-		val = c.Val()
-
-		// Extra configuration may be in a block
-		hadBlock, err := optionalBlock()
-		if err != nil {
-			return nil, err
-		}
-
-		if !hadBlock {
-			// The next argument on this line will be the command or an open curly brace
-			if c.NextArg() {
-				path = val
-				command = c.Val()
-			} else {
-				path = "/"
-				command = val
-			}
-
-			// Okay, check again for optional block
-			hadBlock, err = optionalBlock()
-			if err != nil {
-				return nil, err
-			}
-		}
-
-		// Split command into the actual command and its arguments
-		cmd, args, err := middleware.SplitCommandAndArgs(command)
-		if err != nil {
-			return nil, err
-		}
-
-		websocks = append(websocks, websockets.Config{
-			Path:      path,
-			Command:   cmd,
-			Arguments: args,
-			Respawn:   respawn, // TODO: This isn't used currently
-		})
-	}
-
-	return websocks, nil
-
-}

config/setup/websocket_test.go

@@ -1,85 +0,0 @@
-package setup
-
-import (
-	"github.com/mholt/caddy/middleware/websockets"
-	"testing"
-)
-
-func TestWebSocket(t *testing.T) {
-
-	c := NewTestController(`websocket cat`)
-
-	mid, err := WebSocket(c)
-
-	if err != nil {
-		t.Errorf("Expected no errors, got: %v", err)
-	}
-
-	if mid == nil {
-		t.Fatal("Expected middleware, was nil instead")
-	}
-
-	handler := mid(EmptyNext)
-	myHandler, ok := handler.(websockets.WebSockets)
-
-	if !ok {
-		t.Fatalf("Expected handler to be type WebSockets, got: %#v", handler)
-	}
-
-	if myHandler.Sockets[0].Path != "/" {
-		t.Errorf("Expected / as the default Path")
-	}
-	if myHandler.Sockets[0].Command != "cat" {
-		t.Errorf("Expected %s as the command", "cat")
-	}
-
-}
-func TestWebSocketParse(t *testing.T) {
-	tests := []struct {
-		inputWebSocketConfig    string
-		shouldErr               bool
-		expectedWebSocketConfig []websockets.Config
-	}{
-		{`websocket /api1 cat`, false, []websockets.Config{{
-			Path:    "/api1",
-			Command: "cat",
-		}}},
-
-		{`websocket /api3 cat  
-		  websocket /api4 cat `, false, []websockets.Config{{
-			Path:    "/api3",
-			Command: "cat",
-		}, {
-			Path:    "/api4",
-			Command: "cat",
-		}}},
-	}
-	for i, test := range tests {
-		c := NewTestController(test.inputWebSocketConfig)
-		actualWebSocketConfigs, err := webSocketParse(c)
-
-		if err == nil && test.shouldErr {
-			t.Errorf("Test %d didn't error, but it should have", i)
-		} else if err != nil && !test.shouldErr {
-			t.Errorf("Test %d errored, but it shouldn't have; got '%v'", i, err)
-		}
-		if len(actualWebSocketConfigs) != len(test.expectedWebSocketConfig) {
-			t.Fatalf("Test %d expected %d no of WebSocket configs, but got %d ",
-				i, len(test.expectedWebSocketConfig), len(actualWebSocketConfigs))
-		}
-		for j, actualWebSocketConfig := range actualWebSocketConfigs {
-
-			if actualWebSocketConfig.Path != test.expectedWebSocketConfig[j].Path {
-				t.Errorf("Test %d expected %dth WebSocket Config Path to be  %s  , but got %s",
-					i, j, test.expectedWebSocketConfig[j].Path, actualWebSocketConfig.Path)
-			}
-
-			if actualWebSocketConfig.Command != test.expectedWebSocketConfig[j].Command {
-				t.Errorf("Test %d expected %dth WebSocket Config Command to be  %s  , but got %s",
-					i, j, test.expectedWebSocketConfig[j].Command, actualWebSocketConfig.Command)
-			}
-
-		}
-	}
-
-}

dist/CHANGES.txt

@@ -1,82 +0,0 @@
-CHANGES
-
-
-0.7.2 (July 1, 2015)
-- Custom builds through caddyserver.com - extend Caddy by writing addons
-- browse: Sort by clicking column heading or using query string
-- core: Serving hostname that doesn't resolve issues warning then listens on 0.0.0.0
-- errors: Missing error page during parse time is warning, not error
-- ext: Extension only appended if request path does not end in /
-- fastcgi: Fix for backend responding without status text
-- fastcgi: Fix PATH_TRANSLATED when PATH_INFO is empty (RFC 3875)
-- git: Removed from core (available as add-on)
-- gzip: Enable by file path and/or extension
-- gzip: Customize compression level
-- log: Fix for missing status in log entry when error unhandled
-- proxy: Strip prefix from path for proxy to path
-- redir: Meta tag redirects
-- templates: Support for nested includes
-- Internal improvements and more tests
-
-
-0.7.1 (June 2, 2015)
-- basicauth: Patched timing vulnerability
-- proxy: Support for WebSocket backends
-- tls: Client authentication
-
-
-0.7.0 (May 25, 2015)
-- New directive 'internal' to protect resources with X-Accel-Redirect
-- New -version flag to show program name and version
-- core: Fixed escaped backslash characters inside quoted strings
-- core: Fixed parsing Caddyfile for IPv6 addresses missing ports
-- core: A notice is shown when non-local address resolves to loopback interface
-- core: Warns if file descriptor limit is too low for production site (Mac/Linux)
-- fastcgi: Support for Unix sockets
-- git: Fixed issue that prevented pulling at designated interval
-- header: Remove a header field by prefixing field name with "-"
-- markdown: Simple static site generation
-- markdown: Support for metadata ("front matter") at beginning of files
-- rewrite: Experimental support for regular expressions
-- tls: Customize cipher suites and protocols
-- tls: Removed RC4 ciphers
-- Other internal improvements that are not user-facing (more tests, etc.)
-
-
-0.6.0 (May 7, 2015)
-- New directive 'git' to automatically pull changes
-- New directive 'bind' to override host server binds to
-- New -root flag to specify root path to default site
-- Ability to receive config data piped through stdin
-- core: Warning if root directory doesn't exist at startup
-- core: Entire process dies if any server fails to start
-- gzip: Fixed Content-Length value when proxying requests
-- errors: Error log now includes file and line number of panics
-- fastcgi: Pass custom environment variables
-- fastcgi: Support for HEAD, OPTIONS, PUT, PATCH, and DELETE methods
-- fastcgi: Fixed SERVER_SOFTWARE variables
-- markdown: Support for index files when URL points to a directory
-- proxy: Load balancing with multiple backends, health checks, failovers, and multiple policies
-- proxy: Add custom headers
-- startup/shutdown: Run command in background with '&' at end
-- templates: Added .tpl and .tmpl as default extensions
-- templates: Support for index files when URL points to a directory
-- templates: Changed .RemoteAddr to .IP and stripped out remote port
-- tls: TLS disabled (with warning) for servers that are explicitly http://
-- websocket: Fixed SERVER_SOFTWARE and GATEWAY_INTERFACE variables
-- Many internal improvements
-
-
-0.5.1 (April 30, 2015)
-- Default host is now 0.0.0.0 (wildcard)
-- New -host and -port flags to override default host and port
-- core: Support for binding to 0.0.0.0
-- core: Graceful error handling during heavy load; proper error responses
-- errors: Fixed file path handling
-- errors: Fixed panic due to nil log file
-- fastcgi: Support for index files
-- fastcgi: Fix for handling errors that come from responder
-
-
-0.5.0 (April 28, 2015)
-- Initial release

dist/LICENSES.txt

@@ -1,539 +0,0 @@
-The enclosed software makes use of third-party libraries either in full
-or in part, original or modified. This file is part of your download so
-as to be in full compliance with the licenses of all bundled property.
-
-
-
-###
-### github.com/mholt/caddy
-###
-
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "{}"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright {yyyy} {name of copyright owner}
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.
-
-
-
-
-
-
-
-
-
-
-###
-### Go standard library and http2
-###
-
-
-Copyright (c) 2012 The Go Authors. All rights reserved.
-
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-
-   * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-   * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-   * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
-
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
-
-
-
-
-
-
-
-###
-### github.com/russross/blackfriday
-###
-
-
-Blackfriday is distributed under the Simplified BSD License:
-
-> Copyright © 2011 Russ Ross
-> All rights reserved.
->
-> Redistribution and use in source and binary forms, with or without
-> modification, are permitted provided that the following conditions
-> are met:
->
-> 1.  Redistributions of source code must retain the above copyright
->     notice, this list of conditions and the following disclaimer.
->
-> 2.  Redistributions in binary form must reproduce the above
->     copyright notice, this list of conditions and the following
->     disclaimer in the documentation and/or other materials provided with
->     the distribution.
->
-> THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-> "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-> LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
-> FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
-> COPYRIGHT HOLDER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
-> INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
-> BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
-> LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
-> CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
-> LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
-> ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
-> POSSIBILITY OF SUCH DAMAGE.
-
-
-
-
-
-
-
-
-###
-### github.com/dustin/go-humanize
-###
-
-
-Copyright (c) 2005-2008  Dustin Sallings <dustin@spy.net>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE.
-
-<http://www.opensource.org/licenses/mit-license.php>
-
-
-
-
-
-
-
-
-###
-### github.com/flynn/go-shlex
-###
-
-Apache 2.0 license as found in this file
-
-
-
-
-
-
-###
-### github.com/go-yaml/yaml
-###
-
-
-Copyright (c) 2011-2014 - Canonical Inc.
-
-This software is licensed under the LGPLv3, included below.
-
-As a special exception to the GNU Lesser General Public License version 3
-("LGPL3"), the copyright holders of this Library give you permission to
-convey to a third party a Combined Work that links statically or dynamically
-to this Library without providing any Minimal Corresponding Source or
-Minimal Application Code as set out in 4d or providing the installation
-information set out in section 4e, provided that you comply with the other
-provisions of LGPL3 and provided that you meet, for the Application the
-terms and conditions of the license(s) which apply to the Application.
-
-Except as stated in this special exception, the provisions of LGPL3 will
-continue to comply in full to this Library. If you modify this Library, you
-may apply this exception to your version of this Library, but you are not
-obliged to do so. If you do not wish to do so, delete this exception
-statement from your version. This exception does not (and cannot) modify any
-license terms which apply to the Application, with which you must still
-comply.
-
-
-                   GNU LESSER GENERAL PUBLIC LICENSE
-                       Version 3, 29 June 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <http://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-
-  This version of the GNU Lesser General Public License incorporates
-the terms and conditions of version 3 of the GNU General Public
-License, supplemented by the additional permissions listed below.
-
-  0. Additional Definitions.
-
-  As used herein, "this License" refers to version 3 of the GNU Lesser
-General Public License, and the "GNU GPL" refers to version 3 of the GNU
-General Public License.
-
-  "The Library" refers to a covered work governed by this License,
-other than an Application or a Combined Work as defined below.
-
-  An "Application" is any work that makes use of an interface provided
-by the Library, but which is not otherwise based on the Library.
-Defining a subclass of a class defined by the Library is deemed a mode
-of using an interface provided by the Library.
-
-  A "Combined Work" is a work produced by combining or linking an
-Application with the Library.  The particular version of the Library
-with which the Combined Work was made is also called the "Linked
-Version".
-
-  The "Minimal Corresponding Source" for a Combined Work means the
-Corresponding Source for the Combined Work, excluding any source code
-for portions of the Combined Work that, considered in isolation, are
-based on the Application, and not on the Linked Version.
-
-  The "Corresponding Application Code" for a Combined Work means the
-object code and/or source code for the Application, including any data
-and utility programs needed for reproducing the Combined Work from the
-Application, but excluding the System Libraries of the Combined Work.
-
-  1. Exception to Section 3 of the GNU GPL.
-
-  You may convey a covered work under sections 3 and 4 of this License
-without being bound by section 3 of the GNU GPL.
-
-  2. Conveying Modified Versions.
-
-  If you modify a copy of the Library, and, in your modifications, a
-facility refers to a function or data to be supplied by an Application
-that uses the facility (other than as an argument passed when the
-facility is invoked), then you may convey a copy of the modified
-version:
-
-   a) under this License, provided that you make a good faith effort to
-   ensure that, in the event an Application does not supply the
-   function or data, the facility still operates, and performs
-   whatever part of its purpose remains meaningful, or
-
-   b) under the GNU GPL, with none of the additional permissions of
-   this License applicable to that copy.
-
-  3. Object Code Incorporating Material from Library Header Files.
-
-  The object code form of an Application may incorporate material from
-a header file that is part of the Library.  You may convey such object
-code under terms of your choice, provided that, if the incorporated
-material is not limited to numerical parameters, data structure
-layouts and accessors, or small macros, inline functions and templates
-(ten or fewer lines in length), you do both of the following:
-
-   a) Give prominent notice with each copy of the object code that the
-   Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the object code with a copy of the GNU GPL and this license
-   document.
-
-  4. Combined Works.
-
-  You may convey a Combined Work under terms of your choice that,
-taken together, effectively do not restrict modification of the
-portions of the Library contained in the Combined Work and reverse
-engineering for debugging such modifications, if you also do each of
-the following:
-
-   a) Give prominent notice with each copy of the Combined Work that
-   the Library is used in it and that the Library and its use are
-   covered by this License.
-
-   b) Accompany the Combined Work with a copy of the GNU GPL and this license
-   document.
-
-   c) For a Combined Work that displays copyright notices during
-   execution, include the copyright notice for the Library among
-   these notices, as well as a reference directing the user to the
-   copies of the GNU GPL and this license document.
-
-   d) Do one of the following:
-
-       0) Convey the Minimal Corresponding Source under the terms of this
-       License, and the Corresponding Application Code in a form
-       suitable for, and under terms that permit, the user to
-       recombine or relink the Application with a modified version of
-       the Linked Version to produce a modified Combined Work, in the
-       manner specified by section 6 of the GNU GPL for conveying
-       Corresponding Source.
-
-       1) Use a suitable shared library mechanism for linking with the
-       Library.  A suitable mechanism is one that (a) uses at run time
-       a copy of the Library already present on the user's computer
-       system, and (b) will operate properly with a modified version
-       of the Library that is interface-compatible with the Linked
-       Version.
-
-   e) Provide Installation Information, but only if you would otherwise
-   be required to provide such information under section 6 of the
-   GNU GPL, and only to the extent that such information is
-   necessary to install and execute a modified version of the
-   Combined Work produced by recombining or relinking the
-   Application with a modified version of the Linked Version. (If
-   you use option 4d0, the Installation Information must accompany
-   the Minimal Corresponding Source and Corresponding Application
-   Code. If you use option 4d1, you must provide the Installation
-   Information in the manner specified by section 6 of the GNU GPL
-   for conveying Corresponding Source.)
-
-  5. Combined Libraries.
-
-  You may place library facilities that are a work based on the
-Library side by side in a single library together with other library
-facilities that are not Applications and are not covered by this
-License, and convey such a combined library under terms of your
-choice, if you do both of the following:
-
-   a) Accompany the combined library with a copy of the same work based
-   on the Library, uncombined with any other library facilities,
-   conveyed under the terms of this License.
-
-   b) Give prominent notice with the combined library that part of it
-   is a work based on the Library, and explaining where to find the
-   accompanying uncombined form of the same work.
-
-  6. Revised Versions of the GNU Lesser General Public License.
-
-  The Free Software Foundation may publish revised and/or new versions
-of the GNU Lesser General Public License from time to time. Such new
-versions will be similar in spirit to the present version, but may
-differ in detail to address new problems or concerns.
-
-  Each version is given a distinguishing version number. If the
-Library as you received it specifies that a certain numbered version
-of the GNU Lesser General Public License "or any later version"
-applies to it, you have the option of following the terms and
-conditions either of that published version or of any later version
-published by the Free Software Foundation. If the Library as you
-received it does not specify a version number of the GNU Lesser
-General Public License, you may choose any version of the GNU Lesser
-General Public License ever published by the Free Software Foundation.
-
-  If the Library as you received it specifies that a proxy can decide
-whether future versions of the GNU Lesser General Public License shall
-apply, that proxy's public statement of acceptance of any version is
-permanent authorization for you to choose that version for the
-Library.

dist/README.txt

@@ -1,20 +0,0 @@
-CADDY 0.7.2
-
-Website
-	https://caddyserver.com
-
-Source Code
-	https://github.com/mholt/caddy
-
-
-For instructions on using Caddy, please see the user guide on the website. For a list of what's new in this version, see CHANGES.txt.
-
-If you have a question, bug report, or would like to contribute, please open an issue or submit a pull request on GitHub. Your contributions do not go unnoticed!
-
-For a good time, follow @mholt6 on Twitter.
-
-And thanks - you're awesome!
-
-
----
-(c) 2015 Matthew Holt

dist/automate.sh

@@ -1,47 +0,0 @@
-#!/usr/bin/env bash
-set -e
-set -o pipefail
-shopt -s nullglob # if no files match glob, assume empty list instead of string literal
-
-
-## PACKAGE TO BUILD
-Package=github.com/mholt/caddy
-
-
-## PATHS TO USE
-DistDir=$GOPATH/src/$Package/dist
-BuildDir=$DistDir/builds
-ReleaseDir=$DistDir/release
-
-
-## BEGIN
-
-# Compile binaries
-mkdir -p $BuildDir
-cd $BuildDir
-rm -f *
-gox $Package
-
-# Zip them up with release notes and stuff
-mkdir -p $ReleaseDir
-cd $ReleaseDir
-rm -f *
-for f in $BuildDir/*
-do
-	# Name .zip file same as binary, but strip .exe from end
-	zipname=$(basename ${f%".exe"}).zip
-
-	# Binary inside the zip file is simply the project name
-	bin=$BuildDir/$(basename $Package)
-	if [[ $f == *.exe ]]
-	then
-		bin=$bin.exe
-	fi
-	mv $f $bin
-
-	# Compress distributable
-	zip -j $zipname $bin $DistDir/CHANGES.txt $DistDir/LICENSES.txt $DistDir/README.txt
-
-	# Put binary filename back to original
-	mv $bin $f
-done

main.go

@@ -1,175 +0,0 @@
-package main
-
-import (
-	"bytes"
-	"flag"
-	"fmt"
-	"io/ioutil"
-	"log"
-	"os"
-	"os/exec"
-	"path"
-	"runtime"
-	"strconv"
-	"strings"
-
-	"github.com/mholt/caddy/app"
-	"github.com/mholt/caddy/config"
-	"github.com/mholt/caddy/server"
-)
-
-var (
-	conf    string
-	cpu     string
-	version bool
-)
-
-func init() {
-	flag.StringVar(&conf, "conf", "", "Configuration file to use (default="+config.DefaultConfigFile+")")
-	flag.BoolVar(&app.Http2, "http2", true, "Enable HTTP/2 support") // TODO: temporary flag until http2 merged into std lib
-	flag.BoolVar(&app.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.BoolVar(&version, "version", false, "Show version")
-}
-
-func main() {
-	flag.Parse()
-
-	if version {
-		fmt.Printf("%s %s\n", app.Name, app.Version)
-		os.Exit(0)
-	}
-
-	// Set CPU cap
-	err := app.SetCPU(cpu)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// Load config from file
-	allConfigs, err := loadConfigs()
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// Group by address (virtual hosts)
-	addresses, err := config.ArrangeBindings(allConfigs)
-	if err != nil {
-		log.Fatal(err)
-	}
-
-	// Start each server with its one or more configurations
-	for addr, configs := range addresses {
-		s, err := server.New(addr.String(), configs, configs[0].TLS.Enabled)
-		if err != nil {
-			log.Fatal(err)
-		}
-		s.HTTP2 = app.Http2 // TODO: This setting is temporary
-		app.Wg.Add(1)
-		go func(s *server.Server) {
-			defer app.Wg.Done()
-			err := s.Serve()
-			if err != nil {
-				log.Fatal(err) // kill whole process to avoid a half-alive zombie server
-			}
-		}(s)
-
-		app.Servers = append(app.Servers, s)
-	}
-
-	// Show initialization output
-	if !app.Quiet {
-		var checkedFdLimit bool
-		for addr, configs := range addresses {
-			for _, conf := range configs {
-				// Print address of site
-				fmt.Println(conf.Address())
-
-				// Note if non-localhost site resolves to loopback interface
-				if addr.IP.IsLoopback() && !isLocalhost(conf.Host) {
-					fmt.Printf("Notice: %s is only accessible on this machine (%s)\n",
-						conf.Host, addr.IP.String())
-				}
-			}
-
-			if !checkedFdLimit && !addr.IP.IsLoopback() {
-				checkFdlimit()
-				checkedFdLimit = true
-			}
-		}
-	}
-
-	// Wait for all listeners to stop
-	app.Wg.Wait()
-}
-
-// checkFdlimit issues a warning if the OS max file descriptors is below a recommended minimum.
-func checkFdlimit() {
-	const min = 4096
-
-	// Warn if ulimit is too low for production sites
-	if runtime.GOOS == "linux" || runtime.GOOS == "darwin" {
-		out, err := exec.Command("sh", "-c", "ulimit -n").Output() // use sh because ulimit isn't in Linux $PATH
-		if err == nil {
-			// Note that an error here need not be reported
-			lim, err := strconv.Atoi(string(bytes.TrimSpace(out)))
-			if err == nil && lim < min {
-				fmt.Printf("Warning: File descriptor limit %d is too low for production sites.\nAt least %d is recommended. Set with \"ulimit -n %d\".\n", lim, min, min)
-			}
-		}
-	}
-}
-
-// isLocalhost returns true if the string looks explicitly like a localhost address.
-func isLocalhost(s string) bool {
-	return s == "localhost" || s == "::1" || strings.HasPrefix(s, "127.")
-}
-
-// loadConfigs loads configuration from a file or stdin (piped).
-// Configuration is obtained from one of three sources, tried
-// in this order: 1. -conf flag, 2. stdin, 3. Caddyfile.
-// If none of those are available, a default configuration is
-// loaded.
-func loadConfigs() ([]server.Config, error) {
-	// -conf flag
-	if conf != "" {
-		file, err := os.Open(conf)
-		if err != nil {
-			return []server.Config{}, err
-		}
-		defer file.Close()
-		return config.Load(path.Base(conf), file)
-	}
-
-	// stdin
-	fi, err := os.Stdin.Stat()
-	if err == nil && fi.Mode()&os.ModeCharDevice == 0 {
-		// Note that a non-nil error is not a problem. Windows
-		// will not create a stdin if there is no pipe, which
-		// produces an error when calling Stat(). But Unix will
-		// make one either way, which is why we also check that
-		// bitmask.
-		confBody, err := ioutil.ReadAll(os.Stdin)
-		if err != nil {
-			log.Fatal(err)
-		}
-		if len(confBody) > 0 {
-			return config.Load("stdin", bytes.NewReader(confBody))
-		}
-	}
-
-	// Caddyfile
-	file, err := os.Open(config.DefaultConfigFile)
-	if err != nil {
-		if os.IsNotExist(err) {
-			return []server.Config{config.Default()}, nil
-		}
-		return []server.Config{}, err
-	}
-	defer file.Close()
-
-	return config.Load(config.DefaultConfigFile, file)
-}

middleware/basicauth/basicauth.go

@@ -1,69 +0,0 @@
-// Package basicauth implements HTTP Basic Authentication.
-package basicauth
-
-import (
-	"crypto/subtle"
-	"net/http"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// 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.
-func (a BasicAuth) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-
-	var hasAuth bool
-	var isAuthenticated bool
-
-	for _, rule := range a.Rules {
-		for _, res := range rule.Resources {
-			if !middleware.Path(r.URL.Path).Matches(res) {
-				continue
-			}
-
-			// Path matches; parse auth header
-			username, password, ok := r.BasicAuth()
-			hasAuth = true
-
-			// Check credentials
-			if !ok ||
-				username != rule.Username ||
-				subtle.ConstantTimeCompare([]byte(password), []byte(rule.Password)) != 1 {
-				continue
-			}
-
-			// Flag set only on successful authentication
-			isAuthenticated = true
-		}
-	}
-
-	if hasAuth {
-		if !isAuthenticated {
-			w.Header().Set("WWW-Authenticate", "Basic")
-			return http.StatusUnauthorized, nil
-		}
-		// "It's an older code, sir, but it checks out. I was about to clear them."
-		return a.Next.ServeHTTP(w, r)
-	}
-
-	// Pass-thru when no paths match
-	return a.Next.ServeHTTP(w, r)
-}
-
-// Rule represents a BasicAuth rule. A username and password
-// combination protect the associated resources, which are
-// file or directory paths.
-type Rule struct {
-	Username  string
-	Password  string
-	Resources []string
-}

middleware/basicauth/basicauth_test.go

@@ -1,113 +0,0 @@
-package basicauth
-
-import (
-	"encoding/base64"
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-func TestBasicAuth(t *testing.T) {
-
-	rw := BasicAuth{
-		Next: middleware.HandlerFunc(contentHandler),
-		Rules: []Rule{
-			{Username: "test", Password: "ttest", Resources: []string{"/testing"}},
-		},
-	}
-
-	tests := []struct {
-		from   string
-		result int
-		cred   string
-	}{
-		{"/testing", http.StatusUnauthorized, "ttest:test"},
-		{"/testing", http.StatusOK, "test:ttest"},
-		{"/testing", http.StatusUnauthorized, ""},
-	}
-
-	for i, test := range tests {
-
-		req, err := http.NewRequest("GET", test.from, nil)
-		if err != nil {
-			t.Fatalf("Test %d: Could not create HTTP request %v", i, err)
-		}
-		auth := "Basic " + base64.StdEncoding.EncodeToString([]byte(test.cred))
-		req.Header.Set("Authorization", auth)
-
-		rec := httptest.NewRecorder()
-		result, err := rw.ServeHTTP(rec, req)
-		if err != nil {
-			t.Fatalf("Test %d: Could not ServeHTTP %v", i, err)
-		}
-		if result != test.result {
-			t.Errorf("Test %d: Expected Header '%d' but was '%d'",
-				i, test.result, result)
-		}
-		if result == http.StatusUnauthorized {
-			headers := rec.Header()
-			if val, ok := headers["Www-Authenticate"]; ok {
-				if val[0] != "Basic" {
-					t.Errorf("Test %d, Www-Authenticate should be %s provided %s", i, "Basic", val[0])
-				}
-			} else {
-				t.Errorf("Test %d, should provide a header Www-Authenticate", i)
-			}
-		}
-
-	}
-
-}
-
-func TestMultipleOverlappingRules(t *testing.T) {
-	rw := BasicAuth{
-		Next: middleware.HandlerFunc(contentHandler),
-		Rules: []Rule{
-			{Username: "t", Password: "p1", Resources: []string{"/t"}},
-			{Username: "t1", Password: "p2", Resources: []string{"/t/t"}},
-		},
-	}
-
-	tests := []struct {
-		from   string
-		result int
-		cred   string
-	}{
-		{"/t", http.StatusOK, "t:p1"},
-		{"/t/t", http.StatusOK, "t:p1"},
-		{"/t/t", http.StatusOK, "t1:p2"},
-		{"/a", http.StatusOK, "t1:p2"},
-		{"/t/t", http.StatusUnauthorized, "t1:p3"},
-		{"/t", http.StatusUnauthorized, "t1:p2"},
-	}
-
-	for i, test := range tests {
-
-		req, err := http.NewRequest("GET", test.from, nil)
-		if err != nil {
-			t.Fatalf("Test %d: Could not create HTTP request %v", i, err)
-		}
-		auth := "Basic " + base64.StdEncoding.EncodeToString([]byte(test.cred))
-		req.Header.Set("Authorization", auth)
-
-		rec := httptest.NewRecorder()
-		result, err := rw.ServeHTTP(rec, req)
-		if err != nil {
-			t.Fatalf("Test %d: Could not ServeHTTP %v", i, err)
-		}
-		if result != test.result {
-			t.Errorf("Test %d: Expected Header '%d' but was '%d'",
-				i, test.result, result)
-		}
-
-	}
-
-}
-
-func contentHandler(w http.ResponseWriter, r *http.Request) (int, error) {
-	fmt.Fprintf(w, r.URL.String())
-	return http.StatusOK, nil
-}

middleware/browse/browse.go

@@ -1,256 +0,0 @@
-// Package browse provides middleware for listing files in a directory
-// when directory path is requested instead of a specific file.
-package browse
-
-import (
-	"bytes"
-	"errors"
-	"html/template"
-	"net/http"
-	"net/url"
-	"os"
-	"path"
-	"sort"
-	"strings"
-	"time"
-
-	"github.com/dustin/go-humanize"
-	"github.com/mholt/caddy/middleware"
-)
-
-// Browse is an http.Handler that can show a file listing when
-// directories in the given paths are specified.
-type Browse struct {
-	Next    middleware.Handler
-	Root    string
-	Configs []Config
-}
-
-// Config is a configuration for browsing in a particular path.
-type Config struct {
-	PathScope string
-	Template  *template.Template
-}
-
-// A Listing is used to fill out a template.
-type Listing struct {
-	// The name of the directory (the last element of the path)
-	Name string
-
-	// The full path of the request
-	Path string
-
-	// Whether the parent directory is browsable
-	CanGoUp bool
-
-	// The items (files and folders) in the path
-	Items []FileInfo
-
-	// Which sorting order is used
-	Sort string
-
-	// And which order
-	Order string
-}
-
-// FileInfo is the info about a particular file or directory
-type FileInfo struct {
-	IsDir   bool
-	Name    string
-	Size    int64
-	URL     string
-	ModTime time.Time
-	Mode    os.FileMode
-}
-
-// Implement sorting for Listing
-type byName Listing
-type bySize Listing
-type byTime Listing
-
-// By Name
-func (l byName) Len() int      { return len(l.Items) }
-func (l byName) Swap(i, j int) { l.Items[i], l.Items[j] = l.Items[j], l.Items[i] }
-
-// Treat upper and lower case equally
-func (l byName) Less(i, j int) bool {
-	return strings.ToLower(l.Items[i].Name) < strings.ToLower(l.Items[j].Name)
-}
-
-// By Size
-func (l bySize) Len() int           { return len(l.Items) }
-func (l bySize) Swap(i, j int)      { l.Items[i], l.Items[j] = l.Items[j], l.Items[i] }
-func (l bySize) Less(i, j int) bool { return l.Items[i].Size < l.Items[j].Size }
-
-// By Time
-func (l byTime) Len() int           { return len(l.Items) }
-func (l byTime) Swap(i, j int)      { l.Items[i], l.Items[j] = l.Items[j], l.Items[i] }
-func (l byTime) Less(i, j int) bool { return l.Items[i].ModTime.Unix() < l.Items[j].ModTime.Unix() }
-
-// Add sorting method to "Listing"
-// it will apply what's in ".Sort" and ".Order"
-func (l Listing) applySort() {
-	// Check '.Order' to know how to sort
-	if l.Order == "desc" {
-		switch l.Sort {
-		case "name":
-			sort.Sort(sort.Reverse(byName(l)))
-		case "size":
-			sort.Sort(sort.Reverse(bySize(l)))
-		case "time":
-			sort.Sort(sort.Reverse(byTime(l)))
-		default:
-			// If not one of the above, do nothing
-			return
-		}
-	} else { // If we had more Orderings we could add them here
-		switch l.Sort {
-		case "name":
-			sort.Sort(byName(l))
-		case "size":
-			sort.Sort(bySize(l))
-		case "time":
-			sort.Sort(byTime(l))
-		default:
-			// If not one of the above, do nothing
-			return
-		}
-	}
-}
-
-// HumanSize returns the size of the file as a human-readable string.
-func (fi FileInfo) HumanSize() string {
-	return humanize.Bytes(uint64(fi.Size))
-}
-
-// HumanModTime returns the modified time of the file as a human-readable string.
-func (fi FileInfo) HumanModTime(format string) string {
-	return fi.ModTime.Format(format)
-}
-
-var IndexPages = []string{
-	"index.html",
-	"index.htm",
-	"default.html",
-	"default.htm",
-}
-
-func directoryListing(files []os.FileInfo, urlPath string, canGoUp bool) (Listing, error) {
-	var fileinfos []FileInfo
-	for _, f := range files {
-		name := f.Name()
-
-		// Directory is not browsable if it contains index file
-		for _, indexName := range IndexPages {
-			if name == indexName {
-				return Listing{}, errors.New("Directory contains index file, not browsable!")
-			}
-		}
-
-		if f.IsDir() {
-			name += "/"
-		}
-
-		url := url.URL{Path: name}
-
-		fileinfos = append(fileinfos, FileInfo{
-			IsDir:   f.IsDir(),
-			Name:    f.Name(),
-			Size:    f.Size(),
-			URL:     url.String(),
-			ModTime: f.ModTime(),
-			Mode:    f.Mode(),
-		})
-	}
-
-	return Listing{
-		Name:    path.Base(urlPath),
-		Path:    urlPath,
-		CanGoUp: canGoUp,
-		Items:   fileinfos,
-	}, nil
-}
-
-// ServeHTTP implements the middleware.Handler interface.
-func (b Browse) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	filename := b.Root + r.URL.Path
-
-	info, err := os.Stat(filename)
-	if err != nil {
-		return b.Next.ServeHTTP(w, r)
-	}
-
-	if !info.IsDir() {
-		return b.Next.ServeHTTP(w, r)
-	}
-
-	// See if there's a browse configuration to match the path
-	for _, bc := range b.Configs {
-		if !middleware.Path(r.URL.Path).Matches(bc.PathScope) {
-			continue
-		}
-
-		// Browsing navigation gets messed up if browsing a directory
-		// that doesn't end in "/" (which it should, anyway)
-		if r.URL.Path[len(r.URL.Path)-1] != '/' {
-			http.Redirect(w, r, r.URL.Path+"/", http.StatusTemporaryRedirect)
-			return 0, nil
-		}
-
-		// Load directory contents
-		file, err := os.Open(b.Root + r.URL.Path)
-		if err != nil {
-			if os.IsPermission(err) {
-				return http.StatusForbidden, err
-			}
-			return http.StatusNotFound, err
-		}
-		defer file.Close()
-
-		files, err := file.Readdir(-1)
-		if err != nil {
-			return http.StatusForbidden, err
-		}
-
-		// Determine if user can browse up another folder
-		var canGoUp bool
-		curPath := strings.TrimSuffix(r.URL.Path, "/")
-		for _, other := range b.Configs {
-			if strings.HasPrefix(path.Dir(curPath), other.PathScope) {
-				canGoUp = true
-				break
-			}
-		}
-		// Assemble listing of directory contents
-		listing, err := directoryListing(files, r.URL.Path, canGoUp)
-		if err != nil { // directory isn't browsable
-			continue
-		}
-
-		// Get the query vales and store them in the Listing struct
-		listing.Sort, listing.Order = r.URL.Query().Get("sort"), r.URL.Query().Get("order")
-
-		// If the query 'sort' is empty, default to "name" and "asc"
-		if listing.Sort == "" {
-			listing.Sort = "name"
-			listing.Order = "asc"
-		}
-
-		// Apply the sorting
-		listing.applySort()
-
-		var buf bytes.Buffer
-		err = bc.Template.Execute(&buf, listing)
-		if err != nil {
-			return http.StatusInternalServerError, err
-		}
-
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		buf.WriteTo(w)
-
-		return http.StatusOK, nil
-	}
-
-	// Didn't qualify; pass-thru
-	return b.Next.ServeHTTP(w, r)
-}

middleware/browse/browse_test.go

@@ -1,96 +0,0 @@
-package browse
-
-import (
-	"sort"
-	"testing"
-	"time"
-)
-
-// "sort" package has "IsSorted" function, but no "IsReversed";
-func isReversed(data sort.Interface) bool {
-	n := data.Len()
-	for i := n - 1; i > 0; i-- {
-		if !data.Less(i, i-1) {
-			return false
-		}
-	}
-	return true
-}
-
-func TestSort(t *testing.T) {
-	// making up []fileInfo with bogus values;
-	// to be used to make up our "listing"
-	fileInfos := []FileInfo{
-		{
-			Name:    "fizz",
-			Size:    4,
-			ModTime: time.Now().AddDate(-1, 1, 0),
-		},
-		{
-			Name:    "buzz",
-			Size:    2,
-			ModTime: time.Now().AddDate(0, -3, 3),
-		},
-		{
-			Name:    "bazz",
-			Size:    1,
-			ModTime: time.Now().AddDate(0, -2, -23),
-		},
-		{
-			Name:    "jazz",
-			Size:    3,
-			ModTime: time.Now(),
-		},
-	}
-	listing := Listing{
-		Name:    "foobar",
-		Path:    "/fizz/buzz",
-		CanGoUp: false,
-		Items:   fileInfos,
-	}
-
-	// sort by name
-	listing.Sort = "name"
-	listing.applySort()
-	if !sort.IsSorted(byName(listing)) {
-		t.Errorf("The listing isn't name sorted: %v", listing.Items)
-	}
-
-	// sort by size
-	listing.Sort = "size"
-	listing.applySort()
-	if !sort.IsSorted(bySize(listing)) {
-		t.Errorf("The listing isn't size sorted: %v", listing.Items)
-	}
-
-	// sort by Time
-	listing.Sort = "time"
-	listing.applySort()
-	if !sort.IsSorted(byTime(listing)) {
-		t.Errorf("The listing isn't time sorted: %v", listing.Items)
-	}
-
-	// reverse by name
-	listing.Sort = "name"
-	listing.Order = "desc"
-	listing.applySort()
-	if !isReversed(byName(listing)) {
-		t.Errorf("The listing isn't reversed by name: %v", listing.Items)
-	}
-
-	// reverse by size
-	listing.Sort = "size"
-	listing.Order = "desc"
-	listing.applySort()
-	if !isReversed(bySize(listing)) {
-		t.Errorf("The listing isn't reversed by size: %v", listing.Items)
-	}
-
-	// reverse by time
-	listing.Sort = "time"
-	listing.Order = "desc"
-	listing.applySort()
-	if !isReversed(byTime(listing)) {
-		t.Errorf("The listing isn't reversed by time: %v", listing.Items)
-	}
-}

middleware/commands.go

@@ -1,27 +0,0 @@
-package middleware
-
-import (
-	"errors"
-
-	"github.com/flynn/go-shlex"
-)
-
-// SplitCommandAndArgs takes a command string and parses it
-// shell-style into the command and its separate arguments.
-func SplitCommandAndArgs(command string) (cmd string, args []string, err error) {
-	parts, err := shlex.Split(command)
-	if err != nil {
-		err = errors.New("error parsing command: " + err.Error())
-		return
-	} else if len(parts) == 0 {
-		err = errors.New("no command contained in '" + command + "'")
-		return
-	}
-
-	cmd = parts[0]
-	if len(parts) > 1 {
-		args = parts[1:]
-	}
-
-	return
-}

middleware/errors/errors.go

@@ -1,114 +0,0 @@
-// Package errors implements an HTTP error handling middleware.
-package errors
-
-import (
-	"fmt"
-	"io"
-	"log"
-	"net/http"
-	"os"
-	"runtime"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// ErrorHandler handles HTTP errors (or errors from other middleware).
-type ErrorHandler struct {
-	Next       middleware.Handler
-	ErrorPages map[int]string // map of status code to filename
-	LogFile    string
-	Log        *log.Logger
-}
-
-func (h ErrorHandler) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	defer h.recovery(w, r)
-
-	status, err := h.Next.ServeHTTP(w, r)
-
-	if err != nil {
-		h.Log.Printf("[ERROR %d %s] %v", status, r.URL.Path, err)
-	}
-
-	if status >= 400 {
-		h.errorPage(w, status)
-		return 0, err // status < 400 signals that a response has been written
-	}
-
-	return status, err
-}
-
-// errorPage serves a static error page to w according to the status
-// code. If there is an error serving the error page, a plaintext error
-// message is written instead, and the extra error is logged.
-func (h ErrorHandler) errorPage(w http.ResponseWriter, code int) {
-	defaultBody := fmt.Sprintf("%d %s", code, http.StatusText(code))
-
-	// See if an error page for this status code was specified
-	if pagePath, ok := h.ErrorPages[code]; ok {
-
-		// Try to open it
-		errorPage, err := os.Open(pagePath)
-		if err != nil {
-			// An error handling an error... <insert grumpy cat here>
-			h.Log.Printf("HTTP %d could not load error page %s: %v", code, pagePath, err)
-			http.Error(w, defaultBody, code)
-			return
-		}
-		defer errorPage.Close()
-
-		// Copy the page body into the response
-		w.Header().Set("Content-Type", "text/html; charset=utf-8")
-		w.WriteHeader(code)
-		_, err = io.Copy(w, errorPage)
-
-		if err != nil {
-			// Epic fail... sigh.
-			h.Log.Printf("HTTP %d could not respond with %s: %v", code, pagePath, err)
-			http.Error(w, defaultBody, code)
-		}
-
-		return
-	}
-
-	// Default error response
-	http.Error(w, defaultBody, code)
-}
-
-func (h ErrorHandler) recovery(w http.ResponseWriter, r *http.Request) {
-	rec := recover()
-	if rec == nil {
-		return
-	}
-
-	// Obtain source of panic
-	// From: https://gist.github.com/swdunlop/9629168
-	var name, file string // function name, file name
-	var line int
-	var pc [16]uintptr
-	n := runtime.Callers(3, pc[:])
-	for _, pc := range pc[:n] {
-		fn := runtime.FuncForPC(pc)
-		if fn == nil {
-			continue
-		}
-		file, line = fn.FileLine(pc)
-		name = fn.Name()
-		if !strings.HasPrefix(name, "runtime.") {
-			break
-		}
-	}
-
-	// Trim file path
-	delim := "/caddy/"
-	pkgPathPos := strings.Index(file, delim)
-	if pkgPathPos > -1 && len(file) > pkgPathPos+len(delim) {
-		file = file[pkgPathPos+len(delim):]
-	}
-
-	// Currently we don't use the function name, as file:line is more conventional
-	h.Log.Printf("[PANIC %s] %s:%d - %v", r.URL.String(), file, line, rec)
-	h.errorPage(w, http.StatusInternalServerError)
-}
-
-const DefaultLogFilename = "error.log"

middleware/errors/errors_test.go

@@ -1,124 +0,0 @@
-package errors
-
-import (
-	"bytes"
-	"errors"
-	"fmt"
-	"log"
-	"net/http"
-	"net/http/httptest"
-	"os"
-	"path/filepath"
-	"testing"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-func TestErrors(t *testing.T) {
-	// create a temporary page
-	path := filepath.Join(os.TempDir(), "errors_test.html")
-	f, err := os.Create(path)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer os.Remove(path)
-
-	const content = "This is a error page"
-	_, err = f.WriteString(content)
-	if err != nil {
-		t.Fatal(err)
-	}
-	f.Close()
-
-	buf := bytes.Buffer{}
-	em := ErrorHandler{
-		ErrorPages: make(map[int]string),
-		Log:        log.New(&buf, "", 0),
-	}
-	em.ErrorPages[http.StatusNotFound] = path
-	em.ErrorPages[http.StatusForbidden] = "not_exist_file"
-	_, notExistErr := os.Open("not_exist_file")
-
-	testErr := errors.New("test error")
-	tests := []struct {
-		next         middleware.Handler
-		expectedCode int
-		expectedBody string
-		expectedLog  string
-		expectedErr  error
-	}{
-		{
-			next:         genErrorHandler(http.StatusOK, nil, "normal"),
-			expectedCode: http.StatusOK,
-			expectedBody: "normal",
-			expectedLog:  "",
-			expectedErr:  nil,
-		},
-		{
-			next:         genErrorHandler(http.StatusMovedPermanently, testErr, ""),
-			expectedCode: http.StatusMovedPermanently,
-			expectedBody: "",
-			expectedLog:  fmt.Sprintf("[ERROR %d %s] %v\n", http.StatusMovedPermanently, "/", testErr),
-			expectedErr:  testErr,
-		},
-		{
-			next:         genErrorHandler(http.StatusBadRequest, nil, ""),
-			expectedCode: 0,
-			expectedBody: fmt.Sprintf("%d %s\n", http.StatusBadRequest,
-				http.StatusText(http.StatusBadRequest)),
-			expectedLog: "",
-			expectedErr: nil,
-		},
-		{
-			next:         genErrorHandler(http.StatusNotFound, nil, ""),
-			expectedCode: 0,
-			expectedBody: content,
-			expectedLog:  "",
-			expectedErr:  nil,
-		},
-		{
-			next:         genErrorHandler(http.StatusForbidden, nil, ""),
-			expectedCode: 0,
-			expectedBody: fmt.Sprintf("%d %s\n", http.StatusForbidden,
-				http.StatusText(http.StatusForbidden)),
-			expectedLog: fmt.Sprintf("HTTP %d could not load error page %s: %v\n",
-				http.StatusForbidden, "not_exist_file", notExistErr),
-			expectedErr: nil,
-		},
-	}
-
-	req, err := http.NewRequest("GET", "/", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-	for i, test := range tests {
-		em.Next = test.next
-		buf.Reset()
-		rec := httptest.NewRecorder()
-		code, err := em.ServeHTTP(rec, req)
-
-		if err != test.expectedErr {
-			t.Errorf("Test %d: Expected error %v, but got %v",
-				i, test.expectedErr, err)
-		}
-		if code != test.expectedCode {
-			t.Errorf("Test %d: Expected status code %d, but got %d",
-				i, test.expectedCode, code)
-		}
-		if body := rec.Body.String(); body != test.expectedBody {
-			t.Errorf("Test %d: Expected body %q, but got %q",
-				i, test.expectedBody, body)
-		}
-		if log := buf.String(); log != test.expectedLog {
-			t.Errorf("Test %d: Expected log %q, but got %q",
-				i, test.expectedLog, log)
-		}
-	}
-}
-
-func genErrorHandler(status int, err error, body string) middleware.Handler {
-	return middleware.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-		fmt.Fprint(w, body)
-		return status, err
-	})
-}

middleware/extensions/ext.go

@@ -1,52 +0,0 @@
-// Package extensions contains middleware for clean URLs.
-//
-// The root path of the site is passed in as well as possible extensions
-// to try internally for paths requested that don't match an existing
-// resource. The first path+ext combination that matches a valid file
-// will be used.
-package extensions
-
-import (
-	"net/http"
-	"os"
-	"path"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// Ext can assume an extension from clean URLs.
-// It tries extensions in the order listed in Extensions.
-type Ext struct {
-	// Next handler in the chain
-	Next middleware.Handler
-
-	// Path to ther root of the site
-	Root string
-
-	// List of extensions to try
-	Extensions []string
-}
-
-// ServeHTTP implements the middleware.Handler interface.
-func (e Ext) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	urlpath := strings.TrimSuffix(r.URL.Path, "/")
-	if path.Ext(urlpath) == "" && r.URL.Path[len(r.URL.Path)-1] != '/' {
-		for _, ext := range e.Extensions {
-			if resourceExists(e.Root, urlpath+ext) {
-				r.URL.Path = urlpath + ext
-				break
-			}
-		}
-	}
-	return e.Next.ServeHTTP(w, r)
-}
-
-// resourceExists returns true if the file specified at
-// root + path exists; false otherwise.
-func resourceExists(root, path string) bool {
-	_, err := os.Stat(root + path)
-	// technically we should use os.IsNotExist(err)
-	// but we don't handle any other kinds of errors anyway
-	return err == nil
-}

middleware/fastcgi/fastcgi.go

@@ -1,247 +0,0 @@
-// Package fastcgi has middleware that acts as a FastCGI client. Requests
-// that get forwarded to FastCGI stop the middleware execution chain.
-// The most common use for this package is to serve PHP websites via php-fpm.
-package fastcgi
-
-import (
-	"io"
-	"net/http"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// Handler is a middleware type that can handle requests as a FastCGI client.
-type Handler struct {
-	Next    middleware.Handler
-	Rules   []Rule
-	Root    string
-	AbsRoot string // same as root, but absolute path
-	FileSys http.FileSystem
-
-	// These are sent to CGI scripts in env variables
-	SoftwareName    string
-	SoftwareVersion string
-	ServerName      string
-	ServerPort      string
-}
-
-// ServeHTTP satisfies the middleware.Handler interface.
-func (h Handler) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	for _, rule := range h.Rules {
-
-		// First requirement: Base path must match
-		if !middleware.Path(r.URL.Path).Matches(rule.Path) {
-			continue
-		}
-
-		// In addition to matching the path, a request must meet some
-		// other criteria before being proxied as FastCGI. For example,
-		// we probably want to exclude static assets (CSS, JS, images...)
-		// but we also want to be flexible for the script we proxy to.
-
-		fpath := r.URL.Path
-		if idx, ok := middleware.IndexFile(h.FileSys, fpath, rule.IndexFiles); ok {
-			fpath = idx
-		}
-
-		// These criteria work well in this order for PHP sites
-		if fpath[len(fpath)-1] == '/' || strings.HasSuffix(fpath, rule.Ext) || !h.exists(fpath) {
-
-			// Create environment for CGI script
-			env, err := h.buildEnv(r, rule, fpath)
-			if err != nil {
-				return http.StatusInternalServerError, err
-			}
-
-			// Connect to FastCGI gateway
-			var fcgi *FCGIClient
-
-			// check if unix socket or tcp
-			if strings.HasPrefix(rule.Address, "/") || strings.HasPrefix(rule.Address, "unix:") {
-				if strings.HasPrefix(rule.Address, "unix:") {
-					rule.Address = rule.Address[len("unix:"):]
-				}
-				fcgi, err = Dial("unix", rule.Address)
-			} else {
-				fcgi, err = Dial("tcp", rule.Address)
-			}
-			if err != nil {
-				return http.StatusBadGateway, err
-			}
-
-			var resp *http.Response
-			contentLength, _ := strconv.Atoi(r.Header.Get("Content-Length"))
-			switch r.Method {
-			case "HEAD":
-				resp, err = fcgi.Head(env)
-			case "GET":
-				resp, err = fcgi.Get(env)
-			case "OPTIONS":
-				resp, err = fcgi.Options(env)
-			case "POST":
-				resp, err = fcgi.Post(env, r.Header.Get("Content-Type"), r.Body, contentLength)
-			case "PUT":
-				resp, err = fcgi.Put(env, r.Header.Get("Content-Type"), r.Body, contentLength)
-			case "PATCH":
-				resp, err = fcgi.Patch(env, r.Header.Get("Content-Type"), r.Body, contentLength)
-			case "DELETE":
-				resp, err = fcgi.Delete(env, r.Header.Get("Content-Type"), r.Body, contentLength)
-			default:
-				return http.StatusMethodNotAllowed, nil
-			}
-
-			if resp.Body != nil {
-				defer resp.Body.Close()
-			}
-
-			if err != nil && err != io.EOF {
-				return http.StatusBadGateway, err
-			}
-
-			// Write the response header
-			for key, vals := range resp.Header {
-				for _, val := range vals {
-					w.Header().Add(key, val)
-				}
-			}
-			w.WriteHeader(resp.StatusCode)
-
-			// Write the response body
-			// TODO: If this has an error, the response will already be
-			// partly written. We should copy out of resp.Body into a buffer
-			// first, then write it to the response...
-			_, err = io.Copy(w, resp.Body)
-			if err != nil {
-				return http.StatusBadGateway, err
-			}
-
-			return 0, nil
-		}
-	}
-
-	return h.Next.ServeHTTP(w, r)
-}
-
-func (h Handler) exists(path string) bool {
-	if _, err := os.Stat(h.Root + path); err == nil {
-		return true
-	}
-	return false
-}
-
-// buildEnv returns a set of CGI environment variables for the request.
-func (h Handler) buildEnv(r *http.Request, rule Rule, fpath string) (map[string]string, error) {
-	var env map[string]string
-
-	// Get absolute path of requested resource
-	absPath := filepath.Join(h.AbsRoot, fpath)
-
-	// Separate remote IP and port; more lenient than net.SplitHostPort
-	var ip, port string
-	if idx := strings.Index(r.RemoteAddr, ":"); idx > -1 {
-		ip = r.RemoteAddr[:idx]
-		port = r.RemoteAddr[idx+1:]
-	} else {
-		ip = r.RemoteAddr
-	}
-
-	// Split path in preparation for env variables
-	splitPos := strings.Index(fpath, rule.SplitPath)
-	var docURI, scriptName, scriptFilename, pathInfo string
-	if splitPos == -1 {
-		// Request doesn't have the extension, so assume index file in root
-		docURI = "/" + rule.IndexFiles[0]
-		scriptName = "/" + rule.IndexFiles[0]
-		scriptFilename = filepath.Join(h.AbsRoot, rule.IndexFiles[0])
-		pathInfo = fpath
-	} else {
-		// Request has the extension; path was split successfully
-		docURI = fpath[:splitPos+len(rule.SplitPath)]
-		pathInfo = fpath[splitPos+len(rule.SplitPath):]
-		scriptName = fpath
-		scriptFilename = absPath
-	}
-
-	// Some variables are unused but cleared explicitly to prevent
-	// the parent environment from interfering.
-	env = map[string]string{
-
-		// Variables defined in CGI 1.1 spec
-		"AUTH_TYPE":         "", // Not used
-		"CONTENT_LENGTH":    r.Header.Get("Content-Length"),
-		"CONTENT_TYPE":      r.Header.Get("Content-Type"),
-		"GATEWAY_INTERFACE": "CGI/1.1",
-		"PATH_INFO":         pathInfo,
-		"QUERY_STRING":      r.URL.RawQuery,
-		"REMOTE_ADDR":       ip,
-		"REMOTE_HOST":       ip, // For speed, remote host lookups disabled
-		"REMOTE_PORT":       port,
-		"REMOTE_IDENT":      "", // Not used
-		"REMOTE_USER":       "", // Not used
-		"REQUEST_METHOD":    r.Method,
-		"SERVER_NAME":       h.ServerName,
-		"SERVER_PORT":       h.ServerPort,
-		"SERVER_PROTOCOL":   r.Proto,
-		"SERVER_SOFTWARE":   h.SoftwareName + "/" + h.SoftwareVersion,
-
-		// Other variables
-		"DOCUMENT_ROOT":   h.AbsRoot,
-		"DOCUMENT_URI":    docURI,
-		"HTTP_HOST":       r.Host, // added here, since not always part of headers
-		"REQUEST_URI":     r.URL.RequestURI(),
-		"SCRIPT_FILENAME": scriptFilename,
-		"SCRIPT_NAME":     scriptName,
-	}
-
-	// compliance with the CGI specification that PATH_TRANSLATED
-	// should only exist if PATH_INFO is defined.
-	// Info: https://www.ietf.org/rfc/rfc3875 Page 14
-	if env["PATH_INFO"] != "" {
-		env["PATH_TRANSLATED"] = filepath.Join(h.AbsRoot, pathInfo) // Info: http://www.oreilly.com/openbook/cgi/ch02_04.html
-	}
-
-	// Add env variables from config
-	for _, envVar := range rule.EnvVars {
-		env[envVar[0]] = envVar[1]
-	}
-
-	// Add all HTTP headers to env variables
-	for field, val := range r.Header {
-		header := strings.ToUpper(field)
-		header = headerNameReplacer.Replace(header)
-		env["HTTP_"+header] = strings.Join(val, ", ")
-	}
-
-	return env, nil
-}
-
-// Rule represents a FastCGI handling rule.
-type Rule struct {
-	// The base path to match. Required.
-	Path string
-
-	// The address of the FastCGI server. Required.
-	Address string
-
-	// Always process files with this extension with fastcgi.
-	Ext string
-
-	// The path in the URL will be split into two, with the first piece ending
-	// with the value of SplitPath. The first piece will be assumed as the
-	// actual resource (CGI script) name, and the second piece will be set to
-	// PATH_INFO for the CGI script to use.
-	SplitPath string
-
-	// If the URL ends with '/' (which indicates a directory), these index
-	// files will be tried instead.
-	IndexFiles []string
-
-	// Environment Variables
-	EnvVars [][2]string
-}
-
-var headerNameReplacer = strings.NewReplacer(" ", "_", "-", "_")

middleware/fastcgi/fcgi_test.php

@@ -1,79 +0,0 @@
-<?php
-
-ini_set("display_errors",1);
-
-echo "resp: start\n";//.print_r($GLOBALS,1)."\n".print_r($_SERVER,1)."\n";
-
-//echo print_r($_SERVER,1)."\n";
-
-$length = 0;
-$stat = "PASSED";
-
-$ret = "[";
-
-if (count($_POST) || count($_FILES)) {
-	foreach($_POST as $key => $val) {
-		$md5 = md5($val);
-		
-		if ($key != $md5) {
-			$stat = "FAILED";
-			echo "server:err ".$md5." != ".$key."\n";
-		}
-		
-		$length += strlen($key) + strlen($val);
-		
-		$ret .= $key."(".strlen($key).") ";
-	}
-	$ret .= "] [";
-	foreach ($_FILES as $k0 => $val) {
-
-		$error = $val["error"];
-		if ($error == UPLOAD_ERR_OK) {
-			$tmp_name = $val["tmp_name"];
-			$name = $val["name"];
-			$datafile = "/tmp/test.go";
-			move_uploaded_file($tmp_name, $datafile);
-			$md5 = md5_file($datafile);
-
-			if ($k0 != $md5) {
-				$stat = "FAILED";
-				echo "server:err ".$md5." != ".$key."\n";
-			}      
-			
-			$length += strlen($k0) + filesize($datafile);
-			
-			unlink($datafile);
-			$ret .= $k0."(".strlen($k0).") ";
-		}
-		else{
-			$stat = "FAILED";
-			echo "server:file err ".file_upload_error_message($error)."\n";
-		}
-	}
-	$ret .= "]";
-	echo "server:got data length " .$length."\n";
-}
-
-
-echo "-{$stat}-POST(".count($_POST).") FILE(".count($_FILES).")\n";
-
-function file_upload_error_message($error_code) {
-	switch ($error_code) { 
-		case UPLOAD_ERR_INI_SIZE: 
-		return 'The uploaded file exceeds the upload_max_filesize directive in php.ini'; 
-		case UPLOAD_ERR_FORM_SIZE: 
-		return 'The uploaded file exceeds the MAX_FILE_SIZE directive that was specified in the HTML form'; 
-		case UPLOAD_ERR_PARTIAL: 
-		return 'The uploaded file was only partially uploaded'; 
-		case UPLOAD_ERR_NO_FILE: 
-		return 'No file was uploaded'; 
-		case UPLOAD_ERR_NO_TMP_DIR: 
-		return 'Missing a temporary folder'; 
-		case UPLOAD_ERR_CANT_WRITE: 
-		return 'Failed to write file to disk'; 
-		case UPLOAD_ERR_EXTENSION: 
-		return 'File upload stopped by extension'; 
-		default: 
-		return 'Unknown upload error'; 
-	} 
-} 

middleware/fastcgi/fcgiclient.go

@@ -1,518 +0,0 @@
-// Forked Jan. 2015 from http://bitbucket.org/PinIdea/fcgi_client
-// (which is forked from https://code.google.com/p/go-fastcgi-client/)
-
-// This fork contains several fixes and improvements by Matt Holt and
-// other contributors to this project.
-
-// Copyright 2012 Junqing Tan <ivan@mysqlab.net> and The Go Authors
-// Use of this source code is governed by a BSD-style
-// Part of source code is from Go fcgi package
-
-package fastcgi
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/binary"
-	"errors"
-	"io"
-	"io/ioutil"
-	"mime/multipart"
-	"net"
-	"net/http"
-	"net/http/httputil"
-	"net/textproto"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"sync"
-)
-
-const FCGI_LISTENSOCK_FILENO uint8 = 0
-const FCGI_HEADER_LEN uint8 = 8
-const VERSION_1 uint8 = 1
-const FCGI_NULL_REQUEST_ID uint8 = 0
-const FCGI_KEEP_CONN uint8 = 1
-const doubleCRLF = "\r\n\r\n"
-
-const (
-	FCGI_BEGIN_REQUEST uint8 = iota + 1
-	FCGI_ABORT_REQUEST
-	FCGI_END_REQUEST
-	FCGI_PARAMS
-	FCGI_STDIN
-	FCGI_STDOUT
-	FCGI_STDERR
-	FCGI_DATA
-	FCGI_GET_VALUES
-	FCGI_GET_VALUES_RESULT
-	FCGI_UNKNOWN_TYPE
-	FCGI_MAXTYPE = FCGI_UNKNOWN_TYPE
-)
-
-const (
-	FCGI_RESPONDER uint8 = iota + 1
-	FCGI_AUTHORIZER
-	FCGI_FILTER
-)
-
-const (
-	FCGI_REQUEST_COMPLETE uint8 = iota
-	FCGI_CANT_MPX_CONN
-	FCGI_OVERLOADED
-	FCGI_UNKNOWN_ROLE
-)
-
-const (
-	FCGI_MAX_CONNS  string = "MAX_CONNS"
-	FCGI_MAX_REQS   string = "MAX_REQS"
-	FCGI_MPXS_CONNS string = "MPXS_CONNS"
-)
-
-const (
-	maxWrite = 65500 // 65530 may work, but for compatibility
-	maxPad   = 255
-)
-
-type header struct {
-	Version       uint8
-	Type          uint8
-	Id            uint16
-	ContentLength uint16
-	PaddingLength uint8
-	Reserved      uint8
-}
-
-// for padding so we don't have to allocate all the time
-// not synchronized because we don't care what the contents are
-var pad [maxPad]byte
-
-func (h *header) init(recType uint8, reqID uint16, contentLength int) {
-	h.Version = 1
-	h.Type = recType
-	h.Id = reqID
-	h.ContentLength = uint16(contentLength)
-	h.PaddingLength = uint8(-contentLength & 7)
-}
-
-type record struct {
-	h    header
-	rbuf []byte
-}
-
-func (rec *record) read(r io.Reader) (buf []byte, err error) {
-	if err = binary.Read(r, binary.BigEndian, &rec.h); err != nil {
-		return
-	}
-	if rec.h.Version != 1 {
-		err = errors.New("fcgi: invalid header version")
-		return
-	}
-	if rec.h.Type == FCGI_END_REQUEST {
-		err = io.EOF
-		return
-	}
-	n := int(rec.h.ContentLength) + int(rec.h.PaddingLength)
-	if len(rec.rbuf) < n {
-		rec.rbuf = make([]byte, n)
-	}
-	if n, err = io.ReadFull(r, rec.rbuf[:n]); err != nil {
-		return
-	}
-	buf = rec.rbuf[:int(rec.h.ContentLength)]
-
-	return
-}
-
-type FCGIClient struct {
-	mutex     sync.Mutex
-	rwc       io.ReadWriteCloser
-	h         header
-	buf       bytes.Buffer
-	keepAlive bool
-	reqId     uint16
-}
-
-// Dial connects to the fcgi responder at the specified network address.
-// See func net.Dial for a description of the network and address parameters.
-func Dial(network, address string) (fcgi *FCGIClient, err error) {
-	var conn net.Conn
-
-	conn, err = net.Dial(network, address)
-	if err != nil {
-		return
-	}
-
-	fcgi = &FCGIClient{
-		rwc:       conn,
-		keepAlive: false,
-		reqId:     1,
-	}
-
-	return
-}
-
-// Close closes fcgi connnection
-func (c *FCGIClient) Close() {
-	c.rwc.Close()
-}
-
-func (c *FCGIClient) writeRecord(recType uint8, content []byte) (err error) {
-	c.mutex.Lock()
-	defer c.mutex.Unlock()
-	c.buf.Reset()
-	c.h.init(recType, c.reqId, len(content))
-	if err := binary.Write(&c.buf, binary.BigEndian, c.h); err != nil {
-		return err
-	}
-	if _, err := c.buf.Write(content); err != nil {
-		return err
-	}
-	if _, err := c.buf.Write(pad[:c.h.PaddingLength]); err != nil {
-		return err
-	}
-	_, err = c.rwc.Write(c.buf.Bytes())
-	return err
-}
-
-func (c *FCGIClient) writeBeginRequest(role uint16, flags uint8) error {
-	b := [8]byte{byte(role >> 8), byte(role), flags}
-	return c.writeRecord(FCGI_BEGIN_REQUEST, b[:])
-}
-
-func (c *FCGIClient) writeEndRequest(appStatus int, protocolStatus uint8) error {
-	b := make([]byte, 8)
-	binary.BigEndian.PutUint32(b, uint32(appStatus))
-	b[4] = protocolStatus
-	return c.writeRecord(FCGI_END_REQUEST, b)
-}
-
-func (c *FCGIClient) writePairs(recType uint8, pairs map[string]string) error {
-	w := newWriter(c, recType)
-	b := make([]byte, 8)
-	nn := 0
-	for k, v := range pairs {
-		m := 8 + len(k) + len(v)
-		if m > maxWrite {
-			// param data size exceed 65535 bytes"
-			vl := maxWrite - 8 - len(k)
-			v = v[:vl]
-		}
-		n := encodeSize(b, uint32(len(k)))
-		n += encodeSize(b[n:], uint32(len(v)))
-		m = n + len(k) + len(v)
-		if (nn + m) > maxWrite {
-			w.Flush()
-			nn = 0
-		}
-		nn += m
-		if _, err := w.Write(b[:n]); err != nil {
-			return err
-		}
-		if _, err := w.WriteString(k); err != nil {
-			return err
-		}
-		if _, err := w.WriteString(v); err != nil {
-			return err
-		}
-	}
-	w.Close()
-	return nil
-}
-
-func readSize(s []byte) (uint32, int) {
-	if len(s) == 0 {
-		return 0, 0
-	}
-	size, n := uint32(s[0]), 1
-	if size&(1<<7) != 0 {
-		if len(s) < 4 {
-			return 0, 0
-		}
-		n = 4
-		size = binary.BigEndian.Uint32(s)
-		size &^= 1 << 31
-	}
-	return size, n
-}
-
-func readString(s []byte, size uint32) string {
-	if size > uint32(len(s)) {
-		return ""
-	}
-	return string(s[:size])
-}
-
-func encodeSize(b []byte, size uint32) int {
-	if size > 127 {
-		size |= 1 << 31
-		binary.BigEndian.PutUint32(b, size)
-		return 4
-	}
-	b[0] = byte(size)
-	return 1
-}
-
-// bufWriter encapsulates bufio.Writer but also closes the underlying stream when
-// Closed.
-type bufWriter struct {
-	closer io.Closer
-	*bufio.Writer
-}
-
-func (w *bufWriter) Close() error {
-	if err := w.Writer.Flush(); err != nil {
-		w.closer.Close()
-		return err
-	}
-	return w.closer.Close()
-}
-
-func newWriter(c *FCGIClient, recType uint8) *bufWriter {
-	s := &streamWriter{c: c, recType: recType}
-	w := bufio.NewWriterSize(s, maxWrite)
-	return &bufWriter{s, w}
-}
-
-// streamWriter abstracts out the separation of a stream into discrete records.
-// It only writes maxWrite bytes at a time.
-type streamWriter struct {
-	c       *FCGIClient
-	recType uint8
-}
-
-func (w *streamWriter) Write(p []byte) (int, error) {
-	nn := 0
-	for len(p) > 0 {
-		n := len(p)
-		if n > maxWrite {
-			n = maxWrite
-		}
-		if err := w.c.writeRecord(w.recType, p[:n]); err != nil {
-			return nn, err
-		}
-		nn += n
-		p = p[n:]
-	}
-	return nn, nil
-}
-
-func (w *streamWriter) Close() error {
-	// send empty record to close the stream
-	return w.c.writeRecord(w.recType, nil)
-}
-
-type streamReader struct {
-	c   *FCGIClient
-	buf []byte
-}
-
-func (w *streamReader) Read(p []byte) (n int, err error) {
-
-	if len(p) > 0 {
-		if len(w.buf) == 0 {
-			rec := &record{}
-			w.buf, err = rec.read(w.c.rwc)
-			if err != nil {
-				return
-			}
-		}
-
-		n = len(p)
-		if n > len(w.buf) {
-			n = len(w.buf)
-		}
-		copy(p, w.buf[:n])
-		w.buf = w.buf[n:]
-	}
-
-	return
-}
-
-// Do made the request and returns a io.Reader that translates the data read
-// from fcgi responder out of fcgi packet before returning it.
-func (c *FCGIClient) Do(p map[string]string, req io.Reader) (r io.Reader, err error) {
-	err = c.writeBeginRequest(uint16(FCGI_RESPONDER), 0)
-	if err != nil {
-		return
-	}
-
-	err = c.writePairs(FCGI_PARAMS, p)
-	if err != nil {
-		return
-	}
-
-	body := newWriter(c, FCGI_STDIN)
-	if req != nil {
-		io.Copy(body, req)
-	}
-	body.Close()
-
-	r = &streamReader{c: c}
-	return
-}
-
-// Request returns a HTTP Response with Header and Body
-// from fcgi responder
-func (c *FCGIClient) Request(p map[string]string, req io.Reader) (resp *http.Response, err error) {
-
-	r, err := c.Do(p, req)
-	if err != nil {
-		return
-	}
-
-	rb := bufio.NewReader(r)
-	tp := textproto.NewReader(rb)
-	resp = new(http.Response)
-
-	// Parse the response headers.
-	mimeHeader, err := tp.ReadMIMEHeader()
-	if err != nil && err != io.EOF {
-		return
-	}
-	resp.Header = http.Header(mimeHeader)
-
-	if resp.Header.Get("Status") != "" {
-		statusParts := strings.SplitN(resp.Header.Get("Status"), " ", 2)
-		resp.StatusCode, err = strconv.Atoi(statusParts[0])
-		if err != nil {
-			return
-		}
-		if len(statusParts) > 1 {
-			resp.Status = statusParts[1]	
-		}
-		
-	} else {
-		resp.StatusCode = http.StatusOK
-	}
-
-	// TODO: fixTransferEncoding ?
-	resp.TransferEncoding = resp.Header["Transfer-Encoding"]
-	resp.ContentLength, _ = strconv.ParseInt(resp.Header.Get("Content-Length"), 10, 64)
-
-	if chunked(resp.TransferEncoding) {
-		resp.Body = ioutil.NopCloser(httputil.NewChunkedReader(rb))
-	} else {
-		resp.Body = ioutil.NopCloser(rb)
-	}
-	return
-}
-
-// Get issues a GET request to the fcgi responder.
-func (c *FCGIClient) Get(p map[string]string) (resp *http.Response, err error) {
-
-	p["REQUEST_METHOD"] = "GET"
-	p["CONTENT_LENGTH"] = "0"
-
-	return c.Request(p, nil)
-}
-
-// Head issues a HEAD request to the fcgi responder.
-func (c *FCGIClient) Head(p map[string]string) (resp *http.Response, err error) {
-
-	p["REQUEST_METHOD"] = "HEAD"
-	p["CONTENT_LENGTH"] = "0"
-
-	return c.Request(p, nil)
-}
-
-// Options issues an OPTIONS request to the fcgi responder.
-func (c *FCGIClient) Options(p map[string]string) (resp *http.Response, err error) {
-
-	p["REQUEST_METHOD"] = "OPTIONS"
-	p["CONTENT_LENGTH"] = "0"
-
-	return c.Request(p, nil)
-}
-
-// Post issues a POST request to the fcgi responder. with request body
-// in the format that bodyType specified
-func (c *FCGIClient) Post(p map[string]string, bodyType string, body io.Reader, l int) (resp *http.Response, err error) {
-
-	if len(p["REQUEST_METHOD"]) == 0 || p["REQUEST_METHOD"] == "GET" {
-		p["REQUEST_METHOD"] = "POST"
-	}
-	p["CONTENT_LENGTH"] = strconv.Itoa(l)
-	if len(bodyType) > 0 {
-		p["CONTENT_TYPE"] = bodyType
-	} else {
-		p["CONTENT_TYPE"] = "application/x-www-form-urlencoded"
-	}
-
-	return c.Request(p, body)
-}
-
-// Put issues a PUT request to the fcgi responder.
-func (c *FCGIClient) Put(p map[string]string, bodyType string, body io.Reader, l int) (resp *http.Response, err error) {
-
-	p["REQUEST_METHOD"] = "PUT"
-
-	return c.Post(p, bodyType, body, l)
-}
-
-// Patch issues a PATCH request to the fcgi responder.
-func (c *FCGIClient) Patch(p map[string]string, bodyType string, body io.Reader, l int) (resp *http.Response, err error) {
-
-	p["REQUEST_METHOD"] = "PATCH"
-
-	return c.Post(p, bodyType, body, l)
-}
-
-// Delete issues a DELETE request to the fcgi responder.
-func (c *FCGIClient) Delete(p map[string]string, bodyType string, body io.Reader, l int) (resp *http.Response, err error) {
-
-	p["REQUEST_METHOD"] = "DELETE"
-
-	return c.Post(p, bodyType, body, l)
-}
-
-// PostForm issues a POST to the fcgi responder, with form
-// as a string key to a list values (url.Values)
-func (c *FCGIClient) PostForm(p map[string]string, data url.Values) (resp *http.Response, err error) {
-	body := bytes.NewReader([]byte(data.Encode()))
-	return c.Post(p, "application/x-www-form-urlencoded", body, body.Len())
-}
-
-// PostFile issues a POST to the fcgi responder in multipart(RFC 2046) standard,
-// with form as a string key to a list values (url.Values),
-// and/or with file as a string key to a list file path.
-func (c *FCGIClient) PostFile(p map[string]string, data url.Values, file map[string]string) (resp *http.Response, err error) {
-	buf := &bytes.Buffer{}
-	writer := multipart.NewWriter(buf)
-	bodyType := writer.FormDataContentType()
-
-	for key, val := range data {
-		for _, v0 := range val {
-			err = writer.WriteField(key, v0)
-			if err != nil {
-				return
-			}
-		}
-	}
-
-	for key, val := range file {
-		fd, e := os.Open(val)
-		if e != nil {
-			return nil, e
-		}
-		defer fd.Close()
-
-		part, e := writer.CreateFormFile(key, filepath.Base(val))
-		if e != nil {
-			return nil, e
-		}
-		_, err = io.Copy(part, fd)
-	}
-
-	err = writer.Close()
-	if err != nil {
-		return
-	}
-
-	return c.Post(p, bodyType, buf, buf.Len())
-}
-
-// Checks whether chunked is part of the encodings stack
-func chunked(te []string) bool { return len(te) > 0 && te[0] == "chunked" }

middleware/fastcgi/fcgiclient_test.go

@@ -1,282 +0,0 @@
-// NOTE: These tests were adapted from the original
-// repository from which this package was forked.
-// The tests are slow (~10s) and in dire need of rewriting.
-// As such, the tests have been disabled to speed up
-// automated builds until they can be properly written.
-
-package fastcgi
-
-import (
-	"bytes"
-	"crypto/md5"
-	"encoding/binary"
-	"fmt"
-	"io"
-	"io/ioutil"
-	"log"
-	"math/rand"
-	"net"
-	"net/http"
-	"net/http/fcgi"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strconv"
-	"strings"
-	"testing"
-	"time"
-)
-
-// test fcgi protocol includes:
-// Get, Post, Post in multipart/form-data, and Post with files
-// each key should be the md5 of the value or the file uploaded
-// sepicify remote fcgi responer ip:port to test with php
-// test failed if the remote fcgi(script) failed md5 verification
-// and output "FAILED" in response
-const (
-	script_file = "/tank/www/fcgic_test.php"
-	//ip_port = "remote-php-serv:59000"
-	ip_port = "127.0.0.1:59000"
-)
-
-var (
-	t_ *testing.T = nil
-)
-
-type FastCGIServer struct{}
-
-func (s FastCGIServer) ServeHTTP(resp http.ResponseWriter, req *http.Request) {
-
-	req.ParseMultipartForm(100000000)
-
-	stat := "PASSED"
-	fmt.Fprintln(resp, "-")
-	file_num := 0
-	{
-		length := 0
-		for k0, v0 := range req.Form {
-			h := md5.New()
-			io.WriteString(h, v0[0])
-			md5 := fmt.Sprintf("%x", h.Sum(nil))
-
-			length += len(k0)
-			length += len(v0[0])
-
-			// echo error when key != md5(val)
-			if md5 != k0 {
-				fmt.Fprintln(resp, "server:err ", md5, k0)
-				stat = "FAILED"
-			}
-		}
-		if req.MultipartForm != nil {
-			file_num = len(req.MultipartForm.File)
-			for kn, fns := range req.MultipartForm.File {
-				//fmt.Fprintln(resp, "server:filekey ", kn )
-				length += len(kn)
-				for _, f := range fns {
-					fd, err := f.Open()
-					if err != nil {
-						log.Println("server:", err)
-						return
-					}
-					h := md5.New()
-					l0, err := io.Copy(h, fd)
-					if err != nil {
-						log.Println(err)
-						return
-					}
-					length += int(l0)
-					defer fd.Close()
-					md5 := fmt.Sprintf("%x", h.Sum(nil))
-					//fmt.Fprintln(resp, "server:filemd5 ", md5 )
-
-					if kn != md5 {
-						fmt.Fprintln(resp, "server:err ", md5, kn)
-						stat = "FAILED"
-					}
-					//fmt.Fprintln(resp, "server:filename ", f.Filename )
-				}
-			}
-		}
-
-		fmt.Fprintln(resp, "server:got data length", length)
-	}
-	fmt.Fprintln(resp, "-"+stat+"-POST(", len(req.Form), ")-FILE(", file_num, ")--")
-}
-
-func sendFcgi(reqType int, fcgi_params map[string]string, data []byte, posts map[string]string, files map[string]string) (content []byte) {
-	fcgi, err := Dial("tcp", ip_port)
-	if err != nil {
-		log.Println("err:", err)
-		return
-	}
-
-	length := 0
-
-	var resp *http.Response
-	switch reqType {
-	case 0:
-		if len(data) > 0 {
-			length = len(data)
-			rd := bytes.NewReader(data)
-			resp, err = fcgi.Post(fcgi_params, "", rd, rd.Len())
-		} else if len(posts) > 0 {
-			values := url.Values{}
-			for k, v := range posts {
-				values.Set(k, v)
-				length += len(k) + 2 + len(v)
-			}
-			resp, err = fcgi.PostForm(fcgi_params, values)
-		} else {
-			resp, err = fcgi.Get(fcgi_params)
-		}
-
-	default:
-		values := url.Values{}
-		for k, v := range posts {
-			values.Set(k, v)
-			length += len(k) + 2 + len(v)
-		}
-
-		for k, v := range files {
-			fi, _ := os.Lstat(v)
-			length += len(k) + int(fi.Size())
-		}
-		resp, err = fcgi.PostFile(fcgi_params, values, files)
-	}
-
-	if err != nil {
-		log.Println("err:", err)
-		return
-	}
-
-	defer resp.Body.Close()
-	content, err = ioutil.ReadAll(resp.Body)
-
-	log.Println("c: send data length ≈", length, string(content))
-	fcgi.Close()
-	time.Sleep(1 * time.Second)
-
-	if bytes.Index(content, []byte("FAILED")) >= 0 {
-		t_.Error("Server return failed message")
-	}
-
-	return
-}
-
-func generateRandFile(size int) (p string, m string) {
-
-	p = filepath.Join(os.TempDir(), "fcgict"+strconv.Itoa(rand.Int()))
-
-	// open output file
-	fo, err := os.Create(p)
-	if err != nil {
-		panic(err)
-	}
-	// close fo on exit and check for its returned error
-	defer func() {
-		if err := fo.Close(); err != nil {
-			panic(err)
-		}
-	}()
-
-	h := md5.New()
-	for i := 0; i < size/16; i++ {
-		buf := make([]byte, 16)
-		binary.PutVarint(buf, rand.Int63())
-		fo.Write(buf)
-		h.Write(buf)
-	}
-	m = fmt.Sprintf("%x", h.Sum(nil))
-	return
-}
-
-func Disabled_Test(t *testing.T) {
-	// TODO: test chunked reader
-
-	t_ = t
-	rand.Seed(time.Now().UTC().UnixNano())
-
-	// server
-	go func() {
-		listener, err := net.Listen("tcp", ip_port)
-		if err != nil {
-			// handle error
-			log.Println("listener creatation failed: ", err)
-		}
-
-		srv := new(FastCGIServer)
-		fcgi.Serve(listener, srv)
-	}()
-
-	time.Sleep(1 * time.Second)
-
-	// init
-	fcgi_params := make(map[string]string)
-	fcgi_params["REQUEST_METHOD"] = "GET"
-	fcgi_params["SERVER_PROTOCOL"] = "HTTP/1.1"
-	//fcgi_params["GATEWAY_INTERFACE"] = "CGI/1.1"
-	fcgi_params["SCRIPT_FILENAME"] = script_file
-
-	// simple GET
-	log.Println("test:", "get")
-	sendFcgi(0, fcgi_params, nil, nil, nil)
-
-	// simple post data
-	log.Println("test:", "post")
-	sendFcgi(0, fcgi_params, []byte("c4ca4238a0b923820dcc509a6f75849b=1&7b8b965ad4bca0e41ab51de7b31363a1=n"), nil, nil)
-
-	log.Println("test:", "post data (more than 60KB)")
-	data := ""
-	length := 0
-	for i := 0x00; i < 0xff; i++ {
-		v0 := strings.Repeat(string(i), 256)
-		h := md5.New()
-		io.WriteString(h, v0)
-		k0 := fmt.Sprintf("%x", h.Sum(nil))
-
-		length += len(k0)
-		length += len(v0)
-
-		data += k0 + "=" + url.QueryEscape(v0) + "&"
-	}
-	sendFcgi(0, fcgi_params, []byte(data), nil, nil)
-
-	log.Println("test:", "post form (use url.Values)")
-	p0 := make(map[string]string, 1)
-	p0["c4ca4238a0b923820dcc509a6f75849b"] = "1"
-	p0["7b8b965ad4bca0e41ab51de7b31363a1"] = "n"
-	sendFcgi(1, fcgi_params, nil, p0, nil)
-
-	log.Println("test:", "post forms (256 keys, more than 1MB)")
-	p1 := make(map[string]string, 1)
-	for i := 0x00; i < 0xff; i++ {
-		v0 := strings.Repeat(string(i), 4096)
-		h := md5.New()
-		io.WriteString(h, v0)
-		k0 := fmt.Sprintf("%x", h.Sum(nil))
-		p1[k0] = v0
-	}
-	sendFcgi(1, fcgi_params, nil, p1, nil)
-
-	log.Println("test:", "post file (1 file, 500KB)) ")
-	f0 := make(map[string]string, 1)
-	path0, m0 := generateRandFile(500000)
-	f0[m0] = path0
-	sendFcgi(1, fcgi_params, nil, p1, f0)
-
-	log.Println("test:", "post multiple files (2 files, 5M each) and forms (256 keys, more than 1MB data")
-	path1, m1 := generateRandFile(5000000)
-	f0[m1] = path1
-	sendFcgi(1, fcgi_params, nil, p1, f0)
-
-	log.Println("test:", "post only files (2 files, 5M each)")
-	sendFcgi(1, fcgi_params, nil, nil, f0)
-
-	log.Println("test:", "post only 1 file")
-	delete(f0, "m0")
-	sendFcgi(1, fcgi_params, nil, nil, f0)
-
-	os.Remove(path0)
-	os.Remove(path1)
-}

middleware/gzip/filter.go

@@ -1,112 +0,0 @@
-package gzip
-
-import (
-	"net/http"
-	"path"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// Filter determines if a request should be gzipped.
-type Filter interface {
-	// ShouldCompress tells if gzip compression
-	// should be done on the request.
-	ShouldCompress(*http.Request) bool
-}
-
-// ExtFilter is Filter for file name extensions.
-type ExtFilter struct {
-	// Exts is the file name extensions to accept
-	Exts Set
-}
-
-// extWildCard is the wildcard for extensions.
-const extWildCard = "*"
-
-// ShouldCompress checks if the request file extension matches any
-// of the registered extensions. It returns true if the extension is
-// found and false otherwise.
-func (e ExtFilter) ShouldCompress(r *http.Request) bool {
-	ext := path.Ext(r.URL.Path)
-	return e.Exts.Contains(extWildCard) || e.Exts.Contains(ext)
-}
-
-// PathFilter is Filter for request path.
-type PathFilter struct {
-	// IgnoredPaths is the paths to ignore
-	IgnoredPaths Set
-}
-
-// ShouldCompress checks if the request path matches any of the
-// registered paths to ignore. It returns false if an ignored path
-// is found and true otherwise.
-func (p PathFilter) ShouldCompress(r *http.Request) bool {
-	return !p.IgnoredPaths.ContainsFunc(func(value string) bool {
-		return middleware.Path(r.URL.Path).Matches(value)
-	})
-}
-
-// MIMEFilter is Filter for request content types.
-type MIMEFilter struct {
-	// Types is the MIME types to accept.
-	Types Set
-}
-
-// defaultMIMETypes is the list of default MIME types to use.
-var defaultMIMETypes = []string{
-	"text/plain", "text/html", "text/css", "application/json", "application/javascript",
-	"text/x-markdown", "text/xml", "application/xml",
-}
-
-// DefaultMIMEFilter creates a MIMEFilter with default types.
-func DefaultMIMEFilter() MIMEFilter {
-	m := MIMEFilter{Types: make(Set)}
-	for _, mime := range defaultMIMETypes {
-		m.Types.Add(mime)
-	}
-	return m
-}
-
-// ShouldCompress checks if the content type of the request
-// matches any of the registered ones. It returns true if
-// found and false otherwise.
-func (m MIMEFilter) ShouldCompress(r *http.Request) bool {
-	return m.Types.Contains(r.Header.Get("Content-Type"))
-}
-
-func ValidMIME(mime string) bool {
-	s := strings.Split(mime, "/")
-	return len(s) == 2 && strings.TrimSpace(s[0]) != "" && strings.TrimSpace(s[1]) != ""
-}
-
-// Set stores distinct strings.
-type Set map[string]struct{}
-
-// Add adds an element to the set.
-func (s Set) Add(value string) {
-	s[value] = struct{}{}
-}
-
-// Remove removes an element from the set.
-func (s Set) Remove(value string) {
-	delete(s, value)
-}
-
-// Contains check if the set contains value.
-func (s Set) Contains(value string) bool {
-	_, ok := s[value]
-	return ok
-}
-
-// ContainsFunc is similar to Contains. It iterates all the
-// elements in the set and passes each to f. It returns true
-// on the first call to f that returns true and false otherwise.
-func (s Set) ContainsFunc(f func(string) bool) bool {
-	for k, _ := range s {
-		if f(k) {
-			return true
-		}
-	}
-	return false
-}

middleware/gzip/filter_test.go

@@ -1,132 +0,0 @@
-package gzip
-
-import (
-	"net/http"
-	"testing"
-)
-
-func TestSet(t *testing.T) {
-	set := make(Set)
-	set.Add("a")
-	if len(set) != 1 {
-		t.Errorf("Expected 1 found %v", len(set))
-	}
-	set.Add("a")
-	if len(set) != 1 {
-		t.Errorf("Expected 1 found %v", len(set))
-	}
-	set.Add("b")
-	if len(set) != 2 {
-		t.Errorf("Expected 2 found %v", len(set))
-	}
-	if !set.Contains("a") {
-		t.Errorf("Set should contain a")
-	}
-	if !set.Contains("b") {
-		t.Errorf("Set should contain a")
-	}
-	set.Add("c")
-	if len(set) != 3 {
-		t.Errorf("Expected 3 found %v", len(set))
-	}
-	if !set.Contains("c") {
-		t.Errorf("Set should contain c")
-	}
-	set.Remove("a")
-	if len(set) != 2 {
-		t.Errorf("Expected 2 found %v", len(set))
-	}
-	if set.Contains("a") {
-		t.Errorf("Set should not contain a")
-	}
-	if !set.ContainsFunc(func(v string) bool {
-		return v == "c"
-	}) {
-		t.Errorf("ContainsFunc should return true")
-	}
-}
-
-func TestExtFilter(t *testing.T) {
-	var filter Filter = ExtFilter{make(Set)}
-	for _, e := range []string{".txt", ".html", ".css", ".md"} {
-		filter.(ExtFilter).Exts.Add(e)
-	}
-	r := urlRequest("file.txt")
-	if !filter.ShouldCompress(r) {
-		t.Errorf("Should be valid filter")
-	}
-	var exts = []string{
-		".html", ".css", ".md",
-	}
-	for i, e := range exts {
-		r := urlRequest("file" + e)
-		if !filter.ShouldCompress(r) {
-			t.Errorf("Test %v: Should be valid filter", i)
-		}
-	}
-	exts = []string{
-		".htm1", ".abc", ".mdx",
-	}
-	for i, e := range exts {
-		r := urlRequest("file" + e)
-		if filter.ShouldCompress(r) {
-			t.Errorf("Test %v: Should not be valid filter", i)
-		}
-	}
-}
-
-func TestPathFilter(t *testing.T) {
-	paths := []string{
-		"/a", "/b", "/c", "/de",
-	}
-	var filter Filter = PathFilter{make(Set)}
-	for _, p := range paths {
-		filter.(PathFilter).IgnoredPaths.Add(p)
-	}
-	for i, p := range paths {
-		r := urlRequest(p)
-		if filter.ShouldCompress(r) {
-			t.Errorf("Test %v: Should not be valid filter", i)
-		}
-	}
-	paths = []string{
-		"/f", "/g", "/h", "/ed",
-	}
-	for i, p := range paths {
-		r := urlRequest(p)
-		if !filter.ShouldCompress(r) {
-			t.Errorf("Test %v: Should be valid filter", i)
-		}
-	}
-}
-
-func TestMIMEFilter(t *testing.T) {
-	var filter Filter = DefaultMIMEFilter()
-	_ = filter.(MIMEFilter)
-	var mimes = []string{
-		"text/html", "text/css", "application/json",
-	}
-	for i, m := range mimes {
-		r := urlRequest("file" + m)
-		r.Header.Set("Content-Type", m)
-		if !filter.ShouldCompress(r) {
-			t.Errorf("Test %v: Should be valid filter", i)
-		}
-	}
-	mimes = []string{
-		"image/jpeg", "image/png",
-	}
-	filter = DefaultMIMEFilter()
-	for i, m := range mimes {
-		r := urlRequest("file" + m)
-		r.Header.Set("Content-Type", m)
-		if filter.ShouldCompress(r) {
-			t.Errorf("Test %v: Should not be valid filter", i)
-		}
-	}
-}
-
-func urlRequest(url string) *http.Request {
-	r, _ := http.NewRequest("GET", url, nil)
-	return r
-}

middleware/gzip/gzip.go

@@ -1,111 +0,0 @@
-// Package gzip provides a simple middleware layer that performs
-// gzip compression on the response.
-package gzip
-
-import (
-	"compress/gzip"
-	"fmt"
-	"io"
-	"net/http"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// Gzip is a middleware type which gzips HTTP responses. It is
-// imperative that any handler which writes to a gzipped response
-// specifies the Content-Type, otherwise some clients will assume
-// application/x-gzip and try to download a file.
-type Gzip struct {
-	Next    middleware.Handler
-	Configs []Config
-}
-
-// Config holds the configuration for Gzip middleware
-type Config struct {
-	Filters []Filter // Filters to use
-	Level   int      // Compression level
-}
-
-// 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") {
-		return g.Next.ServeHTTP(w, r)
-	}
-
-outer:
-	for _, c := range g.Configs {
-
-		// Check filters to determine if gzipping is permitted for this
-		// request
-		for _, filter := range c.Filters {
-			if !filter.ShouldCompress(r) {
-				continue outer
-			}
-		}
-
-		// Delete this header so gzipping is not repeated later in the chain
-		r.Header.Del("Accept-Encoding")
-
-		w.Header().Set("Content-Encoding", "gzip")
-		gzipWriter, err := newWriter(c, w)
-		if err != nil {
-			// should not happen
-			return http.StatusInternalServerError, err
-		}
-		defer gzipWriter.Close()
-		gz := gzipResponseWriter{Writer: gzipWriter, ResponseWriter: w}
-
-		// Any response in forward middleware will now be compressed
-		status, err := g.Next.ServeHTTP(gz, r)
-
-		// If there was an error that remained unhandled, we need
-		// to send something back before gzipWriter gets closed at
-		// the return of this method!
-		if status >= 400 {
-			gz.Header().Set("Content-Type", "text/plain") // very necessary
-			gz.WriteHeader(status)
-			fmt.Fprintf(gz, "%d %s", status, http.StatusText(status))
-			return 0, err
-		}
-		return status, err
-	}
-
-	// no matching filter
-	return g.Next.ServeHTTP(w, r)
-}
-
-// newWriter create a new Gzip Writer based on the compression level.
-// If the level is valid (i.e. between 1 and 9), it uses the level.
-// Otherwise, it uses default compression level.
-func newWriter(c Config, w http.ResponseWriter) (*gzip.Writer, error) {
-	if c.Level >= gzip.BestSpeed && c.Level <= gzip.BestCompression {
-		return gzip.NewWriterLevel(w, c.Level)
-	}
-	return gzip.NewWriter(w), nil
-}
-
-// gzipResponeWriter wraps the underlying Write method
-// with a gzip.Writer to compress the output.
-type gzipResponseWriter struct {
-	io.Writer
-	http.ResponseWriter
-}
-
-// WriteHeader wraps the underlying WriteHeader method to prevent
-// problems with conflicting headers from proxied backends. For
-// example, a backend system that calculates Content-Length would
-// be wrong because it doesn't know it's being gzipped.
-func (w gzipResponseWriter) WriteHeader(code int) {
-	w.Header().Del("Content-Length")
-	w.ResponseWriter.WriteHeader(code)
-}
-
-// Write wraps the underlying Write method to do compression.
-func (w gzipResponseWriter) Write(b []byte) (int, error) {
-	if w.Header().Get("Content-Type") == "" {
-		w.Header().Set("Content-Type", http.DetectContentType(b))
-	}
-	n, err := w.Writer.Write(b)
-	return n, err
-}

middleware/gzip/gzip_test.go

@@ -1,146 +0,0 @@
-package gzip
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-func TestGzipHandler(t *testing.T) {
-
-	pathFilter := PathFilter{make(Set)}
-	badPaths := []string{"/bad", "/nogzip", "/nongzip"}
-	for _, p := range badPaths {
-		pathFilter.IgnoredPaths.Add(p)
-	}
-	extFilter := ExtFilter{make(Set)}
-	for _, e := range []string{".txt", ".html", ".css", ".md"} {
-		extFilter.Exts.Add(e)
-	}
-	gz := Gzip{Configs: []Config{
-		Config{Filters: []Filter{pathFilter, extFilter}},
-	}}
-
-	w := httptest.NewRecorder()
-	gz.Next = nextFunc(true)
-	var exts = []string{
-		".html", ".css", ".md",
-	}
-	for _, e := range exts {
-		url := "/file" + e
-		r, err := http.NewRequest("GET", url, nil)
-		if err != nil {
-			t.Error(err)
-		}
-		r.Header.Set("Accept-Encoding", "gzip")
-		_, err = gz.ServeHTTP(w, r)
-		if err != nil {
-			t.Error(err)
-		}
-	}
-
-	w = httptest.NewRecorder()
-	gz.Next = nextFunc(false)
-	for _, p := range badPaths {
-		for _, e := range exts {
-			url := p + "/file" + e
-			r, err := http.NewRequest("GET", url, nil)
-			if err != nil {
-				t.Error(err)
-			}
-			r.Header.Set("Accept-Encoding", "gzip")
-			_, err = gz.ServeHTTP(w, r)
-			if err != nil {
-				t.Error(err)
-			}
-		}
-	}
-
-	w = httptest.NewRecorder()
-	gz.Next = nextFunc(false)
-	exts = []string{
-		".htm1", ".abc", ".mdx",
-	}
-	for _, e := range exts {
-		url := "/file" + e
-		r, err := http.NewRequest("GET", url, nil)
-		if err != nil {
-			t.Error(err)
-		}
-		r.Header.Set("Accept-Encoding", "gzip")
-		_, err = gz.ServeHTTP(w, r)
-		if err != nil {
-			t.Error(err)
-		}
-	}
-
-	gz.Configs[0].Filters[1] = DefaultMIMEFilter()
-	w = httptest.NewRecorder()
-	gz.Next = nextFunc(true)
-	var mimes = []string{
-		"text/html", "text/css", "application/json",
-	}
-	for _, m := range mimes {
-		url := "/file"
-		r, err := http.NewRequest("GET", url, nil)
-		if err != nil {
-			t.Error(err)
-		}
-		r.Header.Set("Content-Type", m)
-		r.Header.Set("Accept-Encoding", "gzip")
-		_, err = gz.ServeHTTP(w, r)
-		if err != nil {
-			t.Error(err)
-		}
-	}
-
-	w = httptest.NewRecorder()
-	gz.Next = nextFunc(false)
-	mimes = []string{
-		"image/jpeg", "image/png",
-	}
-	for _, m := range mimes {
-		url := "/file"
-		r, err := http.NewRequest("GET", url, nil)
-		if err != nil {
-			t.Error(err)
-		}
-		r.Header.Set("Content-Type", m)
-		r.Header.Set("Accept-Encoding", "gzip")
-		_, err = gz.ServeHTTP(w, r)
-		if err != nil {
-			t.Error(err)
-		}
-	}
-
-}
-
-func nextFunc(shouldGzip bool) middleware.Handler {
-	return middleware.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-		if shouldGzip {
-			if r.Header.Get("Accept-Encoding") != "" {
-				return 0, fmt.Errorf("Accept-Encoding header not expected")
-			}
-			if w.Header().Get("Content-Encoding") != "gzip" {
-				return 0, fmt.Errorf("Content-Encoding must be gzip, found %v", r.Header.Get("Content-Encoding"))
-			}
-			if _, ok := w.(gzipResponseWriter); !ok {
-				return 0, fmt.Errorf("ResponseWriter should be gzipResponseWriter, found %T", w)
-			}
-			return 0, nil
-		}
-		if r.Header.Get("Accept-Encoding") == "" {
-			return 0, fmt.Errorf("Accept-Encoding header expected")
-		}
-		if w.Header().Get("Content-Encoding") == "gzip" {
-			return 0, fmt.Errorf("Content-Encoding must not be gzip, found gzip")
-		}
-		if _, ok := w.(gzipResponseWriter); ok {
-			return 0, fmt.Errorf("ResponseWriter should not be gzipResponseWriter")
-		}
-		return 0, nil
-	})
-}

middleware/headers/headers.go

@@ -1,50 +0,0 @@
-// Package headers provides middleware that appends headers to
-// requests based on a set of configuration rules that define
-// which routes receive which headers.
-package headers
-
-import (
-	"net/http"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// Headers is middleware that adds headers to the responses
-// for requests matching a certain path.
-type Headers struct {
-	Next  middleware.Handler
-	Rules []Rule
-}
-
-// ServeHTTP implements the middleware.Handler interface and serves requests,
-// setting headers on the response according to the configured rules.
-func (h Headers) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	for _, rule := range h.Rules {
-		if middleware.Path(r.URL.Path).Matches(rule.Path) {
-			for _, header := range rule.Headers {
-				if strings.HasPrefix(header.Name, "-") {
-					w.Header().Del(strings.TrimLeft(header.Name, "-"))
-				} else {
-					w.Header().Set(header.Name, header.Value)
-				}
-			}
-		}
-	}
-	return h.Next.ServeHTTP(w, r)
-}
-
-type (
-	// Rule groups a slice of HTTP headers by a URL pattern.
-	// TODO: use http.Header type instead?
-	Rule struct {
-		Path    string
-		Headers []Header
-	}
-
-	// Header represents a single HTTP header, simply a name and value.
-	Header struct {
-		Name  string
-		Value string
-	}
-)

middleware/headers/headers_test.go

@@ -1,50 +0,0 @@
-package headers
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-func TestHeaders(t *testing.T) {
-	for i, test := range []struct {
-		from  string
-		name  string
-		value string
-	}{
-		{"/a", "Foo", "Bar"},
-		{"/a", "Bar", ""},
-		{"/a", "Baz", ""},
-		{"/b", "Foo", ""},
-		{"/b", "Bar", "Removed in /a"},
-	} {
-		he := Headers{
-			Next: middleware.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-				return 0, nil
-			}),
-			Rules: []Rule{
-				{Path: "/a", Headers: []Header{
-					{Name: "Foo", Value: "Bar"},
-					{Name: "-Bar"},
-				}},
-			},
-		}
-
-		req, err := http.NewRequest("GET", test.from, nil)
-		if err != nil {
-			t.Fatalf("Test %d: Could not create HTTP request: %v", i, err)
-		}
-
-		rec := httptest.NewRecorder()
-		rec.Header().Set("Bar", "Removed in /a")
-
-		he.ServeHTTP(rec, req)
-
-		if got := rec.Header().Get(test.name); got != test.value {
-			t.Errorf("Test %d: Expected %s header to be %q but was %q",
-				i, test.name, test.value, got)
-		}
-	}
-}

middleware/inner/internal.go

@@ -1,90 +0,0 @@
-// Package inner provides a simple middleware that (a) prevents access
-// to internal locations and (b) allows to return files from internal location
-// by setting a special header, e.g. in a proxy response.
-package inner
-
-import (
-	"net/http"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// Internal middleware protects internal locations from external requests -
-// but allows access from the inside by using a special HTTP header.
-type Internal struct {
-	Next  middleware.Handler
-	Paths []string
-}
-
-const (
-	redirectHeader   string = "X-Accel-Redirect"
-	maxRedirectCount int    = 10
-)
-
-func isInternalRedirect(w http.ResponseWriter) bool {
-	return w.Header().Get(redirectHeader) != ""
-}
-
-// ServeHTTP implements the middlware.Handler interface.
-func (i Internal) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-
-	// Internal location requested? -> Not found.
-	for _, prefix := range i.Paths {
-		if middleware.Path(r.URL.Path).Matches(prefix) {
-			return http.StatusNotFound, nil
-		}
-	}
-
-	// Use internal response writer to ignore responses that will be
-	// redirected to internal locations
-	iw := internalResponseWriter{ResponseWriter: w}
-	status, err := i.Next.ServeHTTP(iw, r)
-
-	for c := 0; c < maxRedirectCount && isInternalRedirect(iw); c++ {
-		// Redirect - adapt request URL path and send it again
-		// "down the chain"
-		r.URL.Path = iw.Header().Get(redirectHeader)
-		iw.ClearHeader()
-
-		status, err = i.Next.ServeHTTP(iw, r)
-	}
-
-	if isInternalRedirect(iw) {
-		// Too many redirect cycles
-		iw.ClearHeader()
-		return http.StatusInternalServerError, nil
-	}
-
-	return status, err
-}
-
-// internalResponseWriter wraps the underlying http.ResponseWriter and ignores
-// calls to Write and WriteHeader if the response should be redirected to an
-// internal location.
-type internalResponseWriter struct {
-	http.ResponseWriter
-}
-
-// ClearHeader removes all header fields that are already set.
-func (w internalResponseWriter) ClearHeader() {
-	for k := range w.Header() {
-		w.Header().Del(k)
-	}
-}
-
-// WriteHeader ignores the call if the response should be redirected to an
-// internal location.
-func (w internalResponseWriter) WriteHeader(code int) {
-	if !isInternalRedirect(w) {
-		w.ResponseWriter.WriteHeader(code)
-	}
-}
-
-// Write ignores the call if the response should be redirected to an internal
-// location.
-func (w internalResponseWriter) Write(b []byte) (int, error) {
-	if isInternalRedirect(w) {
-		return 0, nil
-	}
-	return w.ResponseWriter.Write(b)
-}

middleware/inner/internal_test.go

@@ -1,64 +0,0 @@
-package inner
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-func TestInternal(t *testing.T) {
-	im := Internal{
-		Next:  middleware.HandlerFunc(internalTestHandlerFunc),
-		Paths: []string{"/internal"},
-	}
-
-	tests := []struct {
-		url          string
-		expectedCode int
-		expectedBody string
-	}{
-		{"/internal", http.StatusNotFound, ""},
-
-		{"/public", 0, "/public"},
-		{"/public/internal", 0, "/public/internal"},
-
-		{"/redirect", 0, "/internal"},
-
-		{"/cycle", http.StatusInternalServerError, ""},
-	}
-
-	for i, test := range tests {
-		req, err := http.NewRequest("GET", test.url, nil)
-		if err != nil {
-			t.Fatalf("Test %d: Could not create HTTP request: %v", i, err)
-		}
-
-		rec := httptest.NewRecorder()
-		code, err := im.ServeHTTP(rec, req)
-
-		if code != test.expectedCode {
-			t.Errorf("Test %d: Expected status code %d for %s, but got %d",
-				i, test.expectedCode, test.url, code)
-		}
-		if rec.Body.String() != test.expectedBody {
-			t.Errorf("Test %d: Expected body '%s' for %s, but got '%s'",
-				i, test.expectedBody, test.url, rec.Body.String())
-		}
-	}
-}
-
-func internalTestHandlerFunc(w http.ResponseWriter, r *http.Request) (int, error) {
-	switch r.URL.Path {
-	case "/redirect":
-		w.Header().Set("X-Accel-Redirect", "/internal")
-	case "/cycle":
-		w.Header().Set("X-Accel-Redirect", "/cycle")
-	}
-	w.WriteHeader(http.StatusOK)
-	fmt.Fprintf(w, r.URL.String())
-
-	return 0, nil
-}

middleware/log/log.go

@@ -1,57 +0,0 @@
-// Package log implements basic but useful request (access) logging middleware.
-package log
-
-import (
-	"fmt"
-	"log"
-	"net/http"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// Logger is a basic request logging middleware.
-type Logger struct {
-	Next      middleware.Handler
-	Rules     []Rule
-	ErrorFunc func(http.ResponseWriter, *http.Request, int) // failover error handler
-}
-
-func (l Logger) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	for _, rule := range l.Rules {
-		if middleware.Path(r.URL.Path).Matches(rule.PathScope) {
-			responseRecorder := middleware.NewResponseRecorder(w)
-			status, err := l.Next.ServeHTTP(responseRecorder, r)
-			if status >= 400 {
-				// There was an error up the chain, but no response has been written yet.
-				// The error must be handled here so the log entry will record the response size.
-				if l.ErrorFunc != nil {
-					l.ErrorFunc(responseRecorder, r, status)
-				} else {
-					// Default failover error handler
-					responseRecorder.WriteHeader(status)
-					fmt.Fprintf(responseRecorder, "%d %s", status, http.StatusText(status))
-				}
-				status = 0
-			}
-			rep := middleware.NewReplacer(r, responseRecorder)
-			rule.Log.Println(rep.Replace(rule.Format))
-			return status, err
-		}
-	}
-	return l.Next.ServeHTTP(w, r)
-}
-
-// Rule configures the logging middleware.
-type Rule struct {
-	PathScope  string
-	OutputFile string
-	Format     string
-	Log        *log.Logger
-}
-
-const (
-	DefaultLogFilename = "access.log"
-	CommonLogFormat    = `{remote} ` + middleware.EmptyStringReplacer + ` [{when}] "{method} {uri} {proto}" {status} {size}`
-	CombinedLogFormat  = CommonLogFormat + ` "{>Referer}" "{>User-Agent}"`
-	DefaultLogFormat   = CommonLogFormat
-)

middleware/log/log_test.go

@@ -1,48 +0,0 @@
-package log
-
-import (
-	"bytes"
-	"log"
-	"net/http"
-	"net/http/httptest"
-	"strings"
-	"testing"
-)
-
-type erroringMiddleware struct{}
-
-func (erroringMiddleware) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	return http.StatusNotFound, nil
-}
-
-func TestLoggedStatus(t *testing.T) {
-	var f bytes.Buffer
-	var next erroringMiddleware
-	rule := Rule{
-		PathScope: "/",
-		Format:    DefaultLogFormat,
-		Log:       log.New(&f, "", 0),
-	}
-
-	logger := Logger{
-		Rules: []Rule{rule},
-		Next:  next,
-	}
-
-	r, err := http.NewRequest("GET", "/", nil)
-	if err != nil {
-		t.Fatal(err)
-	}
-
-	rec := httptest.NewRecorder()
-
-	status, err := logger.ServeHTTP(rec, r)
-	if status != 0 {
-		t.Error("Expected status to be 0 - was", status)
-	}
-
-	logged := f.String()
-	if !strings.Contains(logged, "404 13") {
-		t.Error("Expected 404 to be logged. Logged string -", logged)
-	}
-}

middleware/markdown/markdown.go

@@ -1,135 +0,0 @@
-// Package markdown is middleware to render markdown files as HTML
-// on-the-fly.
-package markdown
-
-import (
-	"io/ioutil"
-	"net/http"
-	"os"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-	"github.com/russross/blackfriday"
-)
-
-// Markdown implements a layer of middleware that serves
-// markdown as HTML.
-type Markdown struct {
-	// Server root
-	Root string
-
-	// Jail the requests to site root with a mock file system
-	FileSys http.FileSystem
-
-	// Next HTTP handler in the chain
-	Next middleware.Handler
-
-	// The list of markdown configurations
-	Configs []Config
-
-	// The list of index files to try
-	IndexFiles []string
-}
-
-// IsIndexFile checks to see if a file is an index file
-func (md Markdown) IsIndexFile(file string) bool {
-	for _, f := range md.IndexFiles {
-		if f == file {
-			return true
-		}
-	}
-	return false
-}
-
-// Config stores markdown middleware configurations.
-type Config struct {
-	// Markdown renderer
-	Renderer blackfriday.Renderer
-
-	// Base path to match
-	PathScope string
-
-	// List of extensions to consider as markdown files
-	Extensions []string
-
-	// List of style sheets to load for each markdown file
-	Styles []string
-
-	// List of JavaScript files to load for each markdown file
-	Scripts []string
-
-	// Map of registered templates
-	Templates map[string]string
-
-	// Map of request URL to static files generated
-	StaticFiles map[string]string
-
-	// Directory to store static files
-	StaticDir string
-}
-
-// ServeHTTP implements the http.Handler interface.
-func (md Markdown) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	for _, m := range md.Configs {
-		if !middleware.Path(r.URL.Path).Matches(m.PathScope) {
-			continue
-		}
-
-		fpath := r.URL.Path
-		if idx, ok := middleware.IndexFile(md.FileSys, fpath, md.IndexFiles); ok {
-			fpath = idx
-		}
-
-		for _, ext := range m.Extensions {
-			if strings.HasSuffix(fpath, ext) {
-				f, err := md.FileSys.Open(fpath)
-				if err != nil {
-					if os.IsPermission(err) {
-						return http.StatusForbidden, err
-					}
-					return http.StatusNotFound, nil
-				}
-
-				fs, err := f.Stat()
-				if err != nil {
-					return http.StatusNotFound, nil
-				}
-
-				// if static site is generated, attempt to use it
-				if filepath, ok := m.StaticFiles[fpath]; ok {
-					if fs1, err := os.Stat(filepath); err == nil {
-						// if markdown has not been modified
-						// since static page generation,
-						// serve the static page
-						if fs.ModTime().UnixNano() < fs1.ModTime().UnixNano() {
-							if html, err := ioutil.ReadFile(filepath); err == nil {
-								w.Write(html)
-								return http.StatusOK, nil
-							}
-							if os.IsPermission(err) {
-								return http.StatusForbidden, err
-							}
-							return http.StatusNotFound, nil
-						}
-					}
-				}
-
-				body, err := ioutil.ReadAll(f)
-				if err != nil {
-					return http.StatusInternalServerError, err
-				}
-
-				html, err := md.Process(m, fpath, body)
-				if err != nil {
-					return http.StatusInternalServerError, err
-				}
-
-				w.Write(html)
-				return http.StatusOK, nil
-			}
-		}
-	}
-
-	// Didn't qualify to serve as markdown; pass-thru
-	return md.Next.ServeHTTP(w, r)
-}

middleware/markdown/metadata.go

@@ -1,252 +0,0 @@
-package markdown
-
-import (
-	"bufio"
-	"bytes"
-	"encoding/json"
-	"fmt"
-
-	"github.com/BurntSushi/toml"
-	"gopkg.in/yaml.v2"
-)
-
-var (
-	parsers = []MetadataParser{
-		&JSONMetadataParser{metadata: Metadata{Variables: make(map[string]interface{})}},
-		&TOMLMetadataParser{metadata: Metadata{Variables: make(map[string]interface{})}},
-		&YAMLMetadataParser{metadata: Metadata{Variables: make(map[string]interface{})}},
-	}
-)
-
-// Metadata stores a page's metadata
-type Metadata struct {
-	// Page title
-	Title string
-
-	// Page template
-	Template string
-
-	// Variables to be used with Template
-	Variables map[string]interface{}
-}
-
-// load loads parsed values in parsedMap into Metadata
-func (m *Metadata) load(parsedMap map[string]interface{}) {
-	if template, ok := parsedMap["title"]; ok {
-		m.Title, _ = template.(string)
-	}
-	if template, ok := parsedMap["template"]; ok {
-		m.Template, _ = template.(string)
-	}
-	if variables, ok := parsedMap["variables"]; ok {
-		m.Variables, _ = variables.(map[string]interface{})
-	}
-}
-
-// MetadataParser is a an interface that must be satisfied by each parser
-type MetadataParser interface {
-	// Opening identifier
-	Opening() []byte
-
-	// Closing identifier
-	Closing() []byte
-
-	// Parse the metadata.
-	// Returns the remaining page contents (Markdown)
-	// after extracting metadata
-	Parse([]byte) ([]byte, error)
-
-	// Parsed metadata.
-	// Should be called after a call to Parse returns no error
-	Metadata() Metadata
-}
-
-// JSONMetadataParser is the MetdataParser for JSON
-type JSONMetadataParser struct {
-	metadata Metadata
-}
-
-// Parse the metadata
-func (j *JSONMetadataParser) Parse(b []byte) ([]byte, error) {
-	m := make(map[string]interface{})
-
-	// Read the preceding JSON object
-	decoder := json.NewDecoder(bytes.NewReader(b))
-	if err := decoder.Decode(&m); err != nil {
-		return b, err
-	}
-
-	j.metadata.load(m)
-
-	// Retrieve remaining bytes after decoding
-	buf := make([]byte, len(b))
-	n, err := decoder.Buffered().Read(buf)
-	if err != nil {
-		return b, err
-	}
-
-	return buf[:n], nil
-}
-
-// Metadata returns parsed metadata.  It should be called
-// only after a call to Parse returns without error.
-func (j *JSONMetadataParser) Metadata() Metadata {
-	return j.metadata
-}
-
-// Opening returns the opening identifier JSON metadata
-func (j *JSONMetadataParser) Opening() []byte {
-	return []byte("{")
-}
-
-// Closing returns the closing identifier JSON metadata
-func (j *JSONMetadataParser) Closing() []byte {
-	return []byte("}")
-}
-
-// TOMLMetadataParser is the MetadataParser for TOML
-type TOMLMetadataParser struct {
-	metadata Metadata
-}
-
-// Parse the metadata
-func (t *TOMLMetadataParser) Parse(b []byte) ([]byte, error) {
-	b, markdown, err := extractMetadata(t, b)
-	if err != nil {
-		return markdown, err
-	}
-	m := make(map[string]interface{})
-	if err := toml.Unmarshal(b, &m); err != nil {
-		return markdown, err
-	}
-	t.metadata.load(m)
-	return markdown, nil
-}
-
-// Metadata returns parsed metadata.  It should be called
-// only after a call to Parse returns without error.
-func (t *TOMLMetadataParser) Metadata() Metadata {
-	return t.metadata
-}
-
-// Opening returns the opening identifier TOML metadata
-func (t *TOMLMetadataParser) Opening() []byte {
-	return []byte("+++")
-}
-
-// Closing returns the closing identifier TOML metadata
-func (t *TOMLMetadataParser) Closing() []byte {
-	return []byte("+++")
-}
-
-// YAMLMetadataParser is the MetadataParser for YAML
-type YAMLMetadataParser struct {
-	metadata Metadata
-}
-
-// Parse the metadata
-func (y *YAMLMetadataParser) Parse(b []byte) ([]byte, error) {
-	b, markdown, err := extractMetadata(y, b)
-	if err != nil {
-		return markdown, err
-	}
-	m := make(map[string]interface{})
-	if err := yaml.Unmarshal(b, &m); err != nil {
-		return markdown, err
-	}
-
-	// convert variables (if present) to map[string]interface{}
-	// to match expected type
-	if vars, ok := m["variables"].(map[interface{}]interface{}); ok {
-		vars1 := make(map[string]interface{})
-		for k, v := range vars {
-			if key, ok := k.(string); ok {
-				vars1[key] = v
-			}
-		}
-		m["variables"] = vars1
-	}
-
-	y.metadata.load(m)
-	return markdown, nil
-}
-
-// Metadata returns parsed metadata.  It should be called
-// only after a call to Parse returns without error.
-func (y *YAMLMetadataParser) Metadata() Metadata {
-	return y.metadata
-}
-
-// Opening returns the opening identifier YAML metadata
-func (y *YAMLMetadataParser) Opening() []byte {
-	return []byte("---")
-}
-
-// Closing returns the closing identifier YAML metadata
-func (y *YAMLMetadataParser) Closing() []byte {
-	return []byte("---")
-}
-
-// extractMetadata extracts metadata content from a page.
-// it returns the metadata, the remaining bytes (markdown),
-// and an error if any.
-// Useful for MetadataParser with defined identifiers (YAML, TOML)
-func extractMetadata(parser MetadataParser, b []byte) (metadata []byte, markdown []byte, err error) {
-	b = bytes.TrimSpace(b)
-	reader := bytes.NewBuffer(b)
-	scanner := bufio.NewScanner(reader)
-
-	// Read first line
-	if !scanner.Scan() {
-		// if no line is read,
-		// assume metadata not present
-		return nil, b, nil
-	}
-
-	line := bytes.TrimSpace(scanner.Bytes())
-	if !bytes.Equal(line, parser.Opening()) {
-		return nil, b, fmt.Errorf("wrong identifier")
-	}
-
-	// buffer for metadata contents
-	buf := bytes.Buffer{}
-
-	// Read remaining lines until closing identifier is found
-	for scanner.Scan() {
-		line := scanner.Bytes()
-
-		// if closing identifier found
-		if bytes.Equal(bytes.TrimSpace(line), parser.Closing()) {
-
-			// get the scanner to return remaining bytes
-			scanner.Split(func(data []byte, atEOF bool) (int, []byte, error) {
-				return len(data), data, nil
-			})
-			// scan the remaining bytes
-			scanner.Scan()
-
-			return buf.Bytes(), scanner.Bytes(), nil
-		}
-		buf.Write(line)
-		buf.WriteString("\r\n")
-	}
-
-	// closing identifier not found
-	return buf.Bytes(), nil, fmt.Errorf("metadata not closed. '%v' not found", string(parser.Closing()))
-}
-
-// findParser finds the parser using line that contains opening identifier
-func findParser(b []byte) MetadataParser {
-	var line []byte
-	// Read first line
-	if _, err := fmt.Fscanln(bytes.NewReader(b), &line); err != nil {
-		return nil
-	}
-	line = bytes.TrimSpace(line)
-	for _, parser := range parsers {
-		if bytes.Equal(parser.Opening(), line) {
-			return parser
-		}
-	}
-	return nil
-}

middleware/markdown/metadata_test.go

@@ -1,165 +0,0 @@
-package markdown
-
-import (
-	"bytes"
-	"fmt"
-	"reflect"
-	"strings"
-	"testing"
-)
-
-var TOML = [4]string{`
-title = "A title"
-template = "default"
-[variables]
-name = "value"
-`,
-	`+++
-title = "A title"
-template = "default"
-[variables]
-name = "value"
-+++
-Page content
-`,
-	`+++
-title = "A title"
-template = "default"
-[variables]
-name = "value"
-	`,
-	`title = "A title" template = "default" [variables] name = "value"`,
-}
-
-var YAML = [4]string{`
-title : A title
-template : default
-variables :
-  name : value
-`,
-	`---
-title : A title
-template : default
-variables :
-  name : value
----
-Page content
-`,
-	`---
-title : A title
-template : default
-variables :
-  name : value
-`,
-	`title : A title template : default variables : name : value`,
-}
-var JSON = [4]string{`
-	"title" : "A title",
-	"template" : "default",
-	"variables" : {
-		"name" : "value"
-	}
-`,
-	`{
-	"title" : "A title",
-	"template" : "default",
-	"variables" : {
-		"name" : "value"
-	}
-}
-Page content
-`,
-	`
-{
-	"title" : "A title",
-	"template" : "default",
-	"variables" : {
-		"name" : "value"
-	}
-`,
-	`
-{{
-	"title" : "A title",
-	"template" : "default",
-	"variables" : {
-		"name" : "value"
-	}
-}
-	`,
-}
-
-func check(t *testing.T, err error) {
-	if err != nil {
-		t.Fatal(err)
-	}
-}
-
-func TestParsers(t *testing.T) {
-	expected := Metadata{
-		Title:     "A title",
-		Template:  "default",
-		Variables: map[string]interface{}{"name": "value"},
-	}
-	compare := func(m Metadata) bool {
-		if m.Title != expected.Title {
-			return false
-		}
-		if m.Template != expected.Template {
-			return false
-		}
-		for k, v := range m.Variables {
-			if v != expected.Variables[k] {
-				return false
-			}
-		}
-		return len(m.Variables) == 1
-	}
-
-	data := []struct {
-		parser   MetadataParser
-		testData [4]string
-		name     string
-	}{
-		{&JSONMetadataParser{}, JSON, "json"},
-		{&YAMLMetadataParser{}, YAML, "yaml"},
-		{&TOMLMetadataParser{}, TOML, "toml"},
-	}
-
-	for _, v := range data {
-		// metadata without identifiers
-		if _, err := v.parser.Parse([]byte(v.testData[0])); err == nil {
-			t.Fatalf("Expected error for invalid metadata for %v", v.name)
-		}
-
-		// metadata with identifiers
-		md, err := v.parser.Parse([]byte(v.testData[1]))
-		check(t, err)
-		if !compare(v.parser.Metadata()) {
-			t.Fatalf("Expected %v, found %v for %v", expected, v.parser.Metadata(), v.name)
-		}
-		if "Page content" != strings.TrimSpace(string(md)) {
-			t.Fatalf("Expected %v, found %v for %v", "Page content", string(md), v.name)
-		}
-
-		var line []byte
-		fmt.Fscanln(bytes.NewReader([]byte(v.testData[1])), &line)
-		if parser := findParser(line); parser == nil {
-			t.Fatalf("Parser must be found for %v", v.name)
-		} else {
-			if reflect.TypeOf(parser) != reflect.TypeOf(v.parser) {
-				t.Fatalf("parsers not equal. %v != %v", reflect.TypeOf(parser), reflect.TypeOf(v.parser))
-			}
-		}
-
-		// metadata without closing identifier
-		if _, err := v.parser.Parse([]byte(v.testData[2])); err == nil {
-			t.Fatalf("Expected error for missing closing identifier for %v", v.name)
-		}
-
-		// invalid metadata
-		if md, err = v.parser.Parse([]byte(v.testData[3])); err == nil {
-			t.Fatalf("Expected error for invalid metadata for %v", v.name)
-		}
-	}
-
-}

middleware/markdown/process.go

@@ -1,184 +0,0 @@
-package markdown
-
-import (
-	"bytes"
-	"io/ioutil"
-	"log"
-	"os"
-	"path/filepath"
-	"strings"
-	"text/template"
-
-	"github.com/russross/blackfriday"
-)
-
-const (
-	DefaultTemplate  = "defaultTemplate"
-	DefaultStaticDir = "generated_site"
-)
-
-// Process processes the contents of a page in b. It parses the metadata
-// (if any) and uses the template (if found).
-func (md Markdown) Process(c Config, requestPath string, b []byte) ([]byte, error) {
-	var metadata = Metadata{Variables: make(map[string]interface{})}
-	var markdown []byte
-	var err error
-
-	// find parser compatible with page contents
-	parser := findParser(b)
-
-	if parser == nil {
-		// if not found, assume whole file is markdown (no front matter)
-		markdown = b
-	} else {
-		// if found, assume metadata present and parse.
-		markdown, err = parser.Parse(b)
-		if err != nil {
-			return nil, err
-		}
-		metadata = parser.Metadata()
-	}
-
-	// if template is not specified, check if Default template is set
-	if metadata.Template == "" {
-		if _, ok := c.Templates[DefaultTemplate]; ok {
-			metadata.Template = DefaultTemplate
-		}
-	}
-
-	// if template is set, load it
-	var tmpl []byte
-	if metadata.Template != "" {
-		if t, ok := c.Templates[metadata.Template]; ok {
-			tmpl, err = ioutil.ReadFile(t)
-		}
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	// process markdown
-	markdown = blackfriday.Markdown(markdown, c.Renderer, 0)
-
-	// set it as body for template
-	metadata.Variables["markdown"] = string(markdown)
-
-	return md.processTemplate(c, requestPath, tmpl, metadata)
-}
-
-// processTemplate processes a template given a requestPath,
-// template (tmpl) and metadata
-func (md Markdown) processTemplate(c Config, requestPath string, tmpl []byte, metadata Metadata) ([]byte, error) {
-	// if template is not specified,
-	// use the default template
-	if tmpl == nil {
-		tmpl = defaultTemplate(c, metadata, requestPath)
-	}
-
-	// process the template
-	b := new(bytes.Buffer)
-	t, err := template.New("").Parse(string(tmpl))
-	if err != nil {
-		return nil, err
-	}
-	if err = t.Execute(b, metadata.Variables); err != nil {
-		return nil, err
-	}
-
-	// generate static page
-	if err = md.generatePage(c, requestPath, b.Bytes()); err != nil {
-		// if static page generation fails,
-		// nothing fatal, only log the error.
-		// TODO: Report this non-fatal error, but don't log it here
-		log.Println(err)
-	}
-
-	return b.Bytes(), nil
-
-}
-
-// generatePage generates a static html page from the markdown in content if c.StaticDir
-// is a non-empty value, meaning that the user enabled static site generation.
-func (md Markdown) generatePage(c Config, requestPath string, content []byte) error {
-	// Only generate the page if static site generation is enabled
-	if c.StaticDir != "" {
-		// if static directory is not existing, create it
-		if _, err := os.Stat(c.StaticDir); err != nil {
-			err := os.MkdirAll(c.StaticDir, os.FileMode(0755))
-			if err != nil {
-				return err
-			}
-		}
-
-		filePath := filepath.Join(c.StaticDir, requestPath)
-
-		// If it is index file, use the directory instead
-		if md.IsIndexFile(filepath.Base(requestPath)) {
-			filePath, _ = filepath.Split(filePath)
-		}
-
-		// Create the directory in case it is not existing
-		if err := os.MkdirAll(filePath, os.FileMode(0744)); err != nil {
-			return err
-		}
-
-		// generate index.html file in the directory
-		filePath = filepath.Join(filePath, "index.html")
-		err := ioutil.WriteFile(filePath, content, os.FileMode(0664))
-		if err != nil {
-			return err
-		}
-
-		c.StaticFiles[requestPath] = filePath
-	}
-
-	return nil
-}
-
-// defaultTemplate constructs a default template.
-func defaultTemplate(c Config, metadata Metadata, requestPath string) []byte {
-	var scripts, styles bytes.Buffer
-	for _, style := range c.Styles {
-		styles.WriteString(strings.Replace(cssTemplate, "{{url}}", style, 1))
-		styles.WriteString("\r\n")
-	}
-	for _, script := range c.Scripts {
-		scripts.WriteString(strings.Replace(jsTemplate, "{{url}}", script, 1))
-		scripts.WriteString("\r\n")
-	}
-
-	// Title is first line (length-limited), otherwise filename
-	title := metadata.Title
-	if title == "" {
-		title = filepath.Base(requestPath)
-		if body, _ := metadata.Variables["markdown"].([]byte); len(body) > 128 {
-			title = string(body[:128])
-		} else if len(body) > 0 {
-			title = string(body)
-		}
-	}
-
-	html := []byte(htmlTemplate)
-	html = bytes.Replace(html, []byte("{{title}}"), []byte(title), 1)
-	html = bytes.Replace(html, []byte("{{css}}"), styles.Bytes(), 1)
-	html = bytes.Replace(html, []byte("{{js}}"), scripts.Bytes(), 1)
-
-	return html
-}
-
-const (
-	htmlTemplate = `<!DOCTYPE html>
-<html>
-	<head>
-		<title>{{title}}</title>
-		<meta charset="utf-8">
-		{{css}}
-		{{js}}
-	</head>
-	<body>
-		{{.markdown}}
-	</body>
-</html>`
-	cssTemplate = `<link rel="stylesheet" href="{{url}}">`
-	jsTemplate  = `<script src="{{url}}"></script>`
-)

middleware/middleware.go

@@ -1,73 +0,0 @@
-// Package middleware provides some types and functions common among middleware.
-package middleware
-
-import (
-	"net/http"
-	"path/filepath"
-)
-
-type (
-	// Middleware is the middle layer which represents the traditional
-	// idea of middleware: it chains one Handler to the next by being
-	// passed the next Handler in the chain.
-	Middleware func(Handler) Handler
-
-	// Handler is like http.Handler except ServeHTTP returns a status code
-	// and an error. The status code is for the client's benefit; the error
-	// value is for the server's benefit. The status code will be sent to
-	// the client while the error value will be logged privately. Sometimes,
-	// an error status code (4xx or 5xx) may be returned with a nil error
-	// when there is no reason to log the error on the server.
-	//
-	// If a HandlerFunc returns an error (status >= 400), it should NOT
-	// write to the response. This philosophy makes middleware.Handler
-	// different from http.Handler: error handling should happen at the
-	// application layer or in dedicated error-handling middleware only
-	// rather than with an "every middleware for itself" paradigm.
-	//
-	// The application or error-handling middleware should incorporate logic
-	// to ensure that the client always gets a proper response according to
-	// the status code. For security reasons, it should probably not reveal
-	// the actual error message. (Instead it should be logged, for example.)
-	//
-	// Handlers which do write to the response should return a status value
-	// < 400 as a signal that a response has been written. In other words,
-	// only error-handling middleware or the application will write to the
-	// response for a status code >= 400. When ANY handler writes to the
-	// response, it should return a status code < 400 to signal others to
-	// NOT write to the response again, which would be erroneous.
-	Handler interface {
-		ServeHTTP(http.ResponseWriter, *http.Request) (int, error)
-	}
-
-	// HandlerFunc is a convenience type like http.HandlerFunc, except
-	// ServeHTTP returns a status code and an error. See Handler
-	// documentation for more information.
-	HandlerFunc func(http.ResponseWriter, *http.Request) (int, error)
-)
-
-// ServeHTTP implements the Handler interface.
-func (f HandlerFunc) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	return f(w, r)
-}
-
-// IndexFile looks for a file in /root/fpath/indexFile for each string
-// in indexFiles. If an index file is found, it returns the root-relative
-// path to the file and true. If no index file is found, empty string
-// and false is returned. fpath must end in a forward slash '/'
-// otherwise no index files will be tried (directory paths must end
-// in a forward slash according to HTTP).
-func IndexFile(root http.FileSystem, fpath string, indexFiles []string) (string, bool) {
-	if fpath[len(fpath)-1] != '/' || root == nil {
-		return "", false
-	}
-	for _, indexFile := range indexFiles {
-		fp := filepath.Join(fpath, indexFile)
-		f, err := root.Open(fp)
-		if err == nil {
-			f.Close()
-			return fp, true
-		}
-	}
-	return "", false
-}

middleware/path.go

@@ -1,15 +0,0 @@
-package middleware
-
-import "strings"
-
-// Path represents a URI path, maybe with pattern characters.
-type Path string
-
-// Matches checks to see if other matches p.
-//
-// Path matching will probably not always be a direct
-// comparison; this method assures that paths can be
-// easily and consistently matched.
-func (p Path) Matches(other string) bool {
-	return strings.HasPrefix(string(p), other)
-}

middleware/proxy/policy.go

@@ -1,101 +0,0 @@
-package proxy
-
-import (
-	"math/rand"
-	"sync/atomic"
-)
-
-// HostPool is a collection of UpstreamHosts.
-type HostPool []*UpstreamHost
-
-// Policy decides how a host will be selected from a pool.
-type Policy interface {
-	Select(pool HostPool) *UpstreamHost
-}
-
-func init() {
-	RegisterPolicy("random", func() Policy { return &Random{} })
-	RegisterPolicy("least_conn", func() Policy { return &LeastConn{} })
-	RegisterPolicy("round_robin", func() Policy { return &RoundRobin{} })
-}
-
-// Random is a policy that selects up hosts from a pool at random.
-type Random struct{}
-
-// Select selects an up host at random from the specified pool.
-func (r *Random) Select(pool HostPool) *UpstreamHost {
-	// instead of just generating a random index
-	// this is done to prevent selecting a down host
-	var randHost *UpstreamHost
-	count := 0
-	for _, host := range pool {
-		if host.Down() {
-			continue
-		}
-		count++
-		if count == 1 {
-			randHost = host
-		} else {
-			r := rand.Int() % count
-			if r == (count - 1) {
-				randHost = host
-			}
-		}
-	}
-	return randHost
-}
-
-// LeastConn is a policy that selects the host with the least connections.
-type LeastConn struct{}
-
-// Select selects the up host with the least number of connections in the
-// pool.  If more than one host has the same least number of connections,
-// one of the hosts is chosen at random.
-func (r *LeastConn) Select(pool HostPool) *UpstreamHost {
-	var bestHost *UpstreamHost
-	count := 0
-	leastConn := int64(1<<63 - 1)
-	for _, host := range pool {
-		if host.Down() {
-			continue
-		}
-		hostConns := host.Conns
-		if hostConns < leastConn {
-			bestHost = host
-			leastConn = hostConns
-			count = 1
-		} else if hostConns == leastConn {
-			// randomly select host among hosts with least connections
-			count++
-			if count == 1 {
-				bestHost = host
-			} else {
-				r := rand.Int() % count
-				if r == (count - 1) {
-					bestHost = host
-				}
-			}
-		}
-	}
-	return bestHost
-}
-
-// RoundRobin is a policy that selects hosts based on round robin ordering.
-type RoundRobin struct {
-	Robin uint32
-}
-
-// Select selects an up host from the pool using a round robin ordering scheme.
-func (r *RoundRobin) Select(pool HostPool) *UpstreamHost {
-	poolLen := uint32(len(pool))
-	selection := atomic.AddUint32(&r.Robin, 1) % poolLen
-	host := pool[selection]
-	// if the currently selected host is down, just ffwd to up host
-	for i := uint32(1); host.Down() && i < poolLen; i++ {
-		host = pool[(selection+i)%poolLen]
-	}
-	if host.Down() {
-		return nil
-	}
-	return host
-}

middleware/proxy/policy_test.go

@@ -1,72 +0,0 @@
-package proxy
-
-import (
-	"testing"
-)
-
-type customPolicy struct{}
-
-func (r *customPolicy) Select(pool HostPool) *UpstreamHost {
-	return pool[0]
-}
-
-func testPool() HostPool {
-	pool := []*UpstreamHost{
-		&UpstreamHost{
-			Name: "http://google.com", // this should resolve (healthcheck test)
-		},
-		&UpstreamHost{
-			Name: "http://shouldnot.resolve", // this shouldn't
-		},
-		&UpstreamHost{
-			Name: "http://C",
-		},
-	}
-	return HostPool(pool)
-}
-
-func TestRoundRobinPolicy(t *testing.T) {
-	pool := testPool()
-	rrPolicy := &RoundRobin{}
-	h := rrPolicy.Select(pool)
-	// First selected host is 1, because counter starts at 0
-	// and increments before host is selected
-	if h != pool[1] {
-		t.Error("Expected first round robin host to be second host in the pool.")
-	}
-	h = rrPolicy.Select(pool)
-	if h != pool[2] {
-		t.Error("Expected second round robin host to be third host in the pool.")
-	}
-	// mark host as down
-	pool[0].Unhealthy = true
-	h = rrPolicy.Select(pool)
-	if h != pool[1] {
-		t.Error("Expected third round robin host to be first host in the pool.")
-	}
-}
-
-func TestLeastConnPolicy(t *testing.T) {
-	pool := testPool()
-	lcPolicy := &LeastConn{}
-	pool[0].Conns = 10
-	pool[1].Conns = 10
-	h := lcPolicy.Select(pool)
-	if h != pool[2] {
-		t.Error("Expected least connection host to be third host.")
-	}
-	pool[2].Conns = 100
-	h = lcPolicy.Select(pool)
-	if h != pool[0] && h != pool[1] {
-		t.Error("Expected least connection host to be first or second host.")
-	}
-}
-
-func TestCustomPolicy(t *testing.T) {
-	pool := testPool()
-	customPolicy := &customPolicy{}
-	h := customPolicy.Select(pool)
-	if h != pool[0] {
-		t.Error("Expected custom policy host to be the first host.")
-	}
-}

middleware/proxy/proxy.go

@@ -1,127 +0,0 @@
-// Package proxy is middleware that proxies requests.
-package proxy
-
-import (
-	"errors"
-	"net/http"
-	"net/url"
-	"sync/atomic"
-	"time"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-var errUnreachable = errors.New("unreachable backend")
-
-// Proxy represents a middleware instance that can proxy requests.
-type Proxy struct {
-	Next      middleware.Handler
-	Upstreams []Upstream
-}
-
-// Upstream manages a pool of proxy upstream hosts. Select should return a
-// suitable upstream host, or nil if no such hosts are available.
-type Upstream interface {
-	// The path this upstream host should be routed on
-	From() string
-	// Selects an upstream host to be routed to.
-	Select() *UpstreamHost
-}
-
-// UpstreamHostDownFunc can be used to customize how Down behaves.
-type UpstreamHostDownFunc func(*UpstreamHost) bool
-
-// UpstreamHost represents a single proxy upstream
-type UpstreamHost struct {
-	// The hostname of this upstream host
-	Name              string
-	ReverseProxy      *ReverseProxy
-	Conns             int64
-	Fails             int32
-	FailTimeout       time.Duration
-	Unhealthy         bool
-	ExtraHeaders      http.Header
-	CheckDown         UpstreamHostDownFunc
-	WithoutPathPrefix string
-}
-
-// Down checks whether the upstream host is down or not.
-// Down will try to use uh.CheckDown first, and will fall
-// back to some default criteria if necessary.
-func (uh *UpstreamHost) Down() bool {
-	if uh.CheckDown == nil {
-		// Default settings
-		return uh.Unhealthy || uh.Fails > 0
-	}
-	return uh.CheckDown(uh)
-}
-
-// ServeHTTP satisfies the middleware.Handler interface.
-func (p Proxy) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-
-	for _, upstream := range p.Upstreams {
-		if middleware.Path(r.URL.Path).Matches(upstream.From()) {
-			var replacer middleware.Replacer
-			start := time.Now()
-			requestHost := r.Host
-
-			// Since Select() should give us "up" hosts, keep retrying
-			// hosts until timeout (or until we get a nil host).
-			for time.Now().Sub(start) < (60 * time.Second) {
-				host := upstream.Select()
-				if host == nil {
-					return http.StatusBadGateway, errUnreachable
-				}
-				proxy := host.ReverseProxy
-				r.Host = host.Name
-
-				if baseURL, err := url.Parse(host.Name); err == nil {
-					r.Host = baseURL.Host
-					if proxy == nil {
-						proxy = NewSingleHostReverseProxy(baseURL, host.WithoutPathPrefix)
-					}
-				} else if proxy == nil {
-					return http.StatusInternalServerError, err
-				}
-				var extraHeaders http.Header
-				if host.ExtraHeaders != nil {
-					extraHeaders = make(http.Header)
-					if replacer == nil {
-						rHost := r.Host
-						r.Host = requestHost
-						replacer = middleware.NewReplacer(r, nil)
-						r.Host = rHost
-					}
-					for header, values := range host.ExtraHeaders {
-						for _, value := range values {
-							extraHeaders.Add(header,
-								replacer.Replace(value))
-							if header == "Host" {
-								r.Host = replacer.Replace(value)
-							}
-						}
-					}
-				}
-
-				atomic.AddInt64(&host.Conns, 1)
-				backendErr := proxy.ServeHTTP(w, r, extraHeaders)
-				atomic.AddInt64(&host.Conns, -1)
-				if backendErr == nil {
-					return 0, nil
-				}
-				timeout := host.FailTimeout
-				if timeout == 0 {
-					timeout = 10 * time.Second
-				}
-				atomic.AddInt32(&host.Fails, 1)
-				go func(host *UpstreamHost, timeout time.Duration) {
-					time.Sleep(timeout)
-					atomic.AddInt32(&host.Fails, -1)
-				}(host, timeout)
-			}
-			return http.StatusBadGateway, errUnreachable
-		}
-	}
-
-	return p.Next.ServeHTTP(w, r)
-}

middleware/proxy/proxy_test.go

@@ -1,151 +0,0 @@
-package proxy
-
-import (
-	"bufio"
-	"bytes"
-	"io"
-	"net"
-	"net/http"
-	"net/http/httptest"
-	"net/url"
-	"strings"
-	"testing"
-	"time"
-
-	"golang.org/x/net/websocket"
-)
-
-func TestWebSocketReverseProxyServeHTTPHandler(t *testing.T) {
-	// No-op websocket backend simply allows the WS connection to be
-	// accepted then it will be immediately closed. Perfect for testing.
-	wsNop := httptest.NewServer(websocket.Handler(func(ws *websocket.Conn) {}))
-	defer wsNop.Close()
-
-	// Get proxy to use for the test
-	p := newWebSocketTestProxy(wsNop.URL)
-
-	// Create client request
-	r, err := http.NewRequest("GET", "/", nil)
-	if err != nil {
-		t.Fatalf("Failed to create request: %v", err)
-	}
-	r.Header = http.Header{
-		"Connection":            {"Upgrade"},
-		"Upgrade":               {"websocket"},
-		"Origin":                {wsNop.URL},
-		"Sec-WebSocket-Key":     {"x3JJHMbDL1EzLkh9GBhXDw=="},
-		"Sec-WebSocket-Version": {"13"},
-	}
-
-	// Capture the request
-	w := &recorderHijacker{httptest.NewRecorder(), new(fakeConn)}
-
-	// Booya! Do the test.
-	p.ServeHTTP(w, r)
-
-	// Make sure the backend accepted the WS connection.
-	// Mostly interested in the Upgrade and Connection response headers
-	// and the 101 status code.
-	expected := []byte("HTTP/1.1 101 Switching Protocols\r\nUpgrade: websocket\r\nConnection: Upgrade\r\nSec-WebSocket-Accept: HSmrc0sMlYUkAGmm5OPpG2HaGWk=\r\n\r\n")
-	actual := w.fakeConn.writeBuf.Bytes()
-	if !bytes.Equal(actual, expected) {
-		t.Errorf("Expected backend to accept response:\n'%s'\nActually got:\n'%s'", expected, actual)
-	}
-}
-
-func TestWebSocketReverseProxyFromWSClient(t *testing.T) {
-	// Echo server allows us to test that socket bytes are properly
-	// being proxied.
-	wsEcho := httptest.NewServer(websocket.Handler(func(ws *websocket.Conn) {
-		io.Copy(ws, ws)
-	}))
-	defer wsEcho.Close()
-
-	// Get proxy to use for the test
-	p := newWebSocketTestProxy(wsEcho.URL)
-
-	// This is a full end-end test, so the proxy handler
-	// has to be part of a server listening on a port. Our
-	// WS client will connect to this test server, not
-	// the echo client directly.
-	echoProxy := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		p.ServeHTTP(w, r)
-	}))
-	defer echoProxy.Close()
-
-	// Set up WebSocket client
-	url := strings.Replace(echoProxy.URL, "http://", "ws://", 1)
-	ws, err := websocket.Dial(url, "", echoProxy.URL)
-	if err != nil {
-		t.Fatal(err)
-	}
-	defer ws.Close()
-
-	// Send test message
-	trialMsg := "Is it working?"
-	websocket.Message.Send(ws, trialMsg)
-
-	// It should be echoed back to us
-	var actualMsg string
-	websocket.Message.Receive(ws, &actualMsg)
-	if actualMsg != trialMsg {
-		t.Errorf("Expected '%s' but got '%s' instead", trialMsg, actualMsg)
-	}
-}
-
-// newWebSocketTestProxy returns a test proxy that will
-// redirect to the specified backendAddr. The function
-// also sets up the rules/environment for testing WebSocket
-// proxy.
-func newWebSocketTestProxy(backendAddr string) *Proxy {
-	proxyHeaders = http.Header{
-		"Connection": {"{>Connection}"},
-		"Upgrade":    {"{>Upgrade}"},
-	}
-
-	return &Proxy{
-		Upstreams: []Upstream{&fakeUpstream{name: backendAddr}},
-	}
-}
-
-type fakeUpstream struct {
-	name string
-}
-
-func (u *fakeUpstream) From() string {
-	return "/"
-}
-
-func (u *fakeUpstream) Select() *UpstreamHost {
-	uri, _ := url.Parse(u.name)
-	return &UpstreamHost{
-		Name:         u.name,
-		ReverseProxy: NewSingleHostReverseProxy(uri, ""),
-		ExtraHeaders: proxyHeaders,
-	}
-}
-
-// recorderHijacker is a ResponseRecorder that can
-// be hijacked.
-type recorderHijacker struct {
-	*httptest.ResponseRecorder
-	fakeConn *fakeConn
-}
-
-func (rh *recorderHijacker) Hijack() (net.Conn, *bufio.ReadWriter, error) {
-	return rh.fakeConn, nil, nil
-}
-
-type fakeConn struct {
-	readBuf  bytes.Buffer
-	writeBuf bytes.Buffer
-}
-
-func (c *fakeConn) LocalAddr() net.Addr                { return nil }
-func (c *fakeConn) RemoteAddr() net.Addr               { return nil }
-func (c *fakeConn) SetDeadline(t time.Time) error      { return nil }
-func (c *fakeConn) SetReadDeadline(t time.Time) error  { return nil }
-func (c *fakeConn) SetWriteDeadline(t time.Time) error { return nil }
-func (c *fakeConn) Close() error                       { return nil }
-func (c *fakeConn) Read(b []byte) (int, error)         { return c.readBuf.Read(b) }
-func (c *fakeConn) Write(b []byte) (int, error)        { return c.writeBuf.Write(b) }

middleware/proxy/reverseproxy.go

@@ -1,252 +0,0 @@
-// This file is adapted from code in the net/http/httputil
-// package of the Go standard library, which is by the
-// Go Authors, and bears this copyright and license info:
-//
-//   Copyright 2011 The Go Authors. All rights reserved.
-//   Use of this source code is governed by a BSD-style
-//   license that can be found in the LICENSE file.
-//
-// This file has been modified from the standard lib to
-// meet the needs of the application.
-
-package proxy
-
-import (
-	"io"
-	"net"
-	"net/http"
-	"net/url"
-	"strings"
-	"sync"
-	"time"
-)
-
-// onExitFlushLoop is a callback set by tests to detect the state of the
-// flushLoop() goroutine.
-var onExitFlushLoop func()
-
-// ReverseProxy is an HTTP Handler that takes an incoming request and
-// sends it to another server, proxying the response back to the
-// client.
-type ReverseProxy struct {
-	// Director must be a function which modifies
-	// the request into a new request to be sent
-	// using Transport. Its response is then copied
-	// back to the original client unmodified.
-	Director func(*http.Request)
-
-	// The transport used to perform proxy requests.
-	// If nil, http.DefaultTransport is used.
-	Transport http.RoundTripper
-
-	// FlushInterval specifies the flush interval
-	// to flush to the client while copying the
-	// response body.
-	// If zero, no periodic flushing is done.
-	FlushInterval time.Duration
-}
-
-func singleJoiningSlash(a, b string) string {
-	aslash := strings.HasSuffix(a, "/")
-	bslash := strings.HasPrefix(b, "/")
-	switch {
-	case aslash && bslash:
-		return a + b[1:]
-	case !aslash && !bslash:
-		return a + "/" + b
-	}
-	return a + b
-}
-
-// NewSingleHostReverseProxy returns a new ReverseProxy that rewrites
-// URLs to the scheme, host, and base path provided in target. If the
-// target's path is "/base" and the incoming request was for "/dir",
-// the target request will be for /base/dir.
-// Without logic: target's path is "/", incoming is "/api/messages",
-// without is "/api", then the target request will be for /messages.
-func NewSingleHostReverseProxy(target *url.URL, without string) *ReverseProxy {
-	targetQuery := target.RawQuery
-	director := func(req *http.Request) {
-		req.URL.Scheme = target.Scheme
-		req.URL.Host = target.Host
-		req.URL.Path = singleJoiningSlash(target.Path, req.URL.Path)
-		if targetQuery == "" || req.URL.RawQuery == "" {
-			req.URL.RawQuery = targetQuery + req.URL.RawQuery
-		} else {
-			req.URL.RawQuery = targetQuery + "&" + req.URL.RawQuery
-		}
-		if without != "" {
-			req.URL.Path = strings.TrimPrefix(req.URL.Path, without)
-		}
-	}
-	return &ReverseProxy{Director: director}
-}
-
-func copyHeader(dst, src http.Header) {
-	for k, vv := range src {
-		for _, v := range vv {
-			dst.Add(k, v)
-		}
-	}
-}
-
-// Hop-by-hop headers. These are removed when sent to the backend.
-// http://www.w3.org/Protocols/rfc2616/rfc2616-sec13.html
-var hopHeaders = []string{
-	"Connection",
-	"Keep-Alive",
-	"Proxy-Authenticate",
-	"Proxy-Authorization",
-	"Te", // canonicalized version of "TE"
-	"Trailers",
-	"Transfer-Encoding",
-	"Upgrade",
-}
-
-func (p *ReverseProxy) ServeHTTP(rw http.ResponseWriter, req *http.Request, extraHeaders http.Header) error {
-	transport := p.Transport
-	if transport == nil {
-		transport = http.DefaultTransport
-	}
-
-	outreq := new(http.Request)
-	*outreq = *req // includes shallow copies of maps, but okay
-
-	p.Director(outreq)
-	outreq.Proto = "HTTP/1.1"
-	outreq.ProtoMajor = 1
-	outreq.ProtoMinor = 1
-	outreq.Close = false
-
-	// Remove hop-by-hop headers to the backend.  Especially
-	// important is "Connection" because we want a persistent
-	// connection, regardless of what the client sent to us.  This
-	// is modifying the same underlying map from req (shallow
-	// copied above) so we only copy it if necessary.
-	copiedHeaders := false
-	for _, h := range hopHeaders {
-		if outreq.Header.Get(h) != "" {
-			if !copiedHeaders {
-				outreq.Header = make(http.Header)
-				copyHeader(outreq.Header, req.Header)
-				copiedHeaders = true
-			}
-			outreq.Header.Del(h)
-		}
-	}
-
-	if clientIP, _, err := net.SplitHostPort(req.RemoteAddr); err == nil {
-		// If we aren't the first proxy retain prior
-		// X-Forwarded-For information as a comma+space
-		// separated list and fold multiple headers into one.
-		if prior, ok := outreq.Header["X-Forwarded-For"]; ok {
-			clientIP = strings.Join(prior, ", ") + ", " + clientIP
-		}
-		outreq.Header.Set("X-Forwarded-For", clientIP)
-	}
-
-	if extraHeaders != nil {
-		for k, v := range extraHeaders {
-			outreq.Header[k] = v
-		}
-	}
-
-	res, err := transport.RoundTrip(outreq)
-	if err != nil {
-		return err
-	}
-	defer res.Body.Close()
-
-	if res.StatusCode == http.StatusSwitchingProtocols && res.Header.Get("Upgrade") == "websocket" {
-		hj, ok := rw.(http.Hijacker)
-		if !ok {
-			return nil
-		}
-
-		conn, _, err := hj.Hijack()
-		if err != nil {
-			return err
-		}
-		defer conn.Close()
-
-		backendConn, err := net.Dial("tcp", outreq.Host)
-		if err != nil {
-			return err
-		}
-		defer backendConn.Close()
-
-		outreq.Write(backendConn)
-
-		go func() {
-			io.Copy(backendConn, conn) // write tcp stream to backend.
-		}()
-		io.Copy(conn, backendConn) // read tcp stream from backend.
-	} else {
-		for _, h := range hopHeaders {
-			res.Header.Del(h)
-		}
-
-		copyHeader(rw.Header(), res.Header)
-
-		rw.WriteHeader(res.StatusCode)
-		p.copyResponse(rw, res.Body)
-	}
-
-	return nil
-}
-
-func (p *ReverseProxy) copyResponse(dst io.Writer, src io.Reader) {
-	if p.FlushInterval != 0 {
-		if wf, ok := dst.(writeFlusher); ok {
-			mlw := &maxLatencyWriter{
-				dst:     wf,
-				latency: p.FlushInterval,
-				done:    make(chan bool),
-			}
-			go mlw.flushLoop()
-			defer mlw.stop()
-			dst = mlw
-		}
-	}
-
-	io.Copy(dst, src)
-}
-
-type writeFlusher interface {
-	io.Writer
-	http.Flusher
-}
-
-type maxLatencyWriter struct {
-	dst     writeFlusher
-	latency time.Duration
-
-	lk   sync.Mutex // protects Write + Flush
-	done chan bool
-}
-
-func (m *maxLatencyWriter) Write(p []byte) (int, error) {
-	m.lk.Lock()
-	defer m.lk.Unlock()
-	return m.dst.Write(p)
-}
-
-func (m *maxLatencyWriter) flushLoop() {
-	t := time.NewTicker(m.latency)
-	defer t.Stop()
-	for {
-		select {
-		case <-m.done:
-			if onExitFlushLoop != nil {
-				onExitFlushLoop()
-			}
-			return
-		case <-t.C:
-			m.lk.Lock()
-			m.dst.Flush()
-			m.lk.Unlock()
-		}
-	}
-}
-
-func (m *maxLatencyWriter) stop() { m.done <- true }

middleware/proxy/upstream.go

@@ -1,217 +0,0 @@
-package proxy
-
-import (
-	"io"
-	"io/ioutil"
-	"net/http"
-	"net/url"
-	"strconv"
-	"strings"
-	"time"
-
-	"github.com/mholt/caddy/config/parse"
-)
-
-var (
-	supportedPolicies map[string]func() Policy = make(map[string]func() Policy)
-	proxyHeaders      http.Header              = make(http.Header)
-)
-
-type staticUpstream struct {
-	from   string
-	Hosts  HostPool
-	Policy Policy
-
-	FailTimeout time.Duration
-	MaxFails    int32
-	HealthCheck struct {
-		Path     string
-		Interval time.Duration
-	}
-	WithoutPathPrefix string
-}
-
-// NewStaticUpstreams parses the configuration input and sets up
-// static upstreams for the proxy middleware.
-func NewStaticUpstreams(c parse.Dispenser) ([]Upstream, error) {
-	var upstreams []Upstream
-	for c.Next() {
-		upstream := &staticUpstream{
-			from:        "",
-			Hosts:       nil,
-			Policy:      &Random{},
-			FailTimeout: 10 * time.Second,
-			MaxFails:    1,
-		}
-
-		if !c.Args(&upstream.from) {
-			return upstreams, c.ArgErr()
-		}
-		to := c.RemainingArgs()
-		if len(to) == 0 {
-			return upstreams, c.ArgErr()
-		}
-
-		for c.NextBlock() {
-			switch c.Val() {
-			case "policy":
-				if !c.NextArg() {
-					return upstreams, c.ArgErr()
-				}
-
-				if policyCreateFunc, ok := supportedPolicies[c.Val()]; ok {
-					upstream.Policy = policyCreateFunc()
-				} else {
-					return upstreams, c.ArgErr()
-				}
-			case "fail_timeout":
-				if !c.NextArg() {
-					return upstreams, c.ArgErr()
-				}
-				if dur, err := time.ParseDuration(c.Val()); err == nil {
-					upstream.FailTimeout = dur
-				} else {
-					return upstreams, err
-				}
-			case "max_fails":
-				if !c.NextArg() {
-					return upstreams, c.ArgErr()
-				}
-				if n, err := strconv.Atoi(c.Val()); err == nil {
-					upstream.MaxFails = int32(n)
-				} else {
-					return upstreams, err
-				}
-			case "health_check":
-				if !c.NextArg() {
-					return upstreams, c.ArgErr()
-				}
-				upstream.HealthCheck.Path = c.Val()
-				upstream.HealthCheck.Interval = 30 * time.Second
-				if c.NextArg() {
-					if dur, err := time.ParseDuration(c.Val()); err == nil {
-						upstream.HealthCheck.Interval = dur
-					} else {
-						return upstreams, err
-					}
-				}
-			case "proxy_header":
-				var header, value string
-				if !c.Args(&header, &value) {
-					return upstreams, c.ArgErr()
-				}
-				proxyHeaders.Add(header, value)
-			case "websocket":
-				proxyHeaders.Add("Connection", "{>Connection}")
-				proxyHeaders.Add("Upgrade", "{>Upgrade}")
-			case "without":
-				if !c.NextArg() {
-					return upstreams, c.ArgErr()
-				}
-				upstream.WithoutPathPrefix = c.Val()
-			}
-		}
-
-		upstream.Hosts = make([]*UpstreamHost, len(to))
-		for i, host := range to {
-			if !strings.HasPrefix(host, "http") {
-				host = "http://" + host
-			}
-			uh := &UpstreamHost{
-				Name:         host,
-				Conns:        0,
-				Fails:        0,
-				FailTimeout:  upstream.FailTimeout,
-				Unhealthy:    false,
-				ExtraHeaders: proxyHeaders,
-				CheckDown: func(upstream *staticUpstream) UpstreamHostDownFunc {
-					return func(uh *UpstreamHost) bool {
-						if uh.Unhealthy {
-							return true
-						}
-						if uh.Fails >= upstream.MaxFails &&
-							upstream.MaxFails != 0 {
-							return true
-						}
-						return false
-					}
-				}(upstream),
-				WithoutPathPrefix: upstream.WithoutPathPrefix,
-			}
-			if baseURL, err := url.Parse(uh.Name); err == nil {
-				uh.ReverseProxy = NewSingleHostReverseProxy(baseURL, uh.WithoutPathPrefix)
-			} else {
-				return upstreams, err
-			}
-			upstream.Hosts[i] = uh
-		}
-
-		if upstream.HealthCheck.Path != "" {
-			go upstream.HealthCheckWorker(nil)
-		}
-		upstreams = append(upstreams, upstream)
-	}
-	return upstreams, nil
-}
-
-// RegisterPolicy adds a custom policy to the proxy.
-func RegisterPolicy(name string, policy func() Policy) {
-	supportedPolicies[name] = policy
-}
-
-func (u *staticUpstream) From() string {
-	return u.from
-}
-
-func (u *staticUpstream) healthCheck() {
-	for _, host := range u.Hosts {
-		hostURL := host.Name + u.HealthCheck.Path
-		if r, err := http.Get(hostURL); err == nil {
-			io.Copy(ioutil.Discard, r.Body)
-			r.Body.Close()
-			host.Unhealthy = r.StatusCode < 200 || r.StatusCode >= 400
-		} else {
-			host.Unhealthy = true
-		}
-	}
-}
-
-func (u *staticUpstream) HealthCheckWorker(stop chan struct{}) {
-	ticker := time.NewTicker(u.HealthCheck.Interval)
-	u.healthCheck()
-	for {
-		select {
-		case <-ticker.C:
-			u.healthCheck()
-		case <-stop:
-			// TODO: the library should provide a stop channel and global
-			// waitgroup to allow goroutines started by plugins a chance
-			// to clean themselves up.
-		}
-	}
-}
-
-func (u *staticUpstream) Select() *UpstreamHost {
-	pool := u.Hosts
-	if len(pool) == 1 {
-		if pool[0].Down() {
-			return nil
-		}
-		return pool[0]
-	}
-	allDown := true
-	for _, host := range pool {
-		if !host.Down() {
-			allDown = false
-			break
-		}
-	}
-	if allDown {
-		return nil
-	}
-
-	if u.Policy == nil {
-		return (&Random{}).Select(pool)
-	}
-	return u.Policy.Select(pool)
-}

middleware/proxy/upstream_test.go

@@ -1,53 +0,0 @@
-package proxy
-
-import (
-	"testing"
-	"time"
-)
-
-func TestHealthCheck(t *testing.T) {
-	upstream := &staticUpstream{
-		from:        "",
-		Hosts:       testPool(),
-		Policy:      &Random{},
-		FailTimeout: 10 * time.Second,
-		MaxFails:    1,
-	}
-	upstream.healthCheck()
-	if upstream.Hosts[0].Down() {
-		t.Error("Expected first host in testpool to not fail healthcheck.")
-	}
-	if !upstream.Hosts[1].Down() {
-		t.Error("Expected second host in testpool to fail healthcheck.")
-	}
-}
-
-func TestSelect(t *testing.T) {
-	upstream := &staticUpstream{
-		from:        "",
-		Hosts:       testPool()[:3],
-		Policy:      &Random{},
-		FailTimeout: 10 * time.Second,
-		MaxFails:    1,
-	}
-	upstream.Hosts[0].Unhealthy = true
-	upstream.Hosts[1].Unhealthy = true
-	upstream.Hosts[2].Unhealthy = true
-	if h := upstream.Select(); h != nil {
-		t.Error("Expected select to return nil as all host are down")
-	}
-	upstream.Hosts[2].Unhealthy = false
-	if h := upstream.Select(); h == nil {
-		t.Error("Expected select to not return nil")
-	}
-}
-
-func TestRegisterPolicy(t *testing.T) {
-	name := "custom"
-	customPolicy := &customPolicy{}
-	RegisterPolicy(name, func() Policy { return customPolicy })
-	if _, ok := supportedPolicies[name]; !ok {
-		t.Error("Expected supportedPolicies to have a custom policy.")
-	}
-
-}

middleware/recorder.go

@@ -1,62 +0,0 @@
-package middleware
-
-import (
-	"bufio"
-	"errors"
-	"net"
-	"net/http"
-	"time"
-)
-
-// responseRecorder is a type of ResponseWriter that captures
-// the status code written to it and also the size of the body
-// written in the response. A status code does not have
-// to be written, however, in which case 200 must be assumed.
-// It is best to have the constructor initialize this type
-// with that default status code.
-type responseRecorder struct {
-	http.ResponseWriter
-	status int
-	size   int
-	start  time.Time
-}
-
-// NewResponseRecorder makes and returns a new responseRecorder,
-// which captures the HTTP Status code from the ResponseWriter
-// and also the length of the response body written through it.
-// Because a status is not set unless WriteHeader is called
-// explicitly, this constructor initializes with a status code
-// of 200 to cover the default case.
-func NewResponseRecorder(w http.ResponseWriter) *responseRecorder {
-	return &responseRecorder{
-		ResponseWriter: w,
-		status:         http.StatusOK,
-		start:          time.Now(),
-	}
-}
-
-// WriteHeader records the status code and calls the
-// underlying ResponseWriter's WriteHeader method.
-func (r *responseRecorder) WriteHeader(status int) {
-	r.status = status
-	r.ResponseWriter.WriteHeader(status)
-}
-
-// Write is a wrapper that records the size of the body
-// that gets written.
-func (r *responseRecorder) Write(buf []byte) (int, error) {
-	n, err := r.ResponseWriter.Write(buf)
-	if err == nil {
-		r.size += n
-	}
-	return n, err
-}
-
-// Hijacker is a wrapper of http.Hijacker underearth if any,
-// otherwise it just returns an error.
-func (r *responseRecorder) Hijack() (net.Conn, *bufio.ReadWriter, error) {
-	if hj, ok := r.ResponseWriter.(http.Hijacker); ok {
-		return hj.Hijack()
-	}
-	return nil, nil, errors.New("I'm not a Hijacker")
-}

middleware/redirect/redirect.go

@@ -1,57 +0,0 @@
-// Package redirect is middleware for redirecting certain requests
-// to other locations.
-package redirect
-
-import (
-	"fmt"
-	"html"
-	"net/http"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// Redirect is middleware to respond with HTTP redirects
-type Redirect struct {
-	Next  middleware.Handler
-	Rules []Rule
-}
-
-// ServeHTTP implements the middleware.Handler interface.
-func (rd Redirect) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	for _, rule := range rd.Rules {
-		if rule.From == "/" {
-			// Catchall redirect preserves path (TODO: Standardize/formalize this behavior)
-			newPath := strings.TrimSuffix(rule.To, "/") + r.URL.Path
-			if rule.Meta {
-				fmt.Fprintf(w, metaRedir, html.EscapeString(newPath))
-			} else {
-				http.Redirect(w, r, newPath, rule.Code)
-			}
-			return 0, nil
-		}
-		if r.URL.Path == rule.From {
-			if rule.Meta {
-				fmt.Fprintf(w, metaRedir, html.EscapeString(rule.To))
-			} else {
-				http.Redirect(w, r, rule.To, rule.Code)
-			}
-			return 0, nil
-		}
-	}
-	return rd.Next.ServeHTTP(w, r)
-}
-
-// Rule describes an HTTP redirect rule.
-type Rule struct {
-	From, To string
-	Code     int
-	Meta     bool
-}
-
-var metaRedir = `<html>
-<head>
-  <meta http-equiv="refresh" content="0;URL='%s'">
-</head>
-<body>redirecting...</body>
-</html>`

middleware/redirect/redirect_test.go

@@ -1,86 +0,0 @@
-package redirect
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-func TestMetaRedirect(t *testing.T) {
-	re := Redirect{
-		Rules: []Rule{
-			{From: "/", Meta: true, To: "https://example.com/"},
-			{From: "/whatever", Meta: true, To: "https://example.com/whatever"},
-		},
-	}
-
-	for i, test := range re.Rules {
-		req, err := http.NewRequest("GET", test.From, nil)
-		if err != nil {
-			t.Fatalf("Test %d: Could not create HTTP request: %v", i, err)
-		}
-
-		rec := httptest.NewRecorder()
-		re.ServeHTTP(rec, req)
-
-		body, err := ioutil.ReadAll(rec.Body)
-		if err != nil {
-			t.Fatalf("Test %d: Could not read HTTP response body: %v", i, err)
-		}
-		expectedSnippet := `<meta http-equiv="refresh" content="0;URL='` + test.To + `'">`
-		if !bytes.Contains(body, []byte(expectedSnippet)) {
-			t.Errorf("Test %d: Expected Response Body to contain %q but was %q",
-				i, expectedSnippet, body)
-		}
-	}
-}
-
-func TestRedirect(t *testing.T) {
-	for i, test := range []struct {
-		from             string
-		expectedLocation string
-	}{
-		{"/from", "/to"},
-		{"/a", "/b"},
-		{"/aa", ""},
-		{"/", ""},
-		{"/a?foo=bar", "/b"},
-		{"/asdf?foo=bar", ""},
-		{"/foo#bar", ""},
-		{"/a#foo", "/b"},
-	} {
-		var nextCalled bool
-
-		re := Redirect{
-			Next: middleware.HandlerFunc(func(w http.ResponseWriter, r *http.Request) (int, error) {
-				nextCalled = true
-				return 0, nil
-			}),
-			Rules: []Rule{
-				{From: "/from", To: "/to"},
-				{From: "/a", To: "/b"},
-			},
-		}
-
-		req, err := http.NewRequest("GET", test.from, nil)
-		if err != nil {
-			t.Fatalf("Test %d: Could not create HTTP request: %v", i, err)
-		}
-
-		rec := httptest.NewRecorder()
-		re.ServeHTTP(rec, req)
-
-		if rec.Header().Get("Location") != test.expectedLocation {
-			t.Errorf("Test %d: Expected Location header to be %q but was %q",
-				i, test.expectedLocation, rec.Header().Get("Location"))
-		}
-
-		if nextCalled && test.expectedLocation != "" {
-			t.Errorf("Test %d: Next handler was unexpectedly called", i)
-		}
-	}
-}

middleware/replacer.go

@@ -1,103 +0,0 @@
-package middleware
-
-import (
-	"net"
-	"net/http"
-	"strconv"
-	"strings"
-	"time"
-)
-
-// Replacer is a type which can replace placeholder
-// substrings in a string with actual values from a
-// http.Request and responseRecorder. Always use
-// NewReplacer to get one of these.
-type Replacer interface {
-	Replace(string) string
-}
-
-type replacer map[string]string
-
-// NewReplacer makes a new replacer based on r and rr.
-// Do not create a new replacer until r and rr have all
-// the needed values, because this function copies those
-// values into the replacer.
-func NewReplacer(r *http.Request, rr *responseRecorder) Replacer {
-	rep := replacer{
-		"{method}": r.Method,
-		"{scheme}": func() string {
-			if r.TLS != nil {
-				return "https"
-			}
-			return "http"
-		}(),
-		"{host}":     r.Host,
-		"{path}":     r.URL.Path,
-		"{query}":    r.URL.RawQuery,
-		"{fragment}": r.URL.Fragment,
-		"{proto}":    r.Proto,
-		"{remote}": func() string {
-			if fwdFor := r.Header.Get("X-Forwarded-For"); fwdFor != "" {
-				return fwdFor
-			}
-			host, _, err := net.SplitHostPort(r.RemoteAddr)
-			if err != nil {
-				return r.RemoteAddr
-			}
-			return host
-		}(),
-		"{port}": func() string {
-			_, port, err := net.SplitHostPort(r.RemoteAddr)
-			if err != nil {
-				return ""
-			}
-			return port
-		}(),
-		"{uri}": r.RequestURI,
-		"{when}": func() string {
-			return time.Now().Format(timeFormat)
-		}(),
-	}
-	if rr != nil {
-		rep["{status}"] = strconv.Itoa(rr.status)
-		rep["{size}"] = strconv.Itoa(rr.size)
-		rep["{latency}"] = time.Since(rr.start).String()
-	}
-
-	// Header placeholders
-	for header, val := range r.Header {
-		rep[headerReplacer+header+"}"] = strings.Join(val, ",")
-	}
-
-	return rep
-}
-
-// Replace performs a replacement of values on s and returns
-// the string with the replaced values.
-func (r replacer) Replace(s string) string {
-	for placeholder, replacement := range r {
-		if replacement == "" {
-			replacement = EmptyStringReplacer
-		}
-		s = strings.Replace(s, placeholder, replacement, -1)
-	}
-
-	// Replace any header placeholders that weren't found
-	for strings.Contains(s, headerReplacer) {
-		idxStart := strings.Index(s, headerReplacer)
-		endOffset := idxStart + len(headerReplacer)
-		idxEnd := strings.Index(s[endOffset:], "}")
-		if idxEnd > -1 {
-			s = s[:idxStart] + EmptyStringReplacer + s[endOffset+idxEnd+1:]
-		} else {
-			break
-		}
-	}
-	return s
-}
-
-const (
-	timeFormat          = "02/Jan/2006:15:04:05 -0700"
-	headerReplacer      = "{>"
-	EmptyStringReplacer = "-"
-)

middleware/rewrite/rewrite.go

@@ -1,194 +0,0 @@
-// Package rewrite is middleware for rewriting requests internally to
-// a different path.
-package rewrite
-
-import (
-	"net/http"
-
-	"fmt"
-	"net/url"
-	"path"
-	"path/filepath"
-	"regexp"
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// Rewrite is middleware to rewrite request locations internally before being handled.
-type Rewrite struct {
-	Next  middleware.Handler
-	Rules []Rule
-}
-
-// ServeHTTP implements the middleware.Handler interface.
-func (rw Rewrite) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	for _, rule := range rw.Rules {
-		if ok := rule.Rewrite(r); ok {
-			break
-		}
-	}
-	return rw.Next.ServeHTTP(w, r)
-}
-
-// Rule describes an internal location rewrite rule.
-type Rule interface {
-	// Rewrite rewrites the internal location of the current request.
-	Rewrite(*http.Request) bool
-}
-
-// SimpleRule is a simple rewrite rule.
-type SimpleRule struct {
-	From, To string
-}
-
-// NewSimpleRule creates a new Simple Rule
-func NewSimpleRule(from, to string) SimpleRule {
-	return SimpleRule{from, to}
-}
-
-// Rewrite rewrites the internal location of the current request.
-func (s SimpleRule) Rewrite(r *http.Request) bool {
-	if s.From == r.URL.Path {
-		r.URL.Path = s.To
-		return true
-	}
-	return false
-}
-
-// RegexpRule is a rewrite rule based on a regular expression
-type RegexpRule struct {
-	// Path base. Request to this path and subpaths will be rewritten
-	Base string
-
-	// Path to rewrite to
-	To string
-
-	// Extensions to filter by
-	Exts []string
-
-	*regexp.Regexp
-}
-
-// NewRegexpRule creates a new RegexpRule. It returns an error if regexp
-// pattern (pattern) or extensions (ext) are invalid.
-func NewRegexpRule(base, pattern, to string, ext []string) (*RegexpRule, error) {
-	r, err := regexp.Compile(pattern)
-	if err != nil {
-		return nil, err
-	}
-
-	// validate extensions
-	for _, v := range ext {
-		if len(v) < 2 || (len(v) < 3 && v[0] == '!') {
-			// check if no extension is specified
-			if v != "/" && v != "!/" {
-				return nil, fmt.Errorf("invalid extension %v", v)
-			}
-		}
-	}
-
-	return &RegexpRule{
-		base,
-		to,
-		ext,
-		r,
-	}, nil
-}
-
-// regexpVars are variables that can be used for To (rewrite destination path).
-var regexpVars = []string{
-	"{path}",
-	"{query}",
-	"{file}",
-	"{dir}",
-	"{frag}",
-}
-
-// Rewrite rewrites the internal location of the current request.
-func (r *RegexpRule) Rewrite(req *http.Request) bool {
-	rPath := req.URL.Path
-
-	// validate base
-	if !middleware.Path(rPath).Matches(r.Base) {
-		return false
-	}
-
-	// validate extensions
-	if !r.matchExt(rPath) {
-		return false
-	}
-
-	// validate regexp
-	if !r.MatchString(rPath[len(r.Base):]) {
-		return false
-	}
-
-	to := r.To
-
-	// check variables
-	for _, v := range regexpVars {
-		if strings.Contains(r.To, v) {
-			switch v {
-			case "{path}":
-				to = strings.Replace(to, v, req.URL.Path[1:], -1)
-			case "{query}":
-				to = strings.Replace(to, v, req.URL.RawQuery, -1)
-			case "{frag}":
-				to = strings.Replace(to, v, req.URL.Fragment, -1)
-			case "{file}":
-				_, file := path.Split(req.URL.Path)
-				to = strings.Replace(to, v, file, -1)
-			case "{dir}":
-				dir, _ := path.Split(req.URL.Path)
-				to = path.Clean(strings.Replace(to, v, dir, -1))
-			}
-		}
-	}
-
-	// validate resulting path
-	url, err := url.Parse(to)
-	if err != nil {
-		return false
-	}
-
-	// perform rewrite
-	req.URL.Path = url.Path
-	if url.RawQuery != "" {
-		// overwrite query string if present
-		req.URL.RawQuery = url.RawQuery
-	}
-	return true
-}
-
-// matchExt matches rPath against registered file extensions.
-// Returns true if a match is found and false otherwise.
-func (r *RegexpRule) matchExt(rPath string) bool {
-	f := filepath.Base(rPath)
-	ext := path.Ext(f)
-	if ext == "" {
-		ext = "/"
-	}
-
-	mustUse := false
-	for _, v := range r.Exts {
-		use := true
-		if v[0] == '!' {
-			use = false
-			v = v[1:]
-		}
-
-		if use {
-			mustUse = true
-		}
-
-		if ext == v {
-			return use
-		}
-	}
-
-	if mustUse {
-		return false
-	}
-	return true
-}

middleware/rewrite/rewrite_test.go

@@ -1,103 +0,0 @@
-package rewrite
-
-import (
-	"fmt"
-	"net/http"
-	"net/http/httptest"
-	"testing"
-
-	"strings"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-func TestRewrite(t *testing.T) {
-	rw := Rewrite{
-		Next: middleware.HandlerFunc(urlPrinter),
-		Rules: []Rule{
-			NewSimpleRule("/from", "/to"),
-			NewSimpleRule("/a", "/b"),
-		},
-	}
-
-	regexpRules := [][]string{
-		[]string{"/reg/", ".*", "/to", ""},
-		[]string{"/r/", "[a-z]+", "/toaz", "!.html|"},
-		[]string{"/url/", "a([a-z0-9]*)s([A-Z]{2})", "/to/{path}", ""},
-		[]string{"/ab/", "ab", "/ab?{query}", ".txt|"},
-		[]string{"/ab/", "ab", "/ab?type=html&{query}", ".html|"},
-		[]string{"/abc/", "ab", "/abc/{file}", ".html|"},
-		[]string{"/abcd/", "ab", "/a/{dir}/{file}", ".html|"},
-		[]string{"/abcde/", "ab", "/a#{frag}", ".html|"},
-		[]string{"/ab/", `.*\.jpg`, "/ajpg", ""},
-	}
-
-	for _, regexpRule := range regexpRules {
-		var ext []string
-		if s := strings.Split(regexpRule[3], "|"); len(s) > 1 {
-			ext = s[:len(s)-1]
-		}
-		rule, err := NewRegexpRule(regexpRule[0], regexpRule[1], regexpRule[2], ext)
-		if err != nil {
-			t.Fatal(err)
-		}
-		rw.Rules = append(rw.Rules, rule)
-	}
-
-	tests := []struct {
-		from       string
-		expectedTo string
-	}{
-		{"/from", "/to"},
-		{"/a", "/b"},
-		{"/aa", "/aa"},
-		{"/", "/"},
-		{"/a?foo=bar", "/b?foo=bar"},
-		{"/asdf?foo=bar", "/asdf?foo=bar"},
-		{"/foo#bar", "/foo#bar"},
-		{"/a#foo", "/b#foo"},
-		{"/reg/foo", "/to"},
-		{"/re", "/re"},
-		{"/r/", "/r/"},
-		{"/r/123", "/r/123"},
-		{"/r/a123", "/toaz"},
-		{"/r/abcz", "/toaz"},
-		{"/r/z", "/toaz"},
-		{"/r/z.html", "/r/z.html"},
-		{"/r/z.js", "/toaz"},
-		{"/url/asAB", "/to/url/asAB"},
-		{"/url/aBsAB", "/url/aBsAB"},
-		{"/url/a00sAB", "/to/url/a00sAB"},
-		{"/url/a0z0sAB", "/to/url/a0z0sAB"},
-		{"/ab/aa", "/ab/aa"},
-		{"/ab/ab", "/ab/ab"},
-		{"/ab/ab.txt", "/ab"},
-		{"/ab/ab.txt?name=name", "/ab?name=name"},
-		{"/ab/ab.html?name=name", "/ab?type=html&name=name"},
-		{"/abc/ab.html", "/abc/ab.html"},
-		{"/abcd/abcd.html", "/a/abcd/abcd.html"},
-		{"/abcde/abcde.html", "/a"},
-		{"/abcde/abcde.html#1234", "/a#1234"},
-		{"/ab/ab.jpg", "/ajpg"},
-	}
-
-	for i, test := range tests {
-		req, err := http.NewRequest("GET", test.from, nil)
-		if err != nil {
-			t.Fatalf("Test %d: Could not create HTTP request: %v", i, err)
-		}
-
-		rec := httptest.NewRecorder()
-		rw.ServeHTTP(rec, req)
-
-		if rec.Body.String() != test.expectedTo {
-			t.Errorf("Test %d: Expected URL to be '%s' but was '%s'",
-				i, test.expectedTo, rec.Body.String())
-		}
-	}
-}
-
-func urlPrinter(w http.ResponseWriter, r *http.Request) (int, error) {
-	fmt.Fprintf(w, r.URL.String())
-	return 0, nil
-}

middleware/templates/context.go

@@ -1,117 +0,0 @@
-package templates
-
-import (
-	"bytes"
-	"io/ioutil"
-	"net"
-	"net/http"
-	"net/url"
-	"text/template"
-	"time"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// This file contains the context and functions available for
-// use in the templates.
-
-// context is the context with which templates are executed.
-type context struct {
-	root http.FileSystem
-	req  *http.Request
-	URL  *url.URL
-}
-
-// Include returns the contents of filename relative to the site root
-func (c context) Include(filename string) (string, error) {
-	file, err := c.root.Open(filename)
-	if err != nil {
-		return "", err
-	}
-	defer file.Close()
-
-	body, err := ioutil.ReadAll(file)
-	if err != nil {
-		return "", err
-	}
-
-	tpl, err := template.New(filename).Parse(string(body))
-	if err != nil {
-		return "", err
-	}
-
-	var buf bytes.Buffer
-	err = tpl.Execute(&buf, c)
-	if err != nil {
-		return "", err
-	}
-
-	return buf.String(), nil
-}
-
-// Date returns the current timestamp in the specified format
-func (c context) Date(format string) string {
-	return time.Now().Format(format)
-}
-
-// Cookie gets the value of a cookie with name name.
-func (c context) Cookie(name string) string {
-	cookies := c.req.Cookies()
-	for _, cookie := range cookies {
-		if cookie.Name == name {
-			return cookie.Value
-		}
-	}
-	return ""
-}
-
-// Header gets the value of a request header with field name.
-func (c context) Header(name string) string {
-	return c.req.Header.Get(name)
-}
-
-// IP gets the (remote) IP address of the client making the request.
-func (c context) IP() string {
-	ip, _, err := net.SplitHostPort(c.req.RemoteAddr)
-	if err != nil {
-		return c.req.RemoteAddr
-	}
-	return ip
-}
-
-// URI returns the raw, unprocessed request URI (including query
-// string and hash) obtained directly from the Request-Line of
-// the HTTP request.
-func (c context) URI() string {
-	return c.req.RequestURI
-}
-
-// Host returns the hostname portion of the Host header
-// from the HTTP request.
-func (c context) Host() (string, error) {
-	host, _, err := net.SplitHostPort(c.req.Host)
-	if err != nil {
-		return "", err
-	}
-	return host, nil
-}
-
-// Port returns the port portion of the Host header if specified.
-func (c context) Port() (string, error) {
-	_, port, err := net.SplitHostPort(c.req.Host)
-	if err != nil {
-		return "", err
-	}
-	return port, nil
-}
-
-// Method returns the method (GET, POST, etc.) of the request.
-func (c context) Method() string {
-	return c.req.Method
-}
-
-// PathMatches returns true if the path portion of the request
-// URL matches pattern.
-func (c context) PathMatches(pattern string) bool {
-	return middleware.Path(c.req.URL.Path).Matches(pattern)
-}

middleware/templates/templates.go

@@ -1,72 +0,0 @@
-// Package templates implements template execution for files to be dynamically rendered for the client.
-package templates
-
-import (
-	"bytes"
-	"net/http"
-	"path"
-	"path/filepath"
-	"text/template"
-
-	"github.com/mholt/caddy/middleware"
-)
-
-// ServeHTTP implements the middleware.Handler interface.
-func (t Templates) ServeHTTP(w http.ResponseWriter, r *http.Request) (int, error) {
-	for _, rule := range t.Rules {
-		if !middleware.Path(r.URL.Path).Matches(rule.Path) {
-			continue
-		}
-
-		// Check for index files
-		fpath := r.URL.Path
-		if idx, ok := middleware.IndexFile(t.FileSys, fpath, rule.IndexFiles); ok {
-			fpath = idx
-		}
-
-		// Check the extension
-		reqExt := path.Ext(fpath)
-
-		for _, ext := range rule.Extensions {
-			if reqExt == ext {
-				// Create execution context
-				ctx := context{root: t.FileSys, req: r, URL: r.URL}
-
-				// Build the template
-				tpl, err := template.ParseFiles(filepath.Join(t.Root, fpath))
-				if err != nil {
-					return http.StatusInternalServerError, err
-				}
-
-				// Execute it
-				var buf bytes.Buffer
-				err = tpl.Execute(&buf, ctx)
-				if err != nil {
-					return http.StatusInternalServerError, err
-				}
-				buf.WriteTo(w)
-
-				return http.StatusOK, nil
-			}
-		}
-	}
-
-	return t.Next.ServeHTTP(w, r)
-}
-
-// Templates is middleware to render templated files as the HTTP response.
-type Templates struct {
-	Next    middleware.Handler
-	Rules   []Rule
-	Root    string
-	FileSys http.FileSystem
-}
-
-// Rule represents a template rule. A template will only execute
-// with this rule if the request path matches the Path specified
-// and requests a resource with one of the extensions specified.
-type Rule struct {
-	Path       string
-	Extensions []string
-	IndexFiles []string
-}