Commit a38a2a0e authored by Matthew Holt's avatar Matthew Holt

Created basic fastcgi middleware layer

parent fe1978c6
.DS_Store
Thumbs.db
_gitignore/
Vagrantfile
.vagrant/
error.log
access.log
/*.conf
Caddyfile
......@@ -141,11 +141,19 @@ func (d *dispenser) Err(msg string) middleware.Middleware {
// 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.
func (d *dispenser) Args(targets ...*string) {
for i := 0; i < len(targets) && d.NextArg(); i++ {
// 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
}
// Startup registers a function to execute when the server starts.
......
package middleware
import (
"io"
"io/ioutil"
"log"
"net/http"
"path/filepath"
"strings"
"bitbucket.org/PinIdea/fcgi_client" // TODO: Inline this dependency. It'll need some work.
)
// FastCGI is middleware that acts as a FastCGI client. Requests
// that get forwarded to FastCGI stop the middleware execution
// chain. The most common use for this layer is to serve PHP
// websites with php-fpm.
func FastCGI(p parser) Middleware {
root := p.Root()
var rules []fastCgi
for p.Next() {
rule := fastCgi{}
if !p.Args(&rule.path, &rule.address) {
return p.ArgErr()
}
rules = append(rules, rule)
}
return func(next http.HandlerFunc) http.HandlerFunc {
return func(w http.ResponseWriter, r *http.Request) {
servedFcgi := false
for _, rule := range rules {
if Path(r.URL.Path).Matches(rule.path) {
servedFcgi = true
// Get absolute file paths
absPath, err := filepath.Abs(root + r.URL.Path)
if err != nil {
// TODO!
log.Fatal(err)
}
// Get absolute file paths
absRootPath, err := filepath.Abs(root)
if err != nil {
// TODO!
log.Fatal(err)
}
// Separate remote IP and port
var ip, port string
if idx := strings.Index(r.RemoteAddr, ":"); idx > -1 {
ip = r.RemoteAddr[idx:]
port = r.RemoteAddr[:idx]
} else {
ip = r.RemoteAddr
}
// TODO: Do we really have to make this map from scratch for each request?
env := make(map[string]string)
env["SERVER_SOFTWARE"] = "caddy" // TODO: Obtain version info...
env["SERVER_PROTOCOL"] = r.Proto
env["SCRIPT_FILENAME"] = absPath
env["REMOTE_ADDR"] = ip
env["REMOTE_PORT"] = port
env["REQUEST_METHOD"] = r.Method
env["QUERY_STRING"] = r.URL.RawQuery
env["DOCUMENT_URI"] = r.URL.Path
env["DOCUMENT_ROOT"] = absRootPath
fcgi, err := fcgiclient.Dial("tcp", rule.address)
if err != nil {
// TODO!
}
resp, err := fcgi.Get(env)
if err != nil && err != io.EOF {
// TODO!
}
body, err := ioutil.ReadAll(resp.Body)
if err != nil {
// TODO!
}
for key, vals := range resp.Header {
for _, val := range vals {
w.Header().Add(key, val)
}
}
w.WriteHeader(resp.StatusCode)
w.Write(body)
break
}
}
if !servedFcgi {
next(w, r)
}
}
}
}
type fastCgi struct {
path string
address string
}
......@@ -17,6 +17,7 @@ func init() {
register("rewrite", Rewrite)
register("redir", Redirect)
register("ext", Extensionless)
register("fastcgi", FastCGI)
}
type (
......@@ -37,7 +38,7 @@ type (
NextLine() bool
NextBlock() bool
Val() string
Args(...*string)
Args(...*string) bool
ArgErr() Middleware
Err(string) Middleware
Startup(func() error)
......
Markdown is supported
0%
or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment