init

at-server/vendor/github.com/vulcand/oxy/utils/auth.go

@@ -0,0 +1,43 @@
+package utils
+
+import (
+	"encoding/base64"
+	"fmt"
+	"strings"
+)
+
+// BasicAuth basic auth information
+type BasicAuth struct {
+	Username string
+	Password string
+}
+
+func (ba *BasicAuth) String() string {
+	encoded := base64.StdEncoding.EncodeToString([]byte(fmt.Sprintf("%s:%s", ba.Username, ba.Password)))
+	return fmt.Sprintf("Basic %s", encoded)
+}
+
+// ParseAuthHeader creates a new BasicAuth from header values
+func ParseAuthHeader(header string) (*BasicAuth, error) {
+	values := strings.Fields(header)
+	if len(values) != 2 {
+		return nil, fmt.Errorf(fmt.Sprintf("Failed to parse header '%s'", header))
+	}
+
+	authType := strings.ToLower(values[0])
+	if authType != "basic" {
+		return nil, fmt.Errorf("Expected basic auth type, got '%s'", authType)
+	}
+
+	encodedString := values[1]
+	decodedString, err := base64.StdEncoding.DecodeString(encodedString)
+	if err != nil {
+		return nil, fmt.Errorf("Failed to parse header '%s', base64 failed: %s", header, err)
+	}
+
+	values = strings.SplitN(string(decodedString), ":", 2)
+	if len(values) != 2 {
+		return nil, fmt.Errorf("Failed to parse header '%s', expected separator ':'", header)
+	}
+	return &BasicAuth{Username: values[0], Password: values[1]}, nil
+}

at-server/vendor/github.com/vulcand/oxy/utils/dumpreq.go

@@ -0,0 +1,64 @@
+package utils
+
+import (
+	"crypto/tls"
+	"encoding/json"
+	"fmt"
+	"mime/multipart"
+	"net/http"
+	"net/url"
+)
+
+// SerializableHttpRequest serializable HTTP request
+type SerializableHttpRequest struct {
+	Method           string
+	URL              *url.URL
+	Proto            string // "HTTP/1.0"
+	ProtoMajor       int    // 1
+	ProtoMinor       int    // 0
+	Header           http.Header
+	ContentLength    int64
+	TransferEncoding []string
+	Host             string
+	Form             url.Values
+	PostForm         url.Values
+	MultipartForm    *multipart.Form
+	Trailer          http.Header
+	RemoteAddr       string
+	RequestURI       string
+	TLS              *tls.ConnectionState
+}
+
+// Clone clone a request
+func Clone(r *http.Request) *SerializableHttpRequest {
+	if r == nil {
+		return nil
+	}
+
+	rc := new(SerializableHttpRequest)
+	rc.Method = r.Method
+	rc.URL = r.URL
+	rc.Proto = r.Proto
+	rc.ProtoMajor = r.ProtoMajor
+	rc.ProtoMinor = r.ProtoMinor
+	rc.Header = r.Header
+	rc.ContentLength = r.ContentLength
+	rc.Host = r.Host
+	rc.RemoteAddr = r.RemoteAddr
+	rc.RequestURI = r.RequestURI
+	return rc
+}
+
+// ToJson serializes to JSON
+func (s *SerializableHttpRequest) ToJson() string {
+	jsonVal, err := json.Marshal(s)
+	if err != nil || jsonVal == nil {
+		return fmt.Sprintf("Error marshalling SerializableHttpRequest to json: %s", err)
+	}
+	return string(jsonVal)
+}
+
+// DumpHttpRequest dump a HTTP request to JSON
+func DumpHttpRequest(req *http.Request) string {
+	return Clone(req).ToJson()
+}

at-server/vendor/github.com/vulcand/oxy/utils/handler.go

@@ -0,0 +1,62 @@
+package utils
+
+import (
+	"context"
+	"io"
+	"net"
+	"net/http"
+
+	log "github.com/sirupsen/logrus"
+)
+
+// StatusClientClosedRequest non-standard HTTP status code for client disconnection
+const StatusClientClosedRequest = 499
+
+// StatusClientClosedRequestText non-standard HTTP status for client disconnection
+const StatusClientClosedRequestText = "Client Closed Request"
+
+// ErrorHandler error handler
+type ErrorHandler interface {
+	ServeHTTP(w http.ResponseWriter, req *http.Request, err error)
+}
+
+// DefaultHandler default error handler
+var DefaultHandler ErrorHandler = &StdHandler{}
+
+// StdHandler Standard error handler
+type StdHandler struct{}
+
+func (e *StdHandler) ServeHTTP(w http.ResponseWriter, req *http.Request, err error) {
+	statusCode := http.StatusInternalServerError
+
+	if e, ok := err.(net.Error); ok {
+		if e.Timeout() {
+			statusCode = http.StatusGatewayTimeout
+		} else {
+			statusCode = http.StatusBadGateway
+		}
+	} else if err == io.EOF {
+		statusCode = http.StatusBadGateway
+	} else if err == context.Canceled {
+		statusCode = StatusClientClosedRequest
+	}
+
+	w.WriteHeader(statusCode)
+	w.Write([]byte(statusText(statusCode)))
+	log.Debugf("'%d %s' caused by: %v", statusCode, statusText(statusCode), err)
+}
+
+func statusText(statusCode int) string {
+	if statusCode == StatusClientClosedRequest {
+		return StatusClientClosedRequestText
+	}
+	return http.StatusText(statusCode)
+}
+
+// ErrorHandlerFunc error handler function type
+type ErrorHandlerFunc func(http.ResponseWriter, *http.Request, error)
+
+// ServeHTTP calls f(w, r).
+func (f ErrorHandlerFunc) ServeHTTP(w http.ResponseWriter, r *http.Request, err error) {
+	f(w, r, err)
+}

at-server/vendor/github.com/vulcand/oxy/utils/netutils.go

@@ -0,0 +1,191 @@
+package utils
+
+import (
+	"bufio"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"reflect"
+
+	log "github.com/sirupsen/logrus"
+)
+
+// ProxyWriter calls recorder, used to debug logs
+type ProxyWriter struct {
+	w      http.ResponseWriter
+	code   int
+	length int64
+
+	log *log.Logger
+}
+
+// NewProxyWriter creates a new ProxyWriter
+func NewProxyWriter(w http.ResponseWriter) *ProxyWriter {
+	return NewProxyWriterWithLogger(w, log.StandardLogger())
+}
+
+// NewProxyWriterWithLogger creates a new ProxyWriter
+func NewProxyWriterWithLogger(w http.ResponseWriter, l *log.Logger) *ProxyWriter {
+	return &ProxyWriter{
+		w:   w,
+		log: l,
+	}
+}
+
+// StatusCode gets status code
+func (p *ProxyWriter) StatusCode() int {
+	if p.code == 0 {
+		// per contract standard lib will set this to http.StatusOK if not set
+		// by user, here we avoid the confusion by mirroring this logic
+		return http.StatusOK
+	}
+	return p.code
+}
+
+// GetLength gets content length
+func (p *ProxyWriter) GetLength() int64 {
+	return p.length
+}
+
+// Header gets response header
+func (p *ProxyWriter) Header() http.Header {
+	return p.w.Header()
+}
+
+func (p *ProxyWriter) Write(buf []byte) (int, error) {
+	p.length = p.length + int64(len(buf))
+	return p.w.Write(buf)
+}
+
+// WriteHeader writes status code
+func (p *ProxyWriter) WriteHeader(code int) {
+	p.code = code
+	p.w.WriteHeader(code)
+}
+
+// Flush flush the writer
+func (p *ProxyWriter) Flush() {
+	if f, ok := p.w.(http.Flusher); ok {
+		f.Flush()
+	}
+}
+
+// CloseNotify returns a channel that receives at most a single value (true)
+// when the client connection has gone away.
+func (p *ProxyWriter) CloseNotify() <-chan bool {
+	if cn, ok := p.w.(http.CloseNotifier); ok {
+		return cn.CloseNotify()
+	}
+	p.log.Debugf("Upstream ResponseWriter of type %v does not implement http.CloseNotifier. Returning dummy channel.", reflect.TypeOf(p.w))
+	return make(<-chan bool)
+}
+
+// Hijack lets the caller take over the connection.
+func (p *ProxyWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	if hi, ok := p.w.(http.Hijacker); ok {
+		return hi.Hijack()
+	}
+	p.log.Debugf("Upstream ResponseWriter of type %v does not implement http.Hijacker. Returning dummy channel.", reflect.TypeOf(p.w))
+	return nil, nil, fmt.Errorf("the response writer that was wrapped in this proxy, does not implement http.Hijacker. It is of type: %v", reflect.TypeOf(p.w))
+}
+
+// NewBufferWriter creates a new BufferWriter
+func NewBufferWriter(w io.WriteCloser) *BufferWriter {
+	return &BufferWriter{
+		W: w,
+		H: make(http.Header),
+	}
+}
+
+// BufferWriter buffer writer
+type BufferWriter struct {
+	H    http.Header
+	Code int
+	W    io.WriteCloser
+}
+
+// Close close the writer
+func (b *BufferWriter) Close() error {
+	return b.W.Close()
+}
+
+// Header gets response header
+func (b *BufferWriter) Header() http.Header {
+	return b.H
+}
+
+func (b *BufferWriter) Write(buf []byte) (int, error) {
+	return b.W.Write(buf)
+}
+
+// WriteHeader writes status code
+func (b *BufferWriter) WriteHeader(code int) {
+	b.Code = code
+}
+
+// CloseNotify returns a channel that receives at most a single value (true)
+// when the client connection has gone away.
+func (b *BufferWriter) CloseNotify() <-chan bool {
+	if cn, ok := b.W.(http.CloseNotifier); ok {
+		return cn.CloseNotify()
+	}
+	log.Warningf("Upstream ResponseWriter of type %v does not implement http.CloseNotifier. Returning dummy channel.", reflect.TypeOf(b.W))
+	return make(<-chan bool)
+}
+
+// Hijack lets the caller take over the connection.
+func (b *BufferWriter) Hijack() (net.Conn, *bufio.ReadWriter, error) {
+	if hi, ok := b.W.(http.Hijacker); ok {
+		return hi.Hijack()
+	}
+	log.Debugf("Upstream ResponseWriter of type %v does not implement http.Hijacker. Returning dummy channel.", reflect.TypeOf(b.W))
+	return nil, nil, fmt.Errorf("the response writer that was wrapped in this proxy, does not implement http.Hijacker. It is of type: %v", reflect.TypeOf(b.W))
+}
+
+type nopWriteCloser struct {
+	io.Writer
+}
+
+func (*nopWriteCloser) Close() error { return nil }
+
+// NopWriteCloser returns a WriteCloser with a no-op Close method wrapping
+// the provided Writer w.
+func NopWriteCloser(w io.Writer) io.WriteCloser {
+	return &nopWriteCloser{Writer: w}
+}
+
+// CopyURL provides update safe copy by avoiding shallow copying User field
+func CopyURL(i *url.URL) *url.URL {
+	out := *i
+	if i.User != nil {
+		out.User = &(*i.User)
+	}
+	return &out
+}
+
+// CopyHeaders copies http headers from source to destination, it
+// does not overide, but adds multiple headers
+func CopyHeaders(dst http.Header, src http.Header) {
+	for k, vv := range src {
+		dst[k] = append(dst[k], vv...)
+	}
+}
+
+// HasHeaders determines whether any of the header names is present in the http headers
+func HasHeaders(names []string, headers http.Header) bool {
+	for _, h := range names {
+		if headers.Get(h) != "" {
+			return true
+		}
+	}
+	return false
+}
+
+// RemoveHeaders removes the header with the given names from the headers map
+func RemoveHeaders(headers http.Header, names ...string) {
+	for _, h := range names {
+		headers.Del(h)
+	}
+}

at-server/vendor/github.com/vulcand/oxy/utils/source.go

@@ -0,0 +1,61 @@
+package utils
+
+import (
+	"fmt"
+	"net/http"
+	"strings"
+)
+
+// SourceExtractor extracts the source from the request, e.g. that may be client ip, or particular header that
+// identifies the source. amount stands for amount of connections the source consumes, usually 1 for connection limiters
+// error should be returned when source can not be identified
+type SourceExtractor interface {
+	Extract(req *http.Request) (token string, amount int64, err error)
+}
+
+// ExtractorFunc extractor function type
+type ExtractorFunc func(req *http.Request) (token string, amount int64, err error)
+
+// Extract extract from request
+func (f ExtractorFunc) Extract(req *http.Request) (string, int64, error) {
+	return f(req)
+}
+
+// ExtractSource extract source function type
+type ExtractSource func(req *http.Request)
+
+// NewExtractor creates a new SourceExtractor
+func NewExtractor(variable string) (SourceExtractor, error) {
+	if variable == "client.ip" {
+		return ExtractorFunc(extractClientIP), nil
+	}
+	if variable == "request.host" {
+		return ExtractorFunc(extractHost), nil
+	}
+	if strings.HasPrefix(variable, "request.header.") {
+		header := strings.TrimPrefix(variable, "request.header.")
+		if len(header) == 0 {
+			return nil, fmt.Errorf("wrong header: %s", header)
+		}
+		return makeHeaderExtractor(header), nil
+	}
+	return nil, fmt.Errorf("unsupported limiting variable: '%s'", variable)
+}
+
+func extractClientIP(req *http.Request) (string, int64, error) {
+	vals := strings.SplitN(req.RemoteAddr, ":", 2)
+	if len(vals[0]) == 0 {
+		return "", 0, fmt.Errorf("failed to parse client IP: %v", req.RemoteAddr)
+	}
+	return vals[0], 1, nil
+}
+
+func extractHost(req *http.Request) (string, int64, error) {
+	return req.Host, 1, nil
+}
+
+func makeHeaderExtractor(header string) SourceExtractor {
+	return ExtractorFunc(func(req *http.Request) (string, int64, error) {
+		return req.Header.Get(header), 1, nil
+	})
+}