refactor

api/server/apps_create.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"net/http"
@@ -9,7 +9,6 @@ import (
 )
 
 func handleAppCreate(c *gin.Context) {
-	store := c.MustGet("store").(models.Datastore)
 	log := c.MustGet("log").(logrus.FieldLogger)
 
 	wapp := &models.AppWrapper{}
@@ -33,7 +32,7 @@ func handleAppCreate(c *gin.Context) {
 		return
 	}
 
-	app, err := store.StoreApp(wapp.App)
+	app, err := Api.Datastore.StoreApp(wapp.App)
 	if err != nil {
 		log.WithError(err).Debug(models.ErrAppsCreate)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsCreate))

api/server/apps_delete.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"net/http"
@@ -9,11 +9,10 @@ import (
 )
 
 func handleAppDelete(c *gin.Context) {
-	store := c.MustGet("store").(models.Datastore)
 	log := c.MustGet("log").(logrus.FieldLogger)
 
 	appName := c.Param("app")
-	err := store.RemoveApp(appName)
+	err := Api.Datastore.RemoveApp(appName)
 
 	if err != nil {
 		log.WithError(err).Debug(models.ErrAppsRemoving)

api/server/apps_get.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"net/http"
@@ -9,11 +9,10 @@ import (
 )
 
 func handleAppGet(c *gin.Context) {
-	store := c.MustGet("store").(models.Datastore)
 	log := c.MustGet("log").(logrus.FieldLogger)
 
 	appName := c.Param("app")
-	app, err := store.GetApp(appName)
+	app, err := Api.Datastore.GetApp(appName)
 
 	if err != nil {
 		log.WithError(err).Error(models.ErrAppsGet)

api/server/apps_list.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"net/http"
@@ -9,12 +9,11 @@ import (
 )
 
 func handleAppList(c *gin.Context) {
-	store := c.MustGet("store").(models.Datastore)
 	log := c.MustGet("log").(logrus.FieldLogger)
 
 	filter := &models.AppFilter{}
 
-	apps, err := store.GetApps(filter)
+	apps, err := Api.Datastore.GetApps(filter)
 	if err != nil {
 		log.WithError(err).Debug(models.ErrAppsList)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsList))

api/server/apps_test.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"bytes"
@@ -6,12 +6,13 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/iron-io/functions/api/datastore"
 	"github.com/iron-io/functions/api/models"
-	"github.com/iron-io/functions/api/server/datastore"
 )
 
 func TestAppCreate(t *testing.T) {
-	router := testRouter(&datastore.Mock{}, &models.Config{})
+	New(&datastore.Mock{}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path          string
@@ -51,7 +52,8 @@ func TestAppCreate(t *testing.T) {
 }
 
 func TestAppDelete(t *testing.T) {
-	router := testRouter(&datastore.Mock{}, &models.Config{})
+	New(&datastore.Mock{}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path          string
@@ -81,7 +83,8 @@ func TestAppDelete(t *testing.T) {
 }
 
 func TestAppList(t *testing.T) {
-	router := testRouter(&datastore.Mock{}, &models.Config{})
+	New(&datastore.Mock{}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path          string
@@ -110,7 +113,8 @@ func TestAppList(t *testing.T) {
 }
 
 func TestAppGet(t *testing.T) {
-	router := testRouter(&datastore.Mock{}, &models.Config{})
+	New(&datastore.Mock{}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path          string
@@ -139,7 +143,8 @@ func TestAppGet(t *testing.T) {
 }
 
 func TestAppUpdate(t *testing.T) {
-	router := testRouter(&datastore.Mock{}, &models.Config{})
+	New(&datastore.Mock{}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path          string

api/server/apps_update.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"net/http"
@@ -9,7 +9,6 @@ import (
 )
 
 func handleAppUpdate(c *gin.Context) {
-	// store := c.MustGet("store").(models.Datastore)
 	log := c.MustGet("log").(logrus.FieldLogger)
 
 	app := &models.App{}
@@ -33,7 +32,7 @@ func handleAppUpdate(c *gin.Context) {
 		return
 	}
 
-	// app, err := store.StoreApp(wapp.App)
+	// app, err := Api.Datastore.StoreApp(wapp.App)
 	// if err != nil {
 	// 	log.WithError(err).Debug(models.ErrAppsCreate)
 	// 	c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsCreate))

api/server/datastore/bolt/bolt.go

@@ -1,259 +0,0 @@
-package bolt
-
-import (
-	"encoding/json"
-	"net/url"
-	"os"
-	"path/filepath"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/boltdb/bolt"
-	"github.com/iron-io/functions/api/models"
-)
-
-type BoltDatastore struct {
-	routesBucket []byte
-	appsBucket   []byte
-	logsBucket   []byte
-	db           *bolt.DB
-	log          logrus.FieldLogger
-}
-
-func New(url *url.URL) (models.Datastore, error) {
-	dir := filepath.Dir(url.Path)
-	log := logrus.WithFields(logrus.Fields{"db": url.Scheme, "dir": dir})
-	err := os.MkdirAll(dir, 0777)
-	if err != nil {
-		log.WithError(err).Errorln("Could not create data directory for db")
-		return nil, err
-	}
-	log.Infoln("Creating bolt db at ", url.Path)
-	db, err := bolt.Open(url.Path, 0600, nil)
-	if err != nil {
-		log.WithError(err).Errorln("Error on bolt.Open")
-		return nil, err
-	}
-	bucketPrefix := "funcs-"
-	if url.Query()["bucket"] != nil {
-		bucketPrefix = url.Query()["bucket"][0]
-	}
-	routesBucketName := []byte(bucketPrefix + "routes")
-	appsBucketName := []byte(bucketPrefix + "apps")
-	logsBucketName := []byte(bucketPrefix + "logs")
-	err = db.Update(func(tx *bolt.Tx) error {
-		for _, name := range [][]byte{routesBucketName, appsBucketName, logsBucketName} {
-			_, err := tx.CreateBucketIfNotExists(name)
-			if err != nil {
-				log.WithError(err).WithFields(logrus.Fields{"name": name}).Error("create bucket")
-				return err
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		log.WithError(err).Errorln("Error creating bolt buckets")
-		return nil, err
-	}
-
-	ds := &BoltDatastore{
-		routesBucket: routesBucketName,
-		appsBucket:   appsBucketName,
-		logsBucket:   logsBucketName,
-		db:           db,
-		log:          log,
-	}
-	log.WithFields(logrus.Fields{"prefix": bucketPrefix, "file": url.Path}).Info("BoltDB initialized")
-
-	return ds, nil
-}
-
-func (ds *BoltDatastore) StoreApp(app *models.App) (*models.App, error) {
-	err := ds.db.Update(func(tx *bolt.Tx) error {
-		bIm := tx.Bucket(ds.appsBucket)
-		buf, err := json.Marshal(app)
-		if err != nil {
-			return err
-		}
-		err = bIm.Put([]byte(app.Name), buf)
-		if err != nil {
-			return err
-		}
-		bjParent := tx.Bucket(ds.routesBucket)
-		_, err = bjParent.CreateBucketIfNotExists([]byte(app.Name))
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-	return app, err
-}
-
-func (ds *BoltDatastore) RemoveApp(appName string) error {
-	err := ds.db.Update(func(tx *bolt.Tx) error {
-		bIm := tx.Bucket(ds.appsBucket)
-		err := bIm.Delete([]byte(appName))
-		if err != nil {
-			return err
-		}
-		bjParent := tx.Bucket(ds.routesBucket)
-		err = bjParent.DeleteBucket([]byte(appName))
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-	return err
-}
-
-func (ds *BoltDatastore) GetApps(filter *models.AppFilter) ([]*models.App, error) {
-	res := []*models.App{}
-	err := ds.db.View(func(tx *bolt.Tx) error {
-		b := tx.Bucket(ds.appsBucket)
-		err2 := b.ForEach(func(key, v []byte) error {
-			app := &models.App{}
-			err := json.Unmarshal(v, app)
-			if err != nil {
-				return err
-			}
-			res = append(res, app)
-			return nil
-		})
-		if err2 != nil {
-			logrus.WithError(err2).Errorln("Couldn't get apps!")
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return res, nil
-}
-
-func (ds *BoltDatastore) GetApp(name string) (*models.App, error) {
-	var res *models.App
-	err := ds.db.View(func(tx *bolt.Tx) error {
-		b := tx.Bucket(ds.appsBucket)
-		v := b.Get([]byte(name))
-		if v != nil {
-			app := &models.App{}
-			err := json.Unmarshal(v, app)
-			if err != nil {
-				return err
-			}
-			res = app
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return res, nil
-}
-
-func (ds *BoltDatastore) getRouteBucketForApp(tx *bolt.Tx, appName string) (*bolt.Bucket, error) {
-	var err error
-	bp := tx.Bucket(ds.routesBucket)
-	b := bp.Bucket([]byte(appName))
-	if b == nil {
-		b, err = bp.CreateBucket([]byte(appName))
-		if err != nil {
-			return nil, err
-		}
-	}
-	return b, nil
-}
-
-func (ds *BoltDatastore) StoreRoute(route *models.Route) (*models.Route, error) {
-	err := ds.db.Update(func(tx *bolt.Tx) error {
-		b, err := ds.getRouteBucketForApp(tx, route.AppName)
-		if err != nil {
-			return err
-		}
-
-		buf, err := json.Marshal(route)
-		if err != nil {
-			return err
-		}
-
-		err = b.Put([]byte(route.Name), buf)
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return route, nil
-}
-
-func (ds *BoltDatastore) RemoveRoute(appName, routeName string) error {
-	err := ds.db.Update(func(tx *bolt.Tx) error {
-		b, err := ds.getRouteBucketForApp(tx, appName)
-		if err != nil {
-			return err
-		}
-
-		err = b.Delete([]byte(routeName))
-		if err != nil {
-			return err
-		}
-		return nil
-	})
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func (ds *BoltDatastore) GetRoute(appName, routeName string) (*models.Route, error) {
-	var route models.Route
-	err := ds.db.View(func(tx *bolt.Tx) error {
-		b, err := ds.getRouteBucketForApp(tx, appName)
-		if err != nil {
-			return err
-		}
-
-		v := b.Get([]byte(routeName))
-		if v == nil {
-			return models.ErrRoutesNotFound
-		}
-		err = json.Unmarshal(v, &route)
-		return err
-	})
-	return &route, err
-}
-
-func (ds *BoltDatastore) GetRoutes(filter *models.RouteFilter) ([]*models.Route, error) {
-	res := []*models.Route{}
-	err := ds.db.View(func(tx *bolt.Tx) error {
-		b, err := ds.getRouteBucketForApp(tx, filter.AppName)
-		if err != nil {
-			return err
-		}
-
-		i := 0
-		c := b.Cursor()
-
-		var k, v []byte
-		k, v = c.Last()
-
-		// Iterate backwards, newest first
-		for ; k != nil; k, v = c.Prev() {
-			var route models.Route
-			err := json.Unmarshal(v, &route)
-			if err != nil {
-				return err
-			}
-			if models.ApplyRouteFilter(&route, filter) {
-				i++
-				res = append(res, &route)
-			}
-		}
-		return nil
-	})
-	if err != nil {
-		return nil, err
-	}
-	return res, nil
-}

api/server/datastore/datastore.go

@@ -1,27 +0,0 @@
-package datastore
-
-import (
-	"fmt"
-	"net/url"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/iron-io/functions/api/models"
-	"github.com/iron-io/functions/api/server/datastore/bolt"
-	"github.com/iron-io/functions/api/server/datastore/postgres"
-)
-
-func New(dbURL string) (models.Datastore, error) {
-	u, err := url.Parse(dbURL)
-	if err != nil {
-		logrus.WithFields(logrus.Fields{"url": dbURL}).Fatal("bad DB URL")
-	}
-	logrus.WithFields(logrus.Fields{"db": u.Scheme}).Info("creating new datastore")
-	switch u.Scheme {
-	case "bolt":
-		return bolt.New(u)
-	case "postgres":
-		return postgres.New(u)
-	default:
-		return nil, fmt.Errorf("db type not supported %v", u.Scheme)
-	}
-}

api/server/datastore/mock.go

@@ -1,42 +0,0 @@
-package datastore
-
-import "github.com/iron-io/functions/api/models"
-
-type Mock struct {
-	FakeApp    *models.App
-	FakeApps   []*models.App
-	FakeRoute  *models.Route
-	FakeRoutes []*models.Route
-}
-
-func (m *Mock) GetApp(app string) (*models.App, error) {
-	return m.FakeApp, nil
-}
-
-func (m *Mock) GetApps(appFilter *models.AppFilter) ([]*models.App, error) {
-	return m.FakeApps, nil
-}
-
-func (m *Mock) StoreApp(app *models.App) (*models.App, error) {
-	return m.FakeApp, nil
-}
-
-func (m *Mock) RemoveApp(app string) error {
-	return nil
-}
-
-func (m *Mock) GetRoute(app, route string) (*models.Route, error) {
-	return m.FakeRoute, nil
-}
-
-func (m *Mock) GetRoutes(routeFilter *models.RouteFilter) ([]*models.Route, error) {
-	return m.FakeRoutes, nil
-}
-
-func (m *Mock) StoreRoute(route *models.Route) (*models.Route, error) {
-	return m.FakeRoute, nil
-}
-
-func (m *Mock) RemoveRoute(app, route string) error {
-	return nil
-}

api/server/datastore/postgres/postgres.go

@@ -1,278 +0,0 @@
-package postgres
-
-import (
-	"database/sql"
-	"encoding/json"
-	"fmt"
-	"net/url"
-
-	"github.com/Sirupsen/logrus"
-	"github.com/iron-io/functions/api/models"
-	_ "github.com/lib/pq"
-)
-
-const routesTableCreate = `
-CREATE TABLE IF NOT EXISTS routes (
-	name character varying(256) NOT NULL PRIMARY KEY,
-	path text NOT NULL,
-    app_name character varying(256) NOT NULL,
-    image character varying(256) NOT NULL,
-	headers text NOT NULL
-);`
-
-const appsTableCreate = `CREATE TABLE IF NOT EXISTS apps (
-    name character varying(256) NOT NULL PRIMARY KEY
-);`
-
-const routeSelector = `SELECT name, path, app_name, image, headers FROM routes`
-
-type rowScanner interface {
-	Scan(dest ...interface{}) error
-}
-
-type rowQuerier interface {
-	QueryRow(query string, args ...interface{}) *sql.Row
-}
-
-type PostgresDatastore struct {
-	db *sql.DB
-}
-
-func New(url *url.URL) (models.Datastore, error) {
-	db, err := sql.Open("postgres", url.String())
-	if err != nil {
-		return nil, err
-	}
-
-	err = db.Ping()
-	if err != nil {
-		return nil, err
-	}
-
-	maxIdleConns := 30 // c.MaxIdleConnections
-	db.SetMaxIdleConns(maxIdleConns)
-	logrus.WithFields(logrus.Fields{"max_idle_connections": maxIdleConns}).Info("Postgres dialed")
-
-	pg := &PostgresDatastore{
-		db: db,
-	}
-
-	for _, v := range []string{routesTableCreate, appsTableCreate} {
-		_, err = db.Exec(v)
-		if err != nil {
-			return nil, err
-		}
-	}
-
-	return pg, nil
-}
-
-func (ds *PostgresDatastore) StoreApp(app *models.App) (*models.App, error) {
-	_, err := ds.db.Exec(`
-	  INSERT INTO apps (name)
-		VALUES ($1)
-		RETURNING name;
-	`, app.Name)
-
-	if err != nil {
-		return nil, err
-	}
-
-	return app, nil
-}
-
-func (ds *PostgresDatastore) RemoveApp(appName string) error {
-	_, err := ds.db.Exec(`
-	  DELETE FROM apps
-	  WHERE name = $1
-	`, appName)
-
-	if err != nil {
-		return err
-	}
-
-	return nil
-}
-
-func (ds *PostgresDatastore) GetApp(name string) (*models.App, error) {
-	row := ds.db.QueryRow("SELECT name FROM apps WHERE name=$1", name)
-
-	var resName string
-	err := row.Scan(&resName)
-
-	res := &models.App{
-		Name: resName,
-	}
-
-	if err != nil {
-		return nil, err
-	}
-
-	return res, nil
-}
-
-func scanApp(scanner rowScanner, app *models.App) error {
-	err := scanner.Scan(
-		&app.Name,
-	)
-
-	return err
-}
-
-func (ds *PostgresDatastore) GetApps(filter *models.AppFilter) ([]*models.App, error) {
-	res := []*models.App{}
-
-	rows, err := ds.db.Query(`
-		SELECT DISTINCT *
-		FROM apps`,
-	)
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var app models.App
-		err := scanApp(rows, &app)
-
-		if err != nil {
-			return nil, err
-		}
-		res = append(res, &app)
-	}
-
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return res, nil
-}
-
-func (ds *PostgresDatastore) StoreRoute(route *models.Route) (*models.Route, error) {
-	var headers string
-
-	hbyte, err := json.Marshal(route.Headers)
-	if err != nil {
-		return nil, err
-	}
-
-	headers = string(hbyte)
-
-	_, err = ds.db.Exec(`
-		INSERT INTO routes (
-			name, app_name, path, image,
-			headers
-		)
-		VALUES ($1, $2, $3, $4, $5, $6, $7)
-		ON CONFLICT (name) DO UPDATE SET
-			path = $3,
-			image = $4,
-			headers = $5;
-		`,
-		route.Name,
-		route.AppName,
-		route.Path,
-		route.Image,
-		headers,
-	)
-
-	if err != nil {
-		return nil, err
-	}
-	return route, nil
-}
-
-func (ds *PostgresDatastore) RemoveRoute(appName, routeName string) error {
-	_, err := ds.db.Exec(`
-		DELETE FROM routes
-		WHERE name = $1
-	`, routeName)
-
-	if err != nil {
-		return err
-	}
-	return nil
-}
-
-func scanRoute(scanner rowScanner, route *models.Route) error {
-	var headerStr string
-	err := scanner.Scan(
-		&route.Name,
-		&route.Path,
-		&route.AppName,
-		&route.Image,
-		&headerStr,
-	)
-
-	if headerStr == "" {
-		return models.ErrRoutesNotFound
-	}
-
-	err = json.Unmarshal([]byte(headerStr), &route.Headers)
-
-	return err
-}
-
-func getRoute(qr rowQuerier, routeName string) (*models.Route, error) {
-	var route models.Route
-
-	row := qr.QueryRow(fmt.Sprintf("%s WHERE name=$1", routeSelector), routeName)
-	err := scanRoute(row, &route)
-
-	if err == sql.ErrNoRows {
-		return nil, models.ErrRoutesNotFound
-	} else if err != nil {
-		return nil, err
-	}
-	return &route, nil
-}
-
-func (ds *PostgresDatastore) GetRoute(appName, routeName string) (*models.Route, error) {
-	return getRoute(ds.db, routeName)
-}
-
-func (ds *PostgresDatastore) GetRoutes(filter *models.RouteFilter) ([]*models.Route, error) {
-	res := []*models.Route{}
-	filterQuery := buildFilterQuery(filter)
-	rows, err := ds.db.Query(fmt.Sprintf("%s %s", routeSelector, filterQuery))
-	if err != nil {
-		return nil, err
-	}
-	defer rows.Close()
-
-	for rows.Next() {
-		var route models.Route
-		err := scanRoute(rows, &route)
-		if err != nil {
-			return nil, err
-		}
-		res = append(res, &route)
-
-	}
-	if err := rows.Err(); err != nil {
-		return nil, err
-	}
-	return res, nil
-}
-
-func buildFilterQuery(filter *models.RouteFilter) string {
-	filterQuery := ""
-
-	filterQueries := []string{}
-	if filter.Path != "" {
-		filterQueries = append(filterQueries, fmt.Sprintf("path = '%s'", filter.Path))
-	}
-
-	if filter.AppName != "" {
-		filterQueries = append(filterQueries, fmt.Sprintf("app_name = '%s'", filter.AppName))
-	}
-
-	for i, field := range filterQueries {
-		if i == 0 {
-			filterQuery = fmt.Sprintf("WHERE %s ", field)
-		} else {
-			filterQuery = fmt.Sprintf("%s AND %s", filterQuery, field)
-		}
-	}
-
-	return filterQuery
-}

api/server/helpers.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"encoding/json"
@@ -11,30 +11,15 @@ import (
 	"github.com/Sirupsen/logrus"
 	"github.com/gin-gonic/gin"
 	"github.com/iron-io/functions/api/models"
-	"github.com/iron-io/functions/api/server/datastore"
 )
 
-func testRouter(ds models.Datastore, config *models.Config) *gin.Engine {
+func testRouter() *gin.Engine {
 	r := gin.Default()
 	r.Use(func(c *gin.Context) {
-		c.Set("store", ds)
 		c.Set("log", logrus.WithFields(logrus.Fields{}))
-		c.Set("config", config)
 		c.Next()
 	})
-	Start(r)
-	return r
-}
-
-func testRouterWithDefault() *gin.Engine {
-	r := gin.Default()
-	r.Use(func(c *gin.Context) {
-		c.Set("store", &datastore.Mock{})
-		c.Set("log", logrus.WithFields(logrus.Fields{}))
-		c.Set("config", &models.Config{})
-		c.Next()
-	})
-	Start(r)
+	bindHandlers(r)
 	return r
 }
 

api/server/ping.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"net/http"

api/server/router/router.go

@@ -1,38 +0,0 @@
-package router
-
-import (
-	"github.com/gin-gonic/gin"
-	"github.com/iron-io/functions/api/models"
-)
-
-func Start(engine *gin.Engine) {
-	engine.GET("/", handlePing)
-	engine.GET("/version", handleVersion)
-
-	v1 := engine.Group("/v1")
-	{
-		v1.GET("/apps", handleAppList)
-		v1.POST("/apps", handleAppCreate)
-
-		v1.GET("/apps/:app", handleAppGet)
-		v1.PUT("/apps/:app", handleAppUpdate)
-		v1.DELETE("/apps/:app", handleAppDelete)
-
-		apps := v1.Group("/apps/:app")
-		{
-			apps.GET("/routes", handleRouteList)
-			apps.POST("/routes", handleRouteCreate)
-			apps.GET("/routes/:route", handleRouteGet)
-			apps.PUT("/routes/:route", handleRouteUpdate)
-			apps.DELETE("/routes/:route", handleRouteDelete)
-		}
-
-	}
-
-	engine.Any("/r/:app/*route", handleRunner)
-	engine.NoRoute(handleRunner)
-}
-
-func simpleError(err error) *models.Error {
-	return &models.Error{&models.ErrorBody{Message: err.Error()}}
-}

api/server/routes_create.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"net/http"
@@ -9,7 +9,6 @@ import (
 )
 
 func handleRouteCreate(c *gin.Context) {
-	store := c.MustGet("store").(models.Datastore)
 	log := c.MustGet("log").(logrus.FieldLogger)
 
 	var wroute models.RouteWrapper
@@ -35,7 +34,7 @@ func handleRouteCreate(c *gin.Context) {
 		return
 	}
 
-	app, err := store.GetApp(wroute.Route.AppName)
+	app, err := Api.Datastore.GetApp(wroute.Route.AppName)
 	if err != nil {
 		log.WithError(err).Error(models.ErrAppsGet)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsGet))
@@ -49,7 +48,7 @@ func handleRouteCreate(c *gin.Context) {
 			return
 		}
 
-		app, err = store.StoreApp(newapp)
+		app, err = Api.Datastore.StoreApp(newapp)
 		if err != nil {
 			log.WithError(err).Error(models.ErrAppsCreate)
 			c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsCreate))
@@ -57,7 +56,7 @@ func handleRouteCreate(c *gin.Context) {
 		}
 	}
 
-	route, err := store.StoreRoute(wroute.Route)
+	route, err := Api.Datastore.StoreRoute(wroute.Route)
 	if err != nil {
 		log.WithError(err).Error(models.ErrRoutesCreate)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrRoutesCreate))

api/server/routes_delete.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"net/http"
@@ -9,12 +9,11 @@ import (
 )
 
 func handleRouteDelete(c *gin.Context) {
-	store := c.MustGet("store").(models.Datastore)
 	log := c.MustGet("log").(logrus.FieldLogger)
 
 	appName := c.Param("app")
 	routeName := c.Param("route")
-	err := store.RemoveRoute(appName, routeName)
+	err := Api.Datastore.RemoveRoute(appName, routeName)
 
 	if err != nil {
 		log.WithError(err).Debug(models.ErrRoutesRemoving)

api/server/routes_get.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"net/http"
@@ -9,13 +9,12 @@ import (
 )
 
 func handleRouteGet(c *gin.Context) {
-	store := c.MustGet("store").(models.Datastore)
 	log := c.MustGet("log").(logrus.FieldLogger)
 
 	appName := c.Param("app")
 	routeName := c.Param("route")
 
-	route, err := store.GetRoute(appName, routeName)
+	route, err := Api.Datastore.GetRoute(appName, routeName)
 	if err != nil {
 		log.WithError(err).Error(models.ErrRoutesGet)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrRoutesGet))

api/server/routes_list.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"net/http"
@@ -9,7 +9,6 @@ import (
 )
 
 func handleRouteList(c *gin.Context) {
-	store := c.MustGet("store").(models.Datastore)
 	log := c.MustGet("log").(logrus.FieldLogger)
 
 	appName := c.Param("app")
@@ -18,7 +17,7 @@ func handleRouteList(c *gin.Context) {
 		AppName: appName,
 	}
 
-	routes, err := store.GetRoutes(filter)
+	routes, err := Api.Datastore.GetRoutes(filter)
 	if err != nil {
 		log.WithError(err).Error(models.ErrRoutesGet)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrRoutesGet))

api/server/routes_test.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"bytes"
@@ -6,12 +6,13 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/iron-io/functions/api/datastore"
 	"github.com/iron-io/functions/api/models"
-	"github.com/iron-io/functions/api/server/datastore"
 )
 
 func TestRouteCreate(t *testing.T) {
-	router := testRouter(&datastore.Mock{}, &models.Config{})
+	New(&datastore.Mock{}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path          string
@@ -52,7 +53,8 @@ func TestRouteCreate(t *testing.T) {
 }
 
 func TestRouteDelete(t *testing.T) {
-	router := testRouter(&datastore.Mock{}, &models.Config{})
+	New(&datastore.Mock{}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path          string
@@ -82,7 +84,8 @@ func TestRouteDelete(t *testing.T) {
 }
 
 func TestRouteList(t *testing.T) {
-	router := testRouter(&datastore.Mock{}, &models.Config{})
+	New(&datastore.Mock{}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path          string
@@ -111,7 +114,8 @@ func TestRouteList(t *testing.T) {
 }
 
 func TestRouteGet(t *testing.T) {
-	router := testRouter(&datastore.Mock{}, &models.Config{})
+	New(&datastore.Mock{}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path          string
@@ -140,7 +144,8 @@ func TestRouteGet(t *testing.T) {
 }
 
 func TestRouteUpdate(t *testing.T) {
-	router := testRouter(&datastore.Mock{}, &models.Config{})
+	New(&datastore.Mock{}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path          string

api/server/routes_update.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"net/http"
@@ -9,7 +9,6 @@ import (
 )
 
 func handleRouteUpdate(c *gin.Context) {
-	store := c.MustGet("store").(models.Datastore)
 	log := c.MustGet("log").(logrus.FieldLogger)
 
 	var wroute models.RouteWrapper
@@ -36,7 +35,7 @@ func handleRouteUpdate(c *gin.Context) {
 		return
 	}
 
-	route, err := store.StoreRoute(wroute.Route)
+	route, err := Api.Datastore.StoreRoute(wroute.Route)
 	if err != nil {
 		log.WithError(err).Debug(models.ErrAppsCreate)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrAppsCreate))

api/server/runner.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"io/ioutil"
@@ -21,7 +21,6 @@ func handleRunner(c *gin.Context) {
 	}
 
 	log := c.MustGet("log").(logrus.FieldLogger)
-	store := c.MustGet("store").(models.Datastore)
 
 	var err error
 
@@ -64,7 +63,7 @@ func handleRunner(c *gin.Context) {
 
 	log.WithFields(logrus.Fields{"app": appName, "path": route}).Debug("Finding route on datastore")
 
-	routes, err := store.GetRoutes(filter)
+	routes, err := Api.Datastore.GetRoutes(filter)
 	if err != nil {
 		log.WithError(err).Error(models.ErrRoutesList)
 		c.JSON(http.StatusInternalServerError, simpleError(models.ErrRoutesList))

api/server/runner_test.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"bytes"
@@ -6,12 +6,13 @@ import (
 	"strings"
 	"testing"
 
+	"github.com/iron-io/functions/api/datastore"
 	"github.com/iron-io/functions/api/models"
-	"github.com/iron-io/functions/api/server/datastore"
 )
 
 func TestRouteRunnerGet(t *testing.T) {
-	router := testRouter(&datastore.Mock{}, &models.Config{})
+	New(&datastore.Mock{}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path          string
@@ -43,7 +44,8 @@ func TestRouteRunnerGet(t *testing.T) {
 }
 
 func TestRouteRunnerPost(t *testing.T) {
-	router := testRouter(&datastore.Mock{}, &models.Config{})
+	New(&datastore.Mock{}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path          string
@@ -76,12 +78,13 @@ func TestRouteRunnerPost(t *testing.T) {
 }
 
 func TestRouteRunnerExecution(t *testing.T) {
-	router := testRouter(&datastore.Mock{
+	New(&datastore.Mock{
 		FakeRoutes: []*models.Route{
 			{Path: "/myroute", Image: "iron/hello", Headers: map[string][]string{"X-Function": []string{"Test"}}},
 			{Path: "/myerror", Image: "iron/error", Headers: map[string][]string{"X-Function": []string{"Test"}}},
 		},
 	}, &models.Config{})
+	router := testRouter()
 
 	for i, test := range []struct {
 		path            string

api/server/server.go

@@ -1,27 +1,28 @@
-package api
+package server
 
 import (
-	"fmt"
-	"os"
 	"path"
 
 	"github.com/Sirupsen/logrus"
 	"github.com/gin-gonic/gin"
 	"github.com/iron-io/functions/api/models"
-	"github.com/iron-io/functions/api/server/datastore"
-	"github.com/iron-io/functions/api/server/router"
 )
 
+var Api *Server
+
 type Server struct {
-	router *gin.Engine
-	cfg    *models.Config
+	Router    *gin.Engine
+	Config    *models.Config
+	Datastore models.Datastore
 }
 
-func New(config *models.Config) *Server {
-	return &Server{
-		router: gin.Default(),
-		cfg:    config,
+func New(ds models.Datastore, config *models.Config) *Server {
+	Api = &Server{
+		Router:    gin.Default(),
+		Config:    config,
+		Datastore: ds,
 	}
+	return Api
 }
 
 func extractFields(c *gin.Context) logrus.Fields {
@@ -32,33 +33,46 @@ func extractFields(c *gin.Context) logrus.Fields {
 	return fields
 }
 
-func (s *Server) Start() {
-	if s.cfg.DatabaseURL == "" {
-		cwd, _ := os.Getwd()
-		s.cfg.DatabaseURL = fmt.Sprintf("bolt://%s/bolt.db?bucket=funcs", cwd)
-	}
-
-	if s.cfg.API == "" {
-		s.cfg.API = "http://localhost:8080"
-	}
-
-	ds, err := datastore.New(s.cfg.DatabaseURL)
-	if err != nil {
-		logrus.WithError(err).Fatalln("Invalid DB url.")
-	}
-
-	logrus.SetOutput(os.Stdout)
-	logrus.SetLevel(logrus.DebugLevel)
-
-	s.router.Use(func(c *gin.Context) {
-		c.Set("config", s.cfg)
-		c.Set("store", ds)
+func (s *Server) Run() {
+	s.Router.Use(func(c *gin.Context) {
 		c.Set("log", logrus.WithFields(extractFields(c)))
 		c.Next()
 	})
 
-	router.Start(s.router)
+	bindHandlers(s.Router)
 
 	// Default to :8080
-	s.router.Run()
+	s.Router.Run()
+}
+
+func bindHandlers(engine *gin.Engine) {
+	engine.GET("/", handlePing)
+	engine.GET("/version", handleVersion)
+
+	v1 := engine.Group("/v1")
+	{
+		v1.GET("/apps", handleAppList)
+		v1.POST("/apps", handleAppCreate)
+
+		v1.GET("/apps/:app", handleAppGet)
+		v1.PUT("/apps/:app", handleAppUpdate)
+		v1.DELETE("/apps/:app", handleAppDelete)
+
+		apps := v1.Group("/apps/:app")
+		{
+			apps.GET("/routes", handleRouteList)
+			apps.POST("/routes", handleRouteCreate)
+			apps.GET("/routes/:route", handleRouteGet)
+			apps.PUT("/routes/:route", handleRouteUpdate)
+			apps.DELETE("/routes/:route", handleRouteDelete)
+		}
+
+	}
+
+	engine.Any("/r/:app/*route", handleRunner)
+	engine.NoRoute(handleRunner)
+}
+
+func simpleError(err error) *models.Error {
+	return &models.Error{&models.ErrorBody{Message: err.Error()}}
 }

api/server/version.go

@@ -1,4 +1,4 @@
-package router
+package server
 
 import (
 	"net/http"