Vendor main dependencies.

vendor/github.com/vulcand/vulcand/plugin/middleware.go

@@ -0,0 +1,146 @@
+package plugin
+
+import (
+	"encoding/json"
+	"fmt"
+	"github.com/codegangsta/cli"
+	"github.com/vulcand/route"
+	"github.com/vulcand/vulcand/conntracker"
+	"github.com/vulcand/vulcand/router"
+	"net/http"
+	"reflect"
+)
+
+// Middleware specification, used to construct new middlewares and plug them into CLI API and backends
+type MiddlewareSpec struct {
+	Type string
+	// Reader function that returns a middleware from another middleware structure
+	FromOther interface{}
+	// Flags for CLI tool to generate interface
+	CliFlags []cli.Flag
+	// Function that construtcs a middleware from CLI parameters
+	FromCli CliReader
+}
+
+func (ms *MiddlewareSpec) FromJSON(data []byte) (Middleware, error) {
+	// Get a function's type
+	fnType := reflect.TypeOf(ms.FromOther)
+
+	// Create a pointer to the function's first argument
+	ptr := reflect.New(fnType.In(0)).Interface()
+	err := json.Unmarshal(data, &ptr)
+	if err != nil {
+		return nil, fmt.Errorf("failed to decode %T from JSON, error: %s", ptr, err)
+	}
+	// Now let's call the function to produce a middleware
+	fnVal := reflect.ValueOf(ms.FromOther)
+	results := fnVal.Call([]reflect.Value{reflect.ValueOf(ptr).Elem()})
+
+	m, out := results[0].Interface(), results[1].Interface()
+	if out != nil {
+		return nil, out.(error)
+	}
+	return m.(Middleware), nil
+}
+
+type Middleware interface {
+	NewHandler(http.Handler) (http.Handler, error)
+}
+
+// Reader constructs the middleware from the CLI interface
+type CliReader func(c *cli.Context) (Middleware, error)
+
+// Function that returns middleware spec by it's type
+type SpecGetter func(string) *MiddlewareSpec
+
+// Registry contains currently registered middlewares and used to support pluggable middlewares across all modules of the vulcand
+type Registry struct {
+	specs       []*MiddlewareSpec
+	notFound    Middleware
+	router      router.Router
+	connTracker conntracker.ConnectionTracker
+}
+
+func NewRegistry() *Registry {
+	return &Registry{
+		specs:  []*MiddlewareSpec{},
+		router: route.NewMux(),
+	}
+}
+
+func (r *Registry) AddSpec(s *MiddlewareSpec) error {
+	if s == nil {
+		return fmt.Errorf("spec can not be nil")
+	}
+	if r.GetSpec(s.Type) != nil {
+		return fmt.Errorf("middleware of type %s already registered", s.Type)
+	}
+	if err := verifySignature(s.FromOther); err != nil {
+		return err
+	}
+	r.specs = append(r.specs, s)
+	return nil
+}
+
+func (r *Registry) GetSpec(middlewareType string) *MiddlewareSpec {
+	for _, s := range r.specs {
+		if s.Type == middlewareType {
+			return s
+		}
+	}
+	return nil
+}
+
+func (r *Registry) GetSpecs() []*MiddlewareSpec {
+	return r.specs
+}
+
+func (r *Registry) AddNotFoundMiddleware(notFound Middleware) error {
+	r.notFound = notFound
+	return nil
+}
+
+func (r *Registry) GetNotFoundMiddleware() Middleware {
+	return r.notFound
+}
+
+func (r *Registry) SetRouter(router router.Router) error {
+	r.router = router
+	return nil
+}
+
+func (r *Registry) GetRouter() router.Router {
+	return r.router
+}
+
+func (r *Registry) SetConnectionTracker(connTracker conntracker.ConnectionTracker) error {
+	r.connTracker = connTracker
+	return nil
+}
+
+func (r *Registry) GetConnectionTracker() conntracker.ConnectionTracker {
+	return r.connTracker
+}
+
+func verifySignature(fn interface{}) error {
+	t := reflect.TypeOf(fn)
+	if t == nil || t.Kind() != reflect.Func {
+		return fmt.Errorf("expected function, got %s", t)
+	}
+	if t.NumIn() != 1 {
+		return fmt.Errorf("expected function with one input argument, got %d", t.NumIn())
+	}
+	if t.In(0).Kind() != reflect.Struct {
+		return fmt.Errorf("function argument should be struct, got %s", t.In(0).Kind())
+	}
+	if t.NumOut() != 2 {
+		return fmt.Errorf("function should return 2 values, got %d", t.NumOut())
+	}
+	if !t.Out(0).AssignableTo(reflect.TypeOf((*Middleware)(nil)).Elem()) {
+		return fmt.Errorf("function first return value should be Middleware got, %s", t.Out(0))
+	}
+	if !t.Out(1).AssignableTo(reflect.TypeOf((*error)(nil)).Elem()) {
+		return fmt.Errorf("function second return value should be error got, %s", t.Out(1))
+	}
+	return nil
+}

vendor/github.com/vulcand/vulcand/plugin/rewrite/rewrite.go

@@ -0,0 +1,206 @@
+package rewrite
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"regexp"
+	"strconv"
+	"strings"
+
+	log "github.com/Sirupsen/logrus"
+	"github.com/codegangsta/cli"
+	"github.com/vulcand/oxy/utils"
+	"github.com/vulcand/vulcand/plugin"
+)
+
+const Type = "rewrite"
+
+type Rewrite struct {
+	Regexp      string
+	Replacement string
+	RewriteBody bool
+	Redirect    bool
+}
+
+func NewRewrite(regex, replacement string, rewriteBody, redirect bool) (*Rewrite, error) {
+	return &Rewrite{regex, replacement, rewriteBody, redirect}, nil
+}
+
+func (rw *Rewrite) NewHandler(next http.Handler) (http.Handler, error) {
+	return newRewriteHandler(next, rw)
+}
+
+func (rw *Rewrite) String() string {
+	return fmt.Sprintf("regexp=%v, replacement=%v, rewriteBody=%v, redirect=%v",
+		rw.Regexp, rw.Replacement, rw.RewriteBody, rw.Redirect)
+}
+
+type rewriteHandler struct {
+	next        http.Handler
+	errHandler  utils.ErrorHandler
+	regexp      *regexp.Regexp
+	replacement string
+	rewriteBody bool
+	redirect    bool
+}
+
+func newRewriteHandler(next http.Handler, spec *Rewrite) (*rewriteHandler, error) {
+	re, err := regexp.Compile(spec.Regexp)
+	if err != nil {
+		return nil, err
+	}
+	return &rewriteHandler{
+		regexp:      re,
+		replacement: spec.Replacement,
+		rewriteBody: spec.RewriteBody,
+		redirect:    spec.Redirect,
+		next:        next,
+		errHandler:  utils.DefaultHandler,
+	}, nil
+}
+
+func (rw *rewriteHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	oldURL := rawURL(req)
+
+	// only continue if the Regexp param matches the URL
+	if !rw.regexp.MatchString(oldURL) {
+		rw.next.ServeHTTP(w, req)
+		return
+	}
+
+	// apply a rewrite regexp to the URL
+	newURL := rw.regexp.ReplaceAllString(oldURL, rw.replacement)
+
+	// replace any variables that may be in there
+	rewrittenURL := &bytes.Buffer{}
+	if err := ApplyString(newURL, rewrittenURL, req); err != nil {
+		rw.errHandler.ServeHTTP(w, req, err)
+		return
+	}
+
+	// parse the rewritten URL and replace request URL with it
+	parsedURL, err := url.Parse(rewrittenURL.String())
+	if err != nil {
+		rw.errHandler.ServeHTTP(w, req, err)
+		return
+	}
+
+	if rw.redirect && newURL != oldURL {
+		(&redirectHandler{u: parsedURL}).ServeHTTP(w, req)
+		return
+	}
+
+	req.URL = parsedURL
+
+	// make sure the request URI corresponds the rewritten URL
+	req.RequestURI = req.URL.RequestURI()
+
+	if !rw.rewriteBody {
+		rw.next.ServeHTTP(w, req)
+		return
+	}
+
+	bw := &bufferWriter{header: make(http.Header), buffer: &bytes.Buffer{}}
+	newBody := &bytes.Buffer{}
+
+	rw.next.ServeHTTP(bw, req)
+
+	if err := Apply(bw.buffer, newBody, req); err != nil {
+		log.Errorf("Failed to rewrite response body: %v", err)
+		return
+	}
+
+	utils.CopyHeaders(w.Header(), bw.Header())
+	w.Header().Set("Content-Length", strconv.Itoa(newBody.Len()))
+	w.WriteHeader(bw.code)
+	io.Copy(w, newBody)
+}
+
+func FromOther(rw Rewrite) (plugin.Middleware, error) {
+	return NewRewrite(rw.Regexp, rw.Replacement, rw.RewriteBody, rw.Redirect)
+}
+
+func FromCli(c *cli.Context) (plugin.Middleware, error) {
+	return NewRewrite(c.String("regexp"), c.String("replacement"), c.Bool("rewriteBody"), c.Bool("redirect"))
+}
+
+func GetSpec() *plugin.MiddlewareSpec {
+	return &plugin.MiddlewareSpec{
+		Type:      Type,
+		FromOther: FromOther,
+		FromCli:   FromCli,
+		CliFlags:  CliFlags(),
+	}
+}
+
+func CliFlags() []cli.Flag {
+	return []cli.Flag{
+		cli.StringFlag{
+			Name:  "regexp",
+			Usage: "regex to match against http request path",
+		},
+		cli.StringFlag{
+			Name:  "replacement",
+			Usage: "replacement text into which regex expansions are inserted",
+		},
+		cli.BoolFlag{
+			Name:  "rewriteBody",
+			Usage: "if provided, response body is treated as as template and all variables in it are replaced",
+		},
+		cli.BoolFlag{
+			Name:  "redirect",
+			Usage: "if provided, request is redirected to the rewritten URL",
+		},
+	}
+}
+
+func rawURL(request *http.Request) string {
+	scheme := "http"
+	if request.TLS != nil || isXForwardedHTTPS(request) {
+		scheme = "https"
+	}
+
+	return strings.Join([]string{scheme, "://", request.Host, request.RequestURI}, "")
+}
+
+func isXForwardedHTTPS(request *http.Request) bool {
+	xForwardedProto := request.Header.Get("X-Forwarded-Proto")
+
+	return len(xForwardedProto) > 0 && xForwardedProto == "https"
+}
+
+type redirectHandler struct {
+	u *url.URL
+}
+
+func (f *redirectHandler) ServeHTTP(w http.ResponseWriter, req *http.Request) {
+	w.Header().Set("Location", f.u.String())
+	w.WriteHeader(http.StatusFound)
+	w.Write([]byte(http.StatusText(http.StatusFound)))
+}
+
+type bufferWriter struct {
+	header http.Header
+	code   int
+	buffer *bytes.Buffer
+}
+
+func (b *bufferWriter) Close() error {
+	return nil
+}
+
+func (b *bufferWriter) Header() http.Header {
+	return b.header
+}
+
+func (b *bufferWriter) Write(buf []byte) (int, error) {
+	return b.buffer.Write(buf)
+}
+
+// WriteHeader sets rw.Code.
+func (b *bufferWriter) WriteHeader(code int) {
+	b.code = code
+}

vendor/github.com/vulcand/vulcand/plugin/rewrite/template.go

@@ -0,0 +1,44 @@
+package rewrite
+
+import (
+	"io"
+	"io/ioutil"
+	"net/http"
+	"text/template"
+)
+
+// data represents template data that is available to use in templates.
+type data struct {
+	Request *http.Request
+}
+
+// Apply reads a template string from the provided reader, applies variables
+// from the provided request object to it and writes the result into
+// the provided writer.
+//
+// Template is standard Go's http://golang.org/pkg/text/template/.
+func Apply(in io.Reader, out io.Writer, request *http.Request) error {
+	body, err := ioutil.ReadAll(in)
+	if err != nil {
+		return err
+	}
+
+	return ApplyString(string(body), out, request)
+}
+
+// ApplyString applies variables from the provided request object to the provided
+// template string and writes the result into the provided writer.
+//
+// Template is standard Go's http://golang.org/pkg/text/template/.
+func ApplyString(in string, out io.Writer, request *http.Request) error {
+	t, err := template.New("t").Parse(in)
+	if err != nil {
+		return err
+	}
+
+	if err = t.Execute(out, data{request}); err != nil {
+		return err
+	}
+
+	return nil
+}