falcore

type HandlerFilter ¶

type HandlerFilter struct {
	// contains filtered or unexported fields
}

Implements a RequestFilter using a http.Handler to produce the response This will always return a response due to the requirements of the http.Handler interface so it should be placed at the end of the Upstream pipeline.

func NewHandlerFilter(handler http.Handler) *HandlerFilter

func (h *HandlerFilter) FilterRequest(req *Request) *http.Response

type HostRouter ¶

type HostRouter struct {
	// contains filtered or unexported fields
}

Route requsts based on hostname

func NewHostRouter() *HostRouter

func (r *HostRouter) AddMatch(host string, pipe RequestFilter)

func (r *HostRouter) SelectPipeline(req *Request) (pipe RequestFilter)

type Logger ¶

type Logger interface {
	// Matches the log4go interface
	Finest(arg0 interface{}, args ...interface{})
	Fine(arg0 interface{}, args ...interface{})
	Debug(arg0 interface{}, args ...interface{})
	Trace(arg0 interface{}, args ...interface{})
	Info(arg0 interface{}, args ...interface{})
	Warn(arg0 interface{}, args ...interface{}) error
	Error(arg0 interface{}, args ...interface{}) error
	Critical(arg0 interface{}, args ...interface{}) error
}

I really want to use log4go... but i need to support falling back to standard (shitty) logger :( I suggest using go-timber for the real logger

func NewStdLibLogger() Logger

type MatchAnyRoute ¶

type MatchAnyRoute struct {
	Filter RequestFilter
}

Will match any request. Useful for fallthrough filters.

func (r *MatchAnyRoute) MatchString(str string) RequestFilter

type PathRouter ¶

type PathRouter struct {
	Routes *list.List
}

Route requests based on path

func NewPathRouter() *PathRouter

func (r *PathRouter) AddMatch(match string, filter RequestFilter) (err error)

func (r *PathRouter) AddRoute(route Route)

func (r *PathRouter) SelectPipeline(req *Request) (pipe RequestFilter)

type Pipeline ¶

type Pipeline struct {
	Upstream            *list.List
	Downstream          *list.List
	RequestDoneCallback RequestFilter
}

Pipelines have an upstream and downstream list of filters. A request is passed through the upstream items in order UNTIL a Response is returned. Once a request is returned, it is passed through ALL ResponseFilters in the Downstream list, in order.

If no response is generated by any Filters a default 404 response is returned.

The RequestDoneCallback (if set) will be called after the request has completed. The finished request object will be passed to the FilterRequest method for inspection. Changes to the request will have no effect and the return value is ignored.

func NewPipeline() (l *Pipeline)

func (p *Pipeline) FilterRequest(req *Request) *http.Response

type PipelineStageStat ¶

type PipelineStageStat struct {
	Name      string
	Status    byte
	StartTime time.Time
	EndTime   time.Time
}

Container for keeping stats per pipeline stage Name for filter stages is reflect.TypeOf(filter).String()[1:] and the Status is 0 unless it is changed explicitly in the Filter or Router.

For the Status, the falcore library will not apply any specific meaning to the status codes but the following are suggested conventional usages that we have found useful

  type PipelineStatus byte
  const (
	    Success PipelineStatus = iota	// General Run successfully
	    Skip								// Skipped (all or most of the work of this stage)
	    Fail								// General Fail
	    // All others may be used as custom status codes
  )

func NewPiplineStage(name string) *PipelineStageStat

type RegexpRoute ¶

type RegexpRoute struct {
	Match  *regexp.Regexp
	Filter RequestFilter
}

Will match based on a regular expression

func (r *RegexpRoute) MatchString(str string) RequestFilter

type Request ¶

type Request struct {
	ID                 string
	StartTime          time.Time
	EndTime            time.Time
	HttpRequest        *http.Request
	Connection         net.Conn
	RemoteAddr         *net.TCPAddr
	PipelineStageStats *list.List
	CurrentStage       *PipelineStageStat

	Overhead time.Duration
	Context  map[string]interface{}
	// contains filtered or unexported fields
}

Request wrapper

The request is wrapped so that useful information can be kept with the request as it moves through the pipeline.

A pointer is kept to the originating Connection.

There is a unique ID assigned to each request. This ID is not globally unique to keep it shorter for logging purposes. It is possible to have duplicates though very unlikely over the period of a day or so. It is a good idea to log the ID in any custom log statements so that individual requests can easily be grepped from busy log files.

Falcore collects performance statistics on every stage of the pipeline. The stats for the request are kept in PipelineStageStats. This structure will only be complete in the Request passed to the pipeline RequestDoneCallback. Overhead will only be available in the RequestDoneCallback and it's the difference between the total request time and the sums of the stage times. It will include things like pipeline iteration and the stat collection itself.

See falcore.PipelineStageStat docs for more info.

The Signature is also a cool feature. See the

func TestWithRequest(request *http.Request, filter RequestFilter, context map[string]interface{}) (*Request, *http.Response)

func (fReq *Request) Signature() string

func (fReq *Request) Trace()

type RequestFilter ¶

type RequestFilter interface {
	FilterRequest(req *Request) *http.Response
}

Filter incomming requests and optionally return a response or nil. Filters are chained together into a flow (the Pipeline) which will terminate if the Filter returns a response.

func NewRequestFilter(f func(req *Request) *http.Response) RequestFilter

   filter = NewRequestFilter(func(req *Request) *http.Response {
			req.Headers.Add("X-Falcore", "is_cool")
			return
		})

type ResponseFilter ¶

type ResponseFilter interface {
	FilterResponse(req *Request, res *http.Response)
}

Filter outgoing responses. This can be used to modify the response before it is sent. Modifying the request at this point will have no effect.

func NewResponseFilter(f func(req *Request, res *http.Response)) ResponseFilter

   filter = NewResponseFilter(func(req *Request, res *http.Response) {
			// some crazy response magic
			return
		})

type Route ¶

type Route interface {
	// Returns the route's filter if there's a match.  nil if there isn't
	MatchString(str string) RequestFilter
}

Interface for defining individual routes

type Router ¶

type Router interface {
	// Returns a Pipeline or nil if one can't be found
	SelectPipeline(req *Request) (pipe RequestFilter)
}

Interface for defining routers

func NewRouter(f genericRouter) Router

type Server ¶

type Server struct {
	Addr     string
	Pipeline *Pipeline

	AcceptReady chan int
	// contains filtered or unexported fields
}

func NewServer(port int, pipeline *Pipeline) *Server

func (srv *Server) FdListen(fd int) error

func (srv *Server) ListenAndServe() error

func (srv *Server) ListenAndServeTLS(certFile, keyFile string) error

func (srv *Server) Port() int

func (srv *Server) SocketFd() int

func (srv *Server) StopAccepting()

type StdLibLogger ¶

type StdLibLogger struct{}

This is a simple Logger implementation that uses the go log package for output. It's not really meant for production use since it isn't very configurable. It is a sane default alternative that allows us to not have any external dependencies. Use timber or log4go as a real alternative.

func (fl StdLibLogger) Critical(arg0 interface{}, args ...interface{}) error

func (fl StdLibLogger) Debug(arg0 interface{}, args ...interface{})

func (fl StdLibLogger) Error(arg0 interface{}, args ...interface{}) error

func (fl StdLibLogger) Fine(arg0 interface{}, args ...interface{})

func (fl StdLibLogger) Finest(arg0 interface{}, args ...interface{})

func (fl StdLibLogger) Info(arg0 interface{}, args ...interface{})

func (fl StdLibLogger) Log(lvl level, arg0 interface{}, args ...interface{}) (e error)

func (fl StdLibLogger) Trace(arg0 interface{}, args ...interface{})

func (fl StdLibLogger) Warn(arg0 interface{}, args ...interface{}) error

type StringBody ¶

type StringBody struct {
	BodyBuffer *bytes.Reader
	// contains filtered or unexported fields
}

func (sb *StringBody) Close() error

func (sb *StringBody) Read(b []byte) (n int, err error)

type StringBodyFilter ¶

type StringBodyFilter struct {
	// contains filtered or unexported fields
}

func NewStringBodyFilter() *StringBodyFilter

func (sbf *StringBodyFilter) FilterRequest(request *Request) *http.Response

func (sbf *StringBodyFilter) FilterResponse(request *Request, res *http.Response)

func (sbf *StringBodyFilter) ReturnBuffer(request *Request)