feat: initial HTTP API. Several refactors. New structure for entities

Author: h2non

README.md

@@ -1,4 +1,4 @@
-# sandbox [![Build Status](https://travis-ci.org/vinxi/sandbox.png)](https://travis-ci.org/vinxi/sandbox) [![GoDoc](https://godoc.org/github.com/vinxi/sandbox?status.svg)](https://godoc.org/github.com/vinxi/sandbox) [![Coverage Status](https://coveralls.io/repos/github/vinxi/sandbox/badge.svg?branch=master)](https://coveralls.io/github/vinxi/sandbox?branch=master) [![Go Report Card](https://goreportcard.com/badge/github.com/vinxi/sandbox)](https://goreportcard.com/report/github.com/vinxi/sandbox)
+# sandbox [![Build Status](https://travis-ci.org/vinxi/sandbox.png)](https://travis-ci.org/vinxi/sandbox) [![GoDoc](https://godoc.org/github.com/vinxi/sandbox?status.svg)](https://godoc.org/github.com/vinxi/sandbox) [![Coverage Status](https://coveralls.io/repos/github/vinxi/sandbox/badge.svg?branch=master)](https://coveralls.io/github/vinxi/sandbox?branch=master) 
 
 Sandbox is a vinxi based full-featured, high-level, remotely configurable proxy solution.
 

_examples/default/default.go

@@ -2,24 +2,37 @@ package main
 
 import (
 	"fmt"
+	"os"
+
 	"gopkg.in/vinxi/sandbox.v0"
+	"gopkg.in/vinxi/sandbox.v0/plugins/static"
+	"gopkg.in/vinxi/sandbox.v0/rules"
 	"gopkg.in/vinxi/vinxi.v0"
 )
 
 const port = 3100
 
 func main() {
+	cwd, _ := os.Getwd()
+
 	// Create a new vinxi proxy
-	vs := vinxi.NewServer(vinxi.ServerOptions{Port: port})
+	v := vinxi.New()
+
+	// Manage current vinxi instance
+	manager := sandbox.Manage(v)
+	scope := manager.NewScope(rules.NewPath("/foo"))
+	scope.UsePlugin(static.New(cwd))
 
-	// Attach the apachelog middleware
-	vs.Use(apachelog.Default)
+	go func() {
+		fmt.Printf("Admin server listening on port: %d\n", port+100)
+		manager.ServeAndListen(sandbox.ServerOptions{Port: port + 100})
+	}()
 
 	// Target server to forward
-	vs.Forward("http://httpbin.org")
+	v.Forward("http://httpbin.org")
 
 	fmt.Printf("Server listening on port: %d\n", port)
-	err := vs.Listen()
+	_, err := v.ServeAndListen(vinxi.ServerOptions{Port: port})
 	if err != nil {
 		fmt.Errorf("Error: %s\n", err)
 	}

interface.go

@@ -1,8 +1,13 @@
 package sandbox
 
 import (
+	"bytes"
+	"encoding/json"
+	"io"
 	"net/http"
 
+	"github.com/bmizerany/pat"
+	"github.com/dchest/uniuri"
 	"gopkg.in/vinxi/layer.v0"
 	"gopkg.in/vinxi/vinxi.v0"
 )
@@ -16,9 +21,10 @@ type Options struct {
 }
 
 type Rule interface {
+	ID() string
 	Name() string
 	Description() string
-	Options() Options
+	// Options() Options
 	JSONConfig() string
 	Match(*http.Request) bool
 }
@@ -28,12 +34,17 @@ type Scope struct {
 	rules    []Rule
 	plugins  *PluginLayer
 
+	ID          string
 	Name        string
 	Description string
 }
 
-func NewScope() *Scope {
-	return &Scope{Plugins: NewPluginLayer()}
+func NewScope(rules ...Rule) *Scope {
+	return &Scope{ID: uniuri.New(), Name: "default", plugins: NewPluginLayer(), rules: rules}
+}
+
+func (s *Scope) UsePlugin(plugin Plugin) {
+	s.plugins.Use(plugin)
 }
 
 func (s *Scope) AddRule(rules ...Rule) {
@@ -52,22 +63,23 @@ func (s *Scope) Enable() {
 	s.disabled = false
 }
 
-func (s *Scope) HandleHTTP(h http.Handler) func(w http.ResponseWriter, req *http.Request) {
-	return func(w http.ResponseWriter, req *http.Request) {
+func (s *Scope) HandleHTTP(h http.Handler) func(http.ResponseWriter, *http.Request) {
+	return func(w http.ResponseWriter, r *http.Request) {
 		if s.disabled {
 			h.ServeHTTP(w, r)
 			return
 		}
 
-		w.WriteHeader(502)
-		w.Write([]byte("bad request"))
-	}
-}
+		for _, rule := range s.rules {
+			if !rule.Match(r) {
+				// Continue
+				h.ServeHTTP(w, r)
+				return
+			}
+		}
 
-func NewInstance(vinxi *vinxi.Vinxi) *Instance {
-	plugins := NewPluginLayer()
-	plugins.Register(vinxi)
-	return &Instance{plugins: plugins, vinxi: vinxi}
+		s.plugins.Run(w, r, h)
+	}
 }
 
 type Manager struct {
@@ -82,17 +94,127 @@ func Manage(instance *vinxi.Vinxi) *Manager {
 	return m
 }
 
-func (a *Manager) HandleHTTP(w http.ResponseWriter, req *http.Request, h http.Handler) {
+func (m *Manager) NewScope(rules ...Rule) *Scope {
+	scope := NewScope(rules...)
+	m.scopes = append(m.scopes, scope)
+	return scope
+}
+
+func (a *Manager) HandleHTTP(w http.ResponseWriter, r *http.Request, h http.Handler) {
 	next := h
 
-	for _, scope := range scopes {
+	for _, scope := range a.scopes {
 		next = http.HandlerFunc(scope.HandleHTTP(next))
 	}
 
 	next.ServeHTTP(w, r)
 }
 
-func (a *Manager) Listen(opts ServerOptions) error {
+type JSONRule struct {
+	ID          string `json:"id"`
+	Name        string `json:"name,omitempty"`
+	Description string `json:"description,omitempty"`
+	Config      string `json:"config,omitempty"`
+}
+
+type JSONPlugin struct {
+	ID          string `json:"id"`
+	Name        string `json:"name,omitempty"`
+	Description string `json:"description,omitempty"`
+	Enabled     bool   `json:"enabled,omitempty"`
+}
+
+type JSONScope struct {
+	ID      string       `json:"id"`
+	Name    string       `json:"name,omitempty"`
+	Rules   []JSONRule   `json:"rules,omitempty"`
+	Plugins []JSONPlugin `json:"plugins,omitempty"`
+}
+
+func (a *Manager) ServeAndListen(opts ServerOptions) (*http.Server, error) {
 	a.Server = NewServer(opts)
-	return server.ListenAndServe()
+
+	m := pat.New()
+	a.Server.Handler = m
+
+	// Define route handlers
+	m.Get("/", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		io.WriteString(w, "vinxi HTTP API manager "+Version)
+	}))
+
+	m.Get("/scopes", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		buf := &bytes.Buffer{}
+		scopes := createScopes(a.scopes)
+
+		err := json.NewEncoder(buf).Encode(scopes)
+		if err != nil {
+			w.WriteHeader(500)
+			w.Write([]byte(err.Error()))
+			return
+		}
+
+		w.Write(buf.Bytes())
+	}))
+
+	m.Get("/scopes/:scope", http.HandlerFunc(func(w http.ResponseWriter, req *http.Request) {
+		id := req.URL.Query().Get(":scope")
+
+		// Find scope by ID
+		for _, scope := range a.scopes {
+			if scope.ID == id {
+				data, err := encodeJSON(createScope(scope))
+				if err != nil {
+					w.WriteHeader(500)
+					w.Write([]byte(err.Error()))
+					return
+				}
+				w.Write(data)
+				return
+			}
+		}
+
+		w.WriteHeader(404)
+		w.Write([]byte("not found"))
+	}))
+
+	return a.Server, Listen(a.Server, opts)
+}
+
+func encodeJSON(data interface{}) ([]byte, error) {
+	buf := &bytes.Buffer{}
+	err := json.NewEncoder(buf).Encode(data)
+	return buf.Bytes(), err
+}
+
+func createScope(scope *Scope) JSONScope {
+	return JSONScope{
+		ID:      scope.ID,
+		Name:    scope.Name,
+		Rules:   createRules(scope),
+		Plugins: createPlugins(scope),
+	}
+}
+
+func createScopes(scopes []*Scope) []JSONScope {
+	buf := make([]JSONScope, len(scopes))
+	for i, scope := range scopes {
+		buf[i] = createScope(scope)
+	}
+	return buf
+}
+
+func createRules(scope *Scope) []JSONRule {
+	rules := make([]JSONRule, len(scope.rules))
+	for i, rule := range scope.rules {
+		rules[i] = JSONRule{ID: rule.ID(), Name: rule.Name(), Description: rule.Description(), Config: rule.JSONConfig()}
+	}
+	return rules
+}
+
+func createPlugins(scope *Scope) []JSONPlugin {
+	plugins := make([]JSONPlugin, scope.plugins.Len())
+	for i, plugin := range scope.plugins.pool {
+		plugins[i] = JSONPlugin{ID: plugin.ID(), Name: plugin.Name(), Description: plugin.Description(), Enabled: plugin.IsEnabled()}
+	}
+	return plugins
 }

manager.go

@@ -3,12 +3,76 @@ package sandbox
 import (
 	"net/http"
 
+	"github.com/dchest/uniuri"
 	"gopkg.in/vinxi/layer.v0"
 )
 
-type Plugin struct {
-	Name        string
-	Description string
+type Handler func(http.Handler) http.Handler
+
+// Plugin represents the required interface implemented by plugins.
+type Plugin interface {
+	// ID is used to retrieve the plugin unique identifier.
+	ID() string
+	// Name is used to retrieve the plugin name identifier.
+	Name() string
+	// Description is used to retrieve a human friendly
+	// description of what the plugin does.
+	Description() string
+	// Enable is used to enable the current plugin.
+	// If the plugin has been already enabled, the call is no-op.
+	Enable()
+	// Disable is used to disable the current plugin.
+	Disable()
+	// Remove is used to disable and remove a plugin.
+	// Remove()
+	// IsEnabled is used to check if a plugin is enabled or not.
+	IsEnabled() bool
+	// HandleHTTP is used to run the plugin task.
+	// Note: add erro reporting layer
+	HandleHTTP(http.Handler) http.Handler
+}
+
+type plugin struct {
+	disabled    bool
+	id          string
+	name        string
+	description string
+	handler     Handler
+}
+
+func NewPlugin(name, description string, handler Handler) Plugin {
+	return &plugin{id: uniuri.New(), name: name, description: description, handler: handler}
+}
+
+func (p *plugin) ID() string {
+	return p.id
+}
+
+func (p *plugin) Name() string {
+	return p.name
+}
+
+func (p *plugin) Description() string {
+	return p.description
+}
+
+func (p *plugin) Disable() {
+	p.disabled = true
+}
+
+func (p *plugin) Enable() {
+	p.disabled = false
+}
+
+func (p *plugin) IsEnabled() bool {
+	return p.disabled == false
+}
+
+func (p *plugin) HandleHTTP(h http.Handler) http.Handler {
+	next := p.handler(h)
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		next.ServeHTTP(w, r)
+	})
 }
 
 // PluginLayer represents a plugins layer designed to intrument
@@ -24,15 +88,24 @@ func NewPluginLayer() *PluginLayer {
 	return &PluginLayer{}
 }
 
+func (l *PluginLayer) Use(plugin Plugin) {
+	l.pool = append(l.pool, plugin)
+}
+
+func (l *PluginLayer) Len() int {
+	return len(l.pool)
+}
+
 // Register implements the middleware Register method.
-func (l *PluginLayer) Register(mw *layer.Middleware) {
-	mw.Use("error", l.run)
-	mw.Use("request", l.run)
+func (l *PluginLayer) Register(mw *layer.Layer) {
+	mw.Use("error", l.Run)
+	mw.Use("request", l.Run)
 }
 
-func (l *PluginLayer) run(h http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// no-op for now
-		h.ServeHTTP(w, r)
-	})
+func (l *PluginLayer) Run(w http.ResponseWriter, r *http.Request, h http.Handler) {
+	next := h
+	for _, plugin := range l.pool {
+		next = plugin.HandleHTTP(next)
+	}
+	next.ServeHTTP(w, r)
 }