Merge pull request #84 from tikazyq/develop

Develop
2026-01-25 17:42:25 +01:00 · 2019-07-28 15:45:00 +08:00
parent 8781f85c8e 4306031e23
commit 391c0a3b27
1015 changed files with 402463 additions and 5740 deletions
--- a/.dockerignore
+++ b/.dockerignore
@@ -1,4 +1,5 @@
 .idea
 logs
 *.log
-node_modules/
+dist/
+**/node_modules/
--- a/.gitignore
+++ b/.gitignore
@@ -16,8 +16,6 @@ dist/
 downloads/
 eggs/
 .eggs/
-lib/
-lib64/
 parts/
 sdist/
 var/
@@ -115,4 +113,10 @@ node_modules/
 .DS_Store

 .docks
-.docs
+.docs
+
+logs/
+tmp/
+_book/
+.idea
+*.lock
--- a/.idea/httpRequests/http-requests-log.http
+++ b/.idea/httpRequests/http-requests-log.http
@@ -1,319 +0,0 @@
-GET http://localhost:5000/api/files?path=/Users/yeqing/projects/crawlab
-Content-Type: application/json
-
-{}
-
-<> 2019-02-17T105049.200.json
-
-###
-
-GET http://localhost:5000/api/files?path=/Users/yeqing/projects/crawlab
-Content-Type: application/json
-
-{}
-
-<> 2019-02-17T105013.200.json
-
-###
-
-GET http://localhost:5000/api/files?path=/Users/yeqing/projects/crawlab-frontend/src
-Content-Type: application/json
-
-{}
-
-<> 2019-02-17T104952.200.json
-
-###
-
-GET http://localhost:5000/api/files?path=/Users/yeqing/projects/crawlab-frontend
-Content-Type: application/json
-
-{}
-
-<> 2019-02-17T104905.200.json
-
-###
-
-GET http://localhost:5000/api/files?path=/Users/yeqing/projects/crawlab-frontend
-Content-Type: application/json
-
-{}
-
-<> 2019-02-17T104843.200.json
-
-###
-
-GET http://localhost:5000/api/files?path=/Users/yeqing/projects/crawlab-frontend
-Content-Type: application/json
-
-{}
-
-<> 2019-02-17T104612.200.json
-
-###
-
-GET http://localhost:5000/api/files?path=/Users/yeqing/projects/crawlab-frontend
-Content-Type: application/json
-
-{}
-
-<> 2019-02-17T104523.400.json
-
-###
-
-GET http://localhost:5000/api/file?path=/Users/yeqing/projects/crawlab-frontend
-Content-Type: application/json
-
-{}
-
-<> 2019-02-17T104518.404.html
-
-###
-
-GET http://localhost:5000/api/file?path=/Users/yeqing/projects/crawlab-frontend
-Content-Type: application/json
-
-{}
-
-<> 2019-02-17T104351.404.html
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "spider_name": "baidu spider",
-  "cmd": "python /Users/yeqing/projects/crawlab/spiders/baidu/baidu.py",
-  "src": "/Users/yeqing/projects/crawlab/spiders/baidu/baidu.py",
-  "spider_type": 1,
-  "lang_type": 1
-}
-
-<> 2019-02-16T044301.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "spider_name": "baidu spider",
-  "cmd": "python /Users/yeqing/projects/crawlab/spiders/baidu/baidu.py",
-  "src": "/Users/yeqing/projects/crawlab/spiders/baidu/baidu.py",
-  "spider_type": 1,
-  "lang_type": 1
-}
-
-<> 2019-02-13T083950.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "spider_name": "baidu spider",
-  "cmd": "/Users/yeqing/projects/crawlab/spiders/baidu/baidu.py",
-  "src": "/Users/yeqing/projects/crawlab/spiders/baidu/baidu.py",
-  "spider_type": 1,
-  "lang_type": 1
-}
-
-<> 2019-02-13T083921.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "spider_name": "baidu spider",
-  "cmd": "/Users/yeqing/projects/crawlab/spiders/baidu/baidu.py",
-  "src": "/Users/yeqing/projects/crawlab/spiders/baidu/baidu.py",
-  "spider_type": 1,
-  "lang_type": 1
-}
-
-###
-
-POST http://localhost:5000/api/spiders/5c63a2ddb65d151bee71d76b/crawl
-Content-Type: application/json
-
-{}
-
-<> 2019-02-13T125947.200.json
-
-###
-
-POST http://localhost:5000/api/spiders/5c63a2ddb65d151bee71d76b/crawl
-Content-Type: application/json
-
-{}
-
-<> 2019-02-13T125918.500.json
-
-###
-
-POST http://localhost:5000/api/spiders/5c63a2ddb65d151bee71d76b/crawl
-Content-Type: application/json
-
-{}
-
-<> 2019-02-13T125714.200.json
-
-###
-
-POST http://localhost:5000/api/spiders/5c63a2ddb65d151bee71d76b
-Content-Type: application/json
-
-{
-  "spider_name": "b spider"
-}
-
-<> 2019-02-13T125635.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "spider_name": "a spider"
-}
-
-<> 2019-02-13T125349.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "spider_name": "a spider"
-}
-
-<> 2019-02-13T125334.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "id": 999,
-  "value": "content"
-}
-
-<> 2019-02-13T125142.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "id": 999,
-  "value": "content"
-}
-
-<> 2019-02-13T125046.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "id": 999,
-  "value": "content"
-}
-
-<> 2019-02-13T124900.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "id": 999,
-  "value": "content"
-}
-
-<> 2019-02-12T010749.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "id": 999,
-  "value": "content"
-}
-
-<> 2019-02-12T010622.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "id": 999,
-  "value": "content"
-}
-
-<> 2019-02-12T010615.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "id": 999,
-  "value": "content"
-}
-
-<> 2019-02-12T010551.200.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "id": 999,
-  "value": "content"
-}
-
-<> 2019-02-12T010511.500.json
-
-###
-
-PUT http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "id": 999,
-  "value": "content"
-}
-
-<> 2019-02-12T010316.405.json
-
-###
-
-POST http://localhost:5000/api/spiders
-Content-Type: application/json
-
-{
-  "id": 999,
-  "value": "content"
-}
-
-<> 2019-02-12T010301.405.json
-
-###
-
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -2,6 +2,7 @@
 ### Features / Enhancement
 - **Documentation**: Better and much more detailed documentation.
 - **Better Crontab**: Make crontab expression through crontab UI.
+- **Better Performance**: Switched from native flask engine to `gunicorn`. [#78](https://github.com/tikazyq/crawlab/issues/78)

 ### Bugs Fixes
 - **Deleting Spider**. Deleting a spider does not only remove record in db but also removing related folder, tasks and schedules. [#69](https://github.com/tikazyq/crawlab/issues/69)
--- a/76
+++ b/76
@@ -1,45 +1,59 @@
+FROM golang:1.12 AS backend-build
+
+WORKDIR /go/src/app
+COPY ./backend .
+
+ENV GO111MODULE on
+ENV GOPROXY https://mirrors.aliyun.com/goproxy/
+
+RUN go install -v ./...
+
+FROM node:8.16.0-alpine AS frontend-build
+
+ADD ./frontend /app
+WORKDIR /app
+
+# install frontend
+RUN npm install -g yarn && yarn install --registry=https://registry.npm.taobao.org
+
+RUN npm run build:prod
+
 # images
 FROM ubuntu:latest

-# source files
-ADD . /opt/crawlab
+ADD . /app

 # set as non-interactive
 ENV DEBIAN_FRONTEND noninteractive

-# environment variables
-ENV NVM_DIR /usr/local/nvm  
-ENV NODE_VERSION 8.12.0
-ENV WORK_DIR /opt/crawlab
-
-# install pkg
+# install packages
 RUN apt-get update \
-	&& apt-get install -y curl git net-tools iputils-ping ntp nginx python3 python3-pip \
-	&& apt-get clean \
-	&& cp $WORK_DIR/crawlab.conf /etc/nginx/conf.d \
+	&& apt-get install -y curl git net-tools iputils-ping ntp ntpdate python3 python3-pip \
 	&& ln -s /usr/bin/pip3 /usr/local/bin/pip \
 	&& ln -s /usr/bin/python3 /usr/local/bin/python

-# install nvm
-RUN curl https://raw.githubusercontent.com/creationix/nvm/v0.24.0/install.sh | bash \  
-    && . $NVM_DIR/nvm.sh \
-    && nvm install v$NODE_VERSION \
-    && nvm use v$NODE_VERSION \
-    && nvm alias default v$NODE_VERSION
-ENV NODE_PATH $NVM_DIR/versions/node/v$NODE_VERSION/lib/node_modules  
-ENV PATH $NVM_DIR/versions/node/v$NODE_VERSION/bin:$PATH
-
-# install frontend
-RUN npm install -g yarn \
-	&& cd /opt/crawlab/frontend \
-	&& yarn install
-
 # install backend
-RUN pip install -U setuptools -i https://pypi.tuna.tsinghua.edu.cn/simple \
-	&& pip install -r /opt/crawlab/crawlab/requirements.txt -i https://pypi.tuna.tsinghua.edu.cn/simple
+RUN pip install scrapy pymongo bs4 requests -i https://pypi.tuna.tsinghua.edu.cn/simple
+
+# copy backend files
+COPY --from=backend-build /go/src/app .
+COPY --from=backend-build /go/bin/crawlab /usr/local/bin
+
+# install nginx
+RUN apt-get -y install nginx
+
+# copy frontend files
+COPY --from=frontend-build /app/dist /app/dist
+COPY --from=frontend-build /app/conf/crawlab.conf /etc/nginx/conf.d
+
+# working directory
+WORKDIR /app/backend
+
+# frontend port
+EXPOSE 8080
+
+# backend port
+EXPOSE 8000

 # start backend
-EXPOSE 8080
-EXPOSE 8000
-WORKDIR /opt/crawlab
-ENTRYPOINT ["/bin/sh", "/opt/crawlab/docker_init.sh"]
+CMD ["/bin/sh", "/app/docker_init.sh"]
--- a/backend/Dockerfile
+++ b/backend/Dockerfile
@@ -0,0 +1,18 @@
+FROM golang:1.12-alpine AS build
+
+WORKDIR /go/src/app
+COPY . .
+
+ENV GO111MODULE on
+ENV GOPROXY https://mirrors.aliyun.com/goproxy/
+
+RUN go mod vendor
+RUN go install -v ./...
+
+FROM alpine:latest
+WORKDIR /root
+COPY --from=build /go/src/app .
+COPY --from=build /go/bin/crawlab /usr/local/bin
+
+EXPOSE 8000
+CMD ["crawlab"]
--- a/backend/Makefile
+++ b/backend/Makefile
@@ -0,0 +1,32 @@
+SHELL := /bin/bash
+BASEDIR = $(shell pwd)
+
+# build with verison infos
+versionDir = "apiserver/pkg/version"
+gitTag = $(shell if [ "`git describe --tags --abbrev=0 2>/dev/null`" != "" ];then git describe --tags --abbrev=0; else git log --pretty=format:'%h' -n 1; fi)
+buildDate = $(shell TZ=Asia/Shanghai date +%FT%T%z)
+gitCommit = $(shell git log --pretty=format:'%H' -n 1)
+gitTreeState = $(shell if git status|grep -q 'clean';then echo clean; else echo dirty; fi)
+
+ldflags="-w -X ${versionDir}.gitTag=${gitTag} -X ${versionDir}.buildDate=${buildDate} -X ${versionDir}.gitCommit=${gitCommit} -X ${versionDir}.gitTreeState=${gitTreeState}"
+
+all: gotool
+	@go build -v -ldflags ${ldflags} .
+clean:
+	rm -f apiserver
+	find . -name "[._]*.s[a-w][a-z]" | xargs -i rm -f {}
+gotool:
+	gofmt -w .
+	go tool vet . |& grep -v vendor;true
+ca:
+	openssl req -new -nodes -x509 -out conf/server.crt -keyout conf/server.key -days 3650 -subj "/C=DE/ST=NRW/L=Earth/O=Random Company/OU=IT/CN=127.0.0.1/emailAddress=xxxxx@qq.com"
+
+help:
+	@echo "make - compile the source code"
+	@echo "make clean - remove binary file and vim swp files"
+	@echo "make gotool - run go tool 'fmt' and 'vet'"
+	@echo "make ca - generate ca files"
+
+.PHONY: clean gotool ca help
+
+
--- a/backend/README.md
+++ b/backend/README.md
@@ -0,0 +1,3 @@
+# crawlab-backend
+
+Backend (Golang) for Crawlab
--- a/backend/conf/config.yml
+++ b/backend/conf/config.yml
@@ -0,0 +1,25 @@
+api:
+  address: "localhost:8000"
+mongo:
+  host: localhost
+  port: 27017
+  db: crawlab_test
+  username: ""
+  password: ""
+redis:
+  network: tcp
+  address: "localhost:6379"
+log:
+  level: info
+  path: "/var/logs/crawlab"
+server:
+  host: 0.0.0.0
+  port: 8000
+  master: "N"
+  secret: "crawlab"
+spider:
+  path: "/app/spiders"
+task:
+  workers: 4
+other:
+  tmppath: "/tmp"
--- a/backend/config/config.go
+++ b/backend/config/config.go
@@ -0,0 +1,55 @@
+package config
+
+import (
+	"github.com/fsnotify/fsnotify"
+	"github.com/spf13/viper"
+	"log"
+	"strings"
+)
+
+type Config struct {
+	Name string
+}
+
+// 监控配置文件变化并热加载程序
+func (c *Config) WatchConfig() {
+	viper.WatchConfig()
+	viper.OnConfigChange(func(e fsnotify.Event) {
+		log.Printf("Config file changed: %s", e.Name)
+	})
+}
+
+func (c *Config) Init() error {
+	if c.Name != "" {
+		viper.SetConfigFile(c.Name) // 如果指定了配置文件，则解析指定的配置文件
+	} else {
+		viper.AddConfigPath("./conf") // 如果没有指定配置文件，则解析默认的配置文件
+		viper.SetConfigName("config")
+	}
+	viper.SetConfigType("yaml")   // 设置配置文件格式为YAML
+	viper.AutomaticEnv()          // 读取匹配的环境变量
+	viper.SetEnvPrefix("CRAWLAB") // 读取环境变量的前缀为APISERVER
+	replacer := strings.NewReplacer(".", "_")
+	viper.SetEnvKeyReplacer(replacer)
+	if err := viper.ReadInConfig(); err != nil { // viper解析配置文件
+		return err
+	}
+
+	return nil
+}
+
+func InitConfig(cfg string) error {
+	c := Config{
+		Name: cfg,
+	}
+
+	// 初始化配置文件
+	if err := c.Init(); err != nil {
+		return err
+	}
+
+	// 监控配置文件变化并热加载程序
+	c.WatchConfig()
+
+	return nil
+}
--- a/backend/constants/message.go
+++ b/backend/constants/message.go
@@ -0,0 +1,7 @@
+package constants
+
+const (
+	MsgTypeGetLog        = "get-log"
+	MsgTypeGetSystemInfo = "get-sys-info"
+	MsgTypeCancelTask    = "cancel-task"
+)
--- a/backend/constants/model.go
+++ b/backend/constants/model.go
@@ -0,0 +1,6 @@
+package constants
+
+const (
+	ObjectIdNull = "000000000000000000000000"
+	Infinite     = 999999999
+)
--- a/backend/constants/node.go
+++ b/backend/constants/node.go
@@ -0,0 +1,6 @@
+package constants
+
+const (
+	StatusOnline  = "online"
+	StatusOffline = "offline"
+)
--- a/backend/constants/spider.go
+++ b/backend/constants/spider.go
@@ -0,0 +1,6 @@
+package constants
+
+const (
+	Customized   = "customized"
+	Configurable = "configurable"
+)
--- a/backend/constants/system.go
+++ b/backend/constants/system.go
@@ -0,0 +1,7 @@
+package constants
+
+const (
+	Windows = "windows"
+	Linux   = "linux"
+	Darwin  = "darwin"
+)
--- a/backend/constants/task.go
+++ b/backend/constants/task.go
@@ -0,0 +1,14 @@
+package constants
+
+const (
+	StatusPending   string = "pending"
+	StatusRunning   string = "running"
+	StatusFinished  string = "finished"
+	StatusError     string = "error"
+	StatusCancelled string = "cancelled"
+)
+
+const (
+	TaskFinish string = "finish"
+	TaskCancel string = "cancel"
+)
--- a/backend/constants/user.go
+++ b/backend/constants/user.go
@@ -0,0 +1,6 @@
+package constants
+
+const (
+	RoleAdmin  = "admin"
+	RoleNormal = "normal"
+)
--- a/backend/database/mongo.go
+++ b/backend/database/mongo.go
@@ -0,0 +1,45 @@
+package database
+
+import (
+	"github.com/globalsign/mgo"
+	"github.com/spf13/viper"
+)
+
+var Session *mgo.Session
+
+func GetSession() *mgo.Session {
+	return Session.Copy()
+}
+
+func GetDb() (*mgo.Session, *mgo.Database) {
+	s := GetSession()
+	return s, s.DB(viper.GetString("mongo.db"))
+}
+
+func GetCol(collectionName string) (*mgo.Session, *mgo.Collection) {
+	s := GetSession()
+	db := s.DB(viper.GetString("mongo.db"))
+	col := db.C(collectionName)
+	return s, col
+}
+
+func GetGridFs(prefix string) (*mgo.Session, *mgo.GridFS) {
+	s, db := GetDb()
+	gf := db.GridFS(prefix)
+	return s, gf
+}
+
+func InitMongo() error {
+	var mongoHost = viper.GetString("mongo.host")
+	var mongoPort = viper.GetString("mongo.port")
+	var mongoDb = viper.GetString("mongo.db")
+
+	if Session == nil {
+		sess, err := mgo.Dial("mongodb://" + mongoHost + ":" + mongoPort + "/" + mongoDb)
+		if err != nil {
+			return err
+		}
+		Session = sess
+	}
+	return nil
+}
--- a/backend/database/pubsub.go
+++ b/backend/database/pubsub.go
@@ -0,0 +1,72 @@
+package database
+
+import (
+	"fmt"
+	"github.com/apex/log"
+	"github.com/gomodule/redigo/redis"
+	"unsafe"
+)
+
+type SubscribeCallback func(channel, message string)
+
+type Subscriber struct {
+	client redis.PubSubConn
+	cbMap  map[string]SubscribeCallback
+}
+
+func (c *Subscriber) Connect() {
+	conn, err := GetRedisConn()
+	if err != nil {
+		log.Fatalf("redis dial failed.")
+	}
+
+	c.client = redis.PubSubConn{Conn: conn}
+	c.cbMap = make(map[string]SubscribeCallback)
+
+	go func() {
+		for {
+			log.Debug("wait...")
+			switch res := c.client.Receive().(type) {
+			case redis.Message:
+				channel := (*string)(unsafe.Pointer(&res.Channel))
+				message := (*string)(unsafe.Pointer(&res.Data))
+				c.cbMap[*channel](*channel, *message)
+			case redis.Subscription:
+				fmt.Printf("%s: %s %d\n", res.Channel, res.Kind, res.Count)
+			case error:
+				log.Error("error handle...")
+				continue
+			}
+		}
+	}()
+
+}
+
+func (c *Subscriber) Close() {
+	err := c.client.Close()
+	if err != nil {
+		log.Errorf("redis close error.")
+	}
+}
+
+func (c *Subscriber) Subscribe(channel interface{}, cb SubscribeCallback) {
+	err := c.client.Subscribe(channel)
+	if err != nil {
+		log.Fatalf("redis Subscribe error.")
+	}
+
+	c.cbMap[channel.(string)] = cb
+}
+
+func Publish(channel string, msg string) error {
+	c, err := GetRedisConn()
+	if err != nil {
+		return err
+	}
+
+	if _, err := c.Do("PUBLISH", channel, msg); err != nil {
+		return err
+	}
+
+	return nil
+}
--- a/backend/database/redis.go
+++ b/backend/database/redis.go
@@ -0,0 +1,119 @@
+package database
+
+import (
+	"github.com/gomodule/redigo/redis"
+	"github.com/spf13/viper"
+	"runtime/debug"
+)
+
+var RedisClient = Redis{}
+
+type ConsumeFunc func(channel string, message []byte) error
+
+type Redis struct {
+}
+
+func (r *Redis) RPush(collection string, value interface{}) error {
+	c, err := GetRedisConn()
+	if err != nil {
+		debug.PrintStack()
+		return err
+	}
+	defer c.Close()
+
+	if _, err := c.Do("RPUSH", collection, value); err != nil {
+		debug.PrintStack()
+		return err
+	}
+	return nil
+}
+
+func (r *Redis) LPop(collection string) (string, error) {
+	c, err := GetRedisConn()
+	if err != nil {
+		debug.PrintStack()
+		return "", err
+	}
+	defer c.Close()
+
+	value, err2 := redis.String(c.Do("LPOP", collection))
+	if err2 != nil {
+		return value, err2
+	}
+	return value, nil
+}
+
+func (r *Redis) HSet(collection string, key string, value string) error {
+	c, err := GetRedisConn()
+	if err != nil {
+		debug.PrintStack()
+		return err
+	}
+	defer c.Close()
+
+	if _, err := c.Do("HSET", collection, key, value); err != nil {
+		debug.PrintStack()
+		return err
+	}
+	return nil
+}
+
+func (r *Redis) HGet(collection string, key string) (string, error) {
+	c, err := GetRedisConn()
+	if err != nil {
+		debug.PrintStack()
+		return "", err
+	}
+	defer c.Close()
+
+	value, err2 := redis.String(c.Do("HGET", collection, key))
+	if err2 != nil {
+		return value, err2
+	}
+	return value, nil
+}
+
+func (r *Redis) HDel(collection string, key string) error {
+	c, err := GetRedisConn()
+	if err != nil {
+		debug.PrintStack()
+		return err
+	}
+	defer c.Close()
+
+	if _, err := c.Do("HDEL", collection, key); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (r *Redis) HKeys(collection string) ([]string, error) {
+	c, err := GetRedisConn()
+	if err != nil {
+		debug.PrintStack()
+		return []string{}, err
+	}
+	defer c.Close()
+
+	value, err2 := redis.Strings(c.Do("HKeys", collection))
+	if err2 != nil {
+		return []string{}, err2
+	}
+	return value, nil
+}
+
+func GetRedisConn() (redis.Conn, error) {
+	c, err := redis.Dial(
+		viper.GetString("redis.network"),
+		viper.GetString("redis.address"),
+	)
+	if err != nil {
+		debug.PrintStack()
+		return c, err
+	}
+	return c, nil
+}
+
+func InitRedis() error {
+	return nil
+}
--- a/backend/dump.rdb
+++ b/backend/dump.rdb
--- a/backend/go.mod
+++ b/backend/go.mod
@@ -0,0 +1,15 @@
+module crawlab
+
+go 1.12
+
+require (
+	github.com/apex/log v1.1.1
+	github.com/dgrijalva/jwt-go v3.2.0+incompatible
+	github.com/fsnotify/fsnotify v1.4.7
+	github.com/gin-gonic/gin v1.4.0
+	github.com/globalsign/mgo v0.0.0-20181015135952-eeefdecb41b8
+	github.com/gomodule/redigo v2.0.0+incompatible
+	github.com/pkg/errors v0.8.1
+	github.com/satori/go.uuid v1.2.0
+	github.com/spf13/viper v1.4.0
+)
--- a/backend/go.sum
+++ b/backend/go.sum
@@ -0,0 +1,206 @@
+cloud.google.com/go v0.26.0/go.mod h1:aQUYkXzVsufM+DwF1aE+0xfcU+56JwCaLick0ClmMTw=
+github.com/BurntSushi/toml v0.3.1 h1:WXkYYl6Yr3qBf1K79EBnL4mak0OimBfB0XUf9Vl28OQ=
+github.com/BurntSushi/toml v0.3.1/go.mod h1:xHWCNGjB5oqiDr8zfno3MHue2Ht5sIBksp03qcyfWMU=
+github.com/OneOfOne/xxhash v1.2.2/go.mod h1:HSdplMjZKSmBqAxg5vPj2TmRDmfkzw+cTzAElWljhcU=
+github.com/alecthomas/template v0.0.0-20160405071501-a0175ee3bccc/go.mod h1:LOuyumcjzFXgccqObfd/Ljyb9UuFJ6TxHnclSeseNhc=
+github.com/alecthomas/units v0.0.0-20151022065526-2efee857e7cf/go.mod h1:ybxpYRFXyAe+OPACYpWeL0wqObRcbAqCMya13uyzqw0=
+github.com/apex/log v1.1.1 h1:BwhRZ0qbjYtTob0I+2M+smavV0kOC8XgcnGZcyL9liA=
+github.com/apex/log v1.1.1/go.mod h1:Ls949n1HFtXfbDcjiTTFQqkVUrte0puoIBfO3SVgwOA=
+github.com/aphistic/golf v0.0.0-20180712155816-02c07f170c5a/go.mod h1:3NqKYiepwy8kCu4PNA+aP7WUV72eXWJeP9/r3/K9aLE=
+github.com/aphistic/sweet v0.2.0/go.mod h1:fWDlIh/isSE9n6EPsRmC0det+whmX6dJid3stzu0Xys=
+github.com/armon/consul-api v0.0.0-20180202201655-eb2c6b5be1b6/go.mod h1:grANhF5doyWs3UAsr3K4I6qtAmlQcZDesFNEHPZAzj8=
+github.com/aws/aws-sdk-go v1.20.6/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
+github.com/aybabtme/rgbterm v0.0.0-20170906152045-cc83f3b3ce59/go.mod h1:q/89r3U2H7sSsE2t6Kca0lfwTK8JdoNGS/yzM/4iH5I=
+github.com/beorn7/perks v0.0.0-20180321164747-3a771d992973/go.mod h1:Dwedo/Wpr24TaqPxmxbtue+5NUziq4I4S80YR8gNf3Q=
+github.com/beorn7/perks v1.0.0/go.mod h1:KWe93zE9D1o94FZ5RNwFwVgaQK1VOXiVxmqh+CedLV8=
+github.com/cespare/xxhash v1.1.0/go.mod h1:XrSqR1VqqWfGrhpAt58auRo0WTKS1nRRg3ghfAqPWnc=
+github.com/client9/misspell v0.3.4/go.mod h1:qj6jICC3Q7zFZvVWo7KLAzC3yx5G7kyvSDkc90ppPyw=
+github.com/coreos/bbolt v1.3.2/go.mod h1:iRUV2dpdMOn7Bo10OQBFzIJO9kkE559Wcmn+qkEiiKk=
+github.com/coreos/etcd v3.3.10+incompatible/go.mod h1:uF7uidLiAD3TWHmW31ZFd/JWoc32PjwdhPthX9715RE=
+github.com/coreos/go-semver v0.2.0/go.mod h1:nnelYz7RCh+5ahJtPPxZlU+153eP4D4r3EedlOD2RNk=
+github.com/coreos/go-systemd v0.0.0-20190321100706-95778dfbb74e/go.mod h1:F5haX7vjVVG0kc13fIWeqUViNPyEJxv/OmvnBo0Yme4=
+github.com/coreos/pkg v0.0.0-20180928190104-399ea9e2e55f/go.mod h1:E3G3o1h8I7cfcXa63jLwjI0eiQQMgzzUDFVpN/nH/eA=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/davecgh/go-spew v1.1.1 h1:vj9j/u1bqnvCEfJOwUhtlOARqs3+rkHYY13jYWTU97c=
+github.com/davecgh/go-spew v1.1.1/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible h1:7qlOGliEKZXTDg6OTjfoBKDXWrumCAMpl/TFQ4/5kLM=
+github.com/dgrijalva/jwt-go v3.2.0+incompatible/go.mod h1:E3ru+11k8xSBh+hMPgOLZmtrrCbhqsmaPHjLKYnJCaQ=
+github.com/dgryski/go-sip13 v0.0.0-20181026042036-e10d5fee7954/go.mod h1:vAd38F8PWV+bWy6jNmig1y/TA+kYO4g3RSRF0IAv0no=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
+github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/ghodss/yaml v1.0.0/go.mod h1:4dBDuWmgqj2HViK6kFavaiC9ZROes6MMH2rRYeMEF04=
+github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3 h1:t8FVkw33L+wilf2QiWkw0UV77qRpcH/JHPKGpKa2E8g=
+github.com/gin-contrib/sse v0.0.0-20190301062529-5545eab6dad3/go.mod h1:VJ0WA2NBN22VlZ2dKZQPAPnyWw5XTlK1KymzLKsr59s=
+github.com/gin-gonic/gin v1.4.0 h1:3tMoCCfM7ppqsR0ptz/wi1impNpT7/9wQtMZ8lr1mCQ=
+github.com/gin-gonic/gin v1.4.0/go.mod h1:OW2EZn3DO8Ln9oIKOvM++LBO+5UPHJJDH72/q/3rZdM=
+github.com/globalsign/mgo v0.0.0-20181015135952-eeefdecb41b8 h1:DujepqpGd1hyOd7aW59XpK7Qymp8iy83xq74fLr21is=
+github.com/globalsign/mgo v0.0.0-20181015135952-eeefdecb41b8/go.mod h1:xkRDCp4j0OGD1HRkm4kmhM+pmpv3AKq5SU7GMg4oO/Q=
+github.com/go-kit/kit v0.8.0/go.mod h1:xBxKIO96dXMWWy0MnWVtmwkA9/13aqxPnvrjFYMA2as=
+github.com/go-logfmt/logfmt v0.3.0/go.mod h1:Qt1PoO58o5twSAckw1HlFXLmHsOX5/0LbT9GBnD5lWE=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/go-stack/stack v1.8.0/go.mod h1:v0f6uXyyMGvRgIKkXu+yp6POWl0qKG85gN/melR3HDY=
+github.com/gogo/protobuf v1.1.1/go.mod h1:r8qH/GZQm5c6nD/R0oafs1akxWv10x8SbQlK7atdtwQ=
+github.com/gogo/protobuf v1.2.1/go.mod h1:hp+jE20tsWTFYpLwKvXlhS1hjn+gTNwPg2I6zVXpSg4=
+github.com/golang/glog v0.0.0-20160126235308-23def4e6c14b/go.mod h1:SBH7ygxi8pfUlaOkMMuAQtPIUF8ecWP5IEl/CR7VP2Q=
+github.com/golang/groupcache v0.0.0-20190129154638-5b532d6fd5ef/go.mod h1:cIg4eruTrX1D+g88fzRXU5OdNfaM+9IcxsU14FzY7Hc=
+github.com/golang/mock v1.1.1/go.mod h1:oTYuIxOrZwtPieC+H1uAHpcLFnEyAGVDL/k47Jfbm0A=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/golang/protobuf v1.3.1 h1:YF8+flBXS5eO826T4nzqPrxfhQThhXl0YzfuUPu4SBg=
+github.com/golang/protobuf v1.3.1/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/gomodule/redigo v2.0.0+incompatible h1:K/R+8tc58AaqLkqG2Ol3Qk+DR/TlNuhuh457pBFPtt0=
+github.com/gomodule/redigo v2.0.0+incompatible/go.mod h1:B4C85qUVwatsJoIUNIfCRsp7qO0iAmpGFZ4EELWSbC4=
+github.com/google/btree v1.0.0/go.mod h1:lNA+9X1NB3Zf8V7Ke586lFgjr2dZNuvo3lPJSGZ5JPQ=
+github.com/google/go-cmp v0.2.0/go.mod h1:oXzfMopK8JAjlY9xF4vHSVASa0yLyX7SntLO5aqRK0M=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/gorilla/websocket v1.4.0/go.mod h1:E7qHFY5m1UJ88s3WnNqhKjPHQ0heANvMoAMk2YaljkQ=
+github.com/grpc-ecosystem/go-grpc-middleware v1.0.0/go.mod h1:FiyG127CGDf3tlThmgyCl78X/SZQqEOJBCDaAfeWzPs=
+github.com/grpc-ecosystem/go-grpc-prometheus v1.2.0/go.mod h1:8NvIoxWQoOIhqOTXgfV/d3M/q6VIi02HzZEHgUlZvzk=
+github.com/grpc-ecosystem/grpc-gateway v1.9.0/go.mod h1:vNeuVxBJEsws4ogUvrchl83t/GYV9WGTSLVdBhOQFDY=
+github.com/hashicorp/hcl v1.0.0 h1:0Anlzjpi4vEasTeNFn2mLJgTSwt0+6sfsiTG8qcWGx4=
+github.com/hashicorp/hcl v1.0.0/go.mod h1:E5yfLk+7swimpb2L/Alb/PJmXilQ/rhwaUYs4T20WEQ=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/jonboulle/clockwork v0.1.0/go.mod h1:Ii8DK3G1RaLaWxj9trq07+26W01tbo22gdxWY5EU2bo=
+github.com/jpillora/backoff v0.0.0-20180909062703-3050d21c67d7/go.mod h1:2iMrUgbbvHEiQClaW2NsSzMyGHqN+rDFqY705q49KG0=
+github.com/json-iterator/go v1.1.6 h1:MrUvLMLTMxbqFJ9kzlvat/rYZqZnW3u4wkLzWTaFwKs=
+github.com/json-iterator/go v1.1.6/go.mod h1:+SdeFBvtyEkXs7REEP0seUULqWtbJapLOCVDaaPEHmU=
+github.com/julienschmidt/httprouter v1.2.0/go.mod h1:SYymIcj16QtmaHHD7aYtjjsJG7VTCxuUUipMqKk8s4w=
+github.com/kisielk/errcheck v1.1.0/go.mod h1:EZBBE59ingxPouuu3KfxchcWSUPOHkagtvWXihfKN4Q=
+github.com/kisielk/gotool v1.0.0/go.mod h1:XhKaO+MFFWcvkIS/tQcRk01m1F5IRFswLeQ+oQHNcck=
+github.com/konsorten/go-windows-terminal-sequences v1.0.1/go.mod h1:T0+1ngSBFLxvqU3pZ+m/2kptfBszLMUkC4ZK/EgS/cQ=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/kr/pretty v0.1.0 h1:L/CwN0zerZDmRFUapSPitk6f+Q3+0za1rQkzVuMiMFI=
+github.com/kr/pretty v0.1.0/go.mod h1:dAy3ld7l9f0ibDNOQOHHMYYIIbhfbHSm3C4ZsoJORNo=
+github.com/kr/pty v1.1.1/go.mod h1:pFQYn66WHrOpPYNljwOMqo10TkYh1fy3cYio2l3bCsQ=
+github.com/kr/text v0.1.0 h1:45sCR5RtlFHMR4UwH9sdQ5TC8v0qDQCHnXt+kaKSTVE=
+github.com/kr/text v0.1.0/go.mod h1:4Jbv+DJW3UT/LiOwJeYQe1efqtUx/iVham/4vfdArNI=
+github.com/magiconair/properties v1.8.0 h1:LLgXmsheXeRoUOBOjtwPQCWIYqM/LU1ayDtDePerRcY=
+github.com/magiconair/properties v1.8.0/go.mod h1:PppfXfuXeibc/6YijjN8zIbojt8czPbwD3XqdrwzmxQ=
+github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
+github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.7/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.8 h1:HLtExJ+uU2HOZ+wI0Tt5DtUDrx8yhUqDcp7fYERX4CE=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/matttproud/golang_protobuf_extensions v1.0.1/go.mod h1:D8He9yQNgCq6Z5Ld7szi9bcBfOoFv/3dc6xSMkL2PC0=
+github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
+github.com/mitchellh/mapstructure v1.1.2 h1:fmNYVwqnSfB9mZU6OS2O6GsXM+wcskZDuKQzvN1EDeE=
+github.com/mitchellh/mapstructure v1.1.2/go.mod h1:FVVH3fgwuzCH5S8UJGiWEs2h04kUh9fWfEaFds41c1Y=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd h1:TRLaZ9cD/w8PVh93nsPXa1VrQ6jlwL5oN8l14QlcNfg=
+github.com/modern-go/concurrent v0.0.0-20180306012644-bacd9c7ef1dd/go.mod h1:6dJC0mAP4ikYIbvyc7fijjWJddQyLn8Ig3JB5CqoB9Q=
+github.com/modern-go/reflect2 v1.0.1 h1:9f412s+6RmYXLWZSEzVVgPGK7C2PphHj5RJrvfx9AWI=
+github.com/modern-go/reflect2 v1.0.1/go.mod h1:bx2lNnkwVCuqBIxFjflWJWanXIb3RllmbCylyMrvgv0=
+github.com/mwitkow/go-conntrack v0.0.0-20161129095857-cc309e4a2223/go.mod h1:qRWi+5nqEBWmkhHvq77mSJWrCKwh8bxhgT7d/eI7P4U=
+github.com/oklog/ulid v1.3.1/go.mod h1:CirwcVhetQ6Lv90oh/F+FBtV6XMibvdAFo93nm5qn4U=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/pelletier/go-toml v1.2.0 h1:T5zMGML61Wp+FlcbWjRDT7yAxhJNAiPPLOFECq181zc=
+github.com/pelletier/go-toml v1.2.0/go.mod h1:5z9KED0ma1S8pY6P1sdut58dfprrGBbd/94hg7ilaic=
+github.com/pkg/errors v0.8.0/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/prometheus/client_golang v0.9.1/go.mod h1:7SWBe2y4D6OKWSNQJUaRYU/AaXPKyh/dDVn+NZz0KFw=
+github.com/prometheus/client_golang v0.9.3/go.mod h1:/TN21ttK/J9q6uSwhBd54HahCDft0ttaMvbicHlPoso=
+github.com/prometheus/client_model v0.0.0-20180712105110-5c3871d89910/go.mod h1:MbSGuTsp3dbXC40dX6PRTWyKYBIrTGTE9sqQNg2J8bo=
+github.com/prometheus/client_model v0.0.0-20190129233127-fd36f4220a90/go.mod h1:xMI15A0UPsDsEKsMN9yxemIoYk6Tm2C1GtYGdfGttqA=
+github.com/prometheus/common v0.0.0-20181113130724-41aa239b4cce/go.mod h1:daVV7qP5qjZbuso7PdcryaAu0sAZbrN9i7WWcTMWvro=
+github.com/prometheus/common v0.4.0/go.mod h1:TNfzLD0ON7rHzMJeJkieUDPYmFC7Snx/y86RQel1bk4=
+github.com/prometheus/procfs v0.0.0-20181005140218-185b4288413d/go.mod h1:c3At6R/oaqEKCNdg8wHV1ftS6bRYblBhIjjI8uT2IGk=
+github.com/prometheus/procfs v0.0.0-20190507164030-5867b95ac084/go.mod h1:TjEm7ze935MbeOT/UhFTIMYKhuLP4wbCsTZCD3I8kEA=
+github.com/prometheus/tsdb v0.7.1/go.mod h1:qhTCs0VvXwvX/y3TZrWD7rabWM+ijKTux40TwIPHuXU=
+github.com/rogpeppe/fastuuid v0.0.0-20150106093220-6724a57986af/go.mod h1:XWv6SoW27p1b0cqNHllgS5HIMJraePCO15w5zCzIWYg=
+github.com/rogpeppe/fastuuid v1.1.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
+github.com/satori/go.uuid v1.2.0 h1:0uYX9dsZ2yD7q2RtLRtPSdGDWzjeM3TbMJP9utgA0ww=
+github.com/satori/go.uuid v1.2.0/go.mod h1:dA0hQrYB0VpLJoorglMZABFdXlWrHn1NEOzdhQKdks0=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/sirupsen/logrus v1.2.0/go.mod h1:LxeOpSwHxABJmUn/MG1IvRgCAasNZTLOkJPxbbu5VWo=
+github.com/smartystreets/assertions v1.0.0/go.mod h1:kHHU4qYBaI3q23Pp3VPrmWhuIUrLW/7eUrw0BU5VaoM=
+github.com/smartystreets/go-aws-auth v0.0.0-20180515143844-0c1422d1fdb9/go.mod h1:SnhjPscd9TpLiy1LpzGSKh3bXCfxxXuqd9xmQJy3slM=
+github.com/smartystreets/gunit v1.0.0/go.mod h1:qwPWnhz6pn0NnRBP++URONOVyNkPyr4SauJk4cUOwJs=
+github.com/soheilhy/cmux v0.1.4/go.mod h1:IM3LyeVVIOuxMH7sFAkER9+bJ4dT7Ms6E4xg4kGIyLM=
+github.com/spaolacci/murmur3 v0.0.0-20180118202830-f09979ecbc72/go.mod h1:JwIasOWyU6f++ZhiEuf87xNszmSA2myDM2Kzu9HwQUA=
+github.com/spf13/afero v1.1.2 h1:m8/z1t7/fwjysjQRYbP0RD+bUIF/8tJwPdEZsI83ACI=
+github.com/spf13/afero v1.1.2/go.mod h1:j4pytiNVoe2o6bmDsKpLACNPDBIoEAkihy7loJ1B0CQ=
+github.com/spf13/cast v1.3.0 h1:oget//CVOEoFewqQxwr0Ej5yjygnqGkvggSE/gB35Q8=
+github.com/spf13/cast v1.3.0/go.mod h1:Qx5cxh0v+4UWYiBimWS+eyWzqEqokIECu5etghLkUJE=
+github.com/spf13/jwalterweatherman v1.0.0 h1:XHEdyB+EcvlqZamSM4ZOMGlc93t6AcsBEu9Gc1vn7yk=
+github.com/spf13/jwalterweatherman v1.0.0/go.mod h1:cQK4TGJAtQXfYWX+Ddv3mKDzgVb68N+wFjFa4jdeBTo=
+github.com/spf13/pflag v1.0.3 h1:zPAT6CGy6wXeQ7NtTnaTerfKOsV6V6F8agHXFiazDkg=
+github.com/spf13/pflag v1.0.3/go.mod h1:DYY7MBk1bdzusC3SYhjObp+wFpr4gzcvqqNjLnInEg4=
+github.com/spf13/viper v1.4.0 h1:yXHLWeravcrgGyFSyCgdYpXQ9dR9c/WED3pg1RhxqEU=
+github.com/spf13/viper v1.4.0/go.mod h1:PTJ7Z/lr49W6bUbkmS1V3by4uWynFiR9p7+dSq/yZzE=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/objx v0.1.1/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.2.2/go.mod h1:a8OnRcib4nhh0OaRAV+Yts87kKdq0PP7pXfy6kDkUVs=
+github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/tj/assert v0.0.0-20171129193455-018094318fb0/go.mod h1:mZ9/Rh9oLWpLLDRpvE+3b7gP/C2YyLFYxNmcLnPTMe0=
+github.com/tj/go-elastic v0.0.0-20171221160941-36157cbbebc2/go.mod h1:WjeM0Oo1eNAjXGDx2yma7uG2XoyRZTq1uv3M/o7imD0=
+github.com/tj/go-kinesis v0.0.0-20171128231115-08b17f58cb1b/go.mod h1:/yhzCV0xPfx6jb1bBgRFjl5lytqVqZXEaeqWP8lTEao=
+github.com/tj/go-spin v1.1.0/go.mod h1:Mg1mzmePZm4dva8Qz60H2lHwmJ2loum4VIrLgVnKwh4=
+github.com/tmc/grpc-websocket-proxy v0.0.0-20190109142713-0ad062ec5ee5/go.mod h1:ncp9v5uamzpCO7NfCPTXjqaC+bZgJeR0sMTm6dMHP7U=
+github.com/ugorji/go v1.1.4 h1:j4s+tAvLfL3bZyefP2SEWmhBzmuIlH/eqNuPdFPgngw=
+github.com/ugorji/go v1.1.4/go.mod h1:uQMGLiO92mf5W77hV/PUCpI3pbzQx3CRekS0kk+RGrc=
+github.com/xiang90/probing v0.0.0-20190116061207-43a291ad63a2/go.mod h1:UETIi67q53MR2AWcXfiuqkDkRtnGDLqkBTpCHuJHxtU=
+github.com/xordataexchange/crypt v0.0.3-0.20170626215501-b2862e3d0a77/go.mod h1:aYKd//L2LvnjZzWKhF00oedf4jCCReLcmhLdhm1A27Q=
+go.etcd.io/bbolt v1.3.2/go.mod h1:IbVyRI1SCnLcuJnV2u8VeU0CEYM7e686BmAb1XKL+uU=
+go.uber.org/atomic v1.4.0/go.mod h1:gD2HeocX3+yG+ygLZcrzQJaqmWj9AIm7n08wl/qW/PE=
+go.uber.org/multierr v1.1.0/go.mod h1:wR5kodmAFQ0UK8QlbwjlSNy0Z68gJhDJUG5sjR94q/0=
+go.uber.org/zap v1.10.0/go.mod h1:vwi/ZaCAaUcBkycHslxD9B2zi4UTXhF60s6SWpuDF0Q=
+golang.org/x/crypto v0.0.0-20180904163835-0709b304e793/go.mod h1:6SG95UA2DQfeDnfUPMdvaQW0Q7yPrPDi9nlGo2tz2b4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/lint v0.0.0-20181026193005-c67002cb31c3/go.mod h1:UVdnD1Gm6xHRNCYTkRU2/jEulfH38KcIWyp/GAMgvoE=
+golang.org/x/lint v0.0.0-20190313153728-d0100b6bd8b3/go.mod h1:6SW0HCj/g11FgYtHlgUYUwCkIfeOF89ocIRzGO/8vkc=
+golang.org/x/net v0.0.0-20180826012351-8a410e7b638d/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181114220301-adae6a3d119a/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20181220203305-927f97764cc3/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190311183353-d8887717615a/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190503192946-f4e77d36d62c/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190522155817-f3200d17e092/go.mod h1:HSz+uSET+XFnRR8LxR5pz3Of3rY3CfYBVs4xY44aLks=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859 h1:R/3boaszxrf1GEUWTVDzSKVwLmSJpwZ1yqXm8j0v2QI=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/oauth2 v0.0.0-20180821212333-d2e6202438be/go.mod h1:N/0e6XlmueqKjAGxoOufVs8QHGRruUQn6yWY3a++T0U=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181108010431-42b317875d0f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sync v0.0.0-20181221193216-37e7f081c4d4/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180830151530-49385e6e1522/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180905080454-ebe1bf3edb33/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181107165924-66b7b1311ac8/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20181116152217-5ac8a444bdc5/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+golang.org/x/time v0.0.0-20190308202827-9d24e82272b4/go.mod h1:tRJNPiyCQ0inRvYxbN9jk5I+vvW/OXSQhTDSoE431IQ=
+golang.org/x/tools v0.0.0-20180221164845-07fd8470d635/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190114222345-bf090417da8b/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
+golang.org/x/tools v0.0.0-20190311212946-11955173bddd/go.mod h1:LCzVGOaR6xXOjkQ3onu1FJEFr0SW1gC7cKk1uF8kGRs=
+google.golang.org/appengine v1.1.0/go.mod h1:EbEs0AVv82hx2wNQdGPgUI5lhzA/G0D9YwlJXL52JkM=
+google.golang.org/genproto v0.0.0-20180817151627-c66870c02cf8/go.mod h1:JiN7NxoALGmiZfu7CAH4rXhgtRTLTxftemlI0sWmxmc=
+google.golang.org/grpc v1.19.0/go.mod h1:mqu4LbDTu4XGKhr4mRzUsmM4RtVoemTSY81AxZiDr8c=
+google.golang.org/grpc v1.21.0/go.mod h1:oYelfM1adQP15Ek0mdvEgi9Df8B9CZIaU1084ijfRaM=
+gopkg.in/alecthomas/kingpin.v2 v2.2.6/go.mod h1:FMv+mEhP44yOT+4EoQTLFTRgOQ1FBLkstjWtayDeSgw=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127 h1:qIbj1fsPNlZgppZ+VLlY7N33q108Sa+fhmuc+sWQYwY=
+gopkg.in/check.v1 v1.0.0-20180628173108-788fd7840127/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/go-playground/assert.v1 v1.2.1 h1:xoYuJVE7KT85PYWrN730RguIQO0ePzVRfFMXadIrXTM=
+gopkg.in/go-playground/assert.v1 v1.2.1/go.mod h1:9RXL0bg/zibRAgZUYszZSwO/z8Y/a8bDuhia5mkpMnE=
+gopkg.in/go-playground/validator.v8 v8.18.2 h1:lFB4DoMU6B626w8ny76MV7VX6W2VHct2GVOI3xgiMrQ=
+gopkg.in/go-playground/validator.v8 v8.18.2/go.mod h1:RX2a/7Ha8BgOhfk7j780h4/u/RRjR0eouCJSH80/M2Y=
+gopkg.in/resty.v1 v1.12.0/go.mod h1:mDo4pnntr5jdWRML875a/NmxYqAlA73dVijT2AXvQQo=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.0.0-20170812160011-eb3733d160e7/go.mod h1:JAlM8MvJe8wmxCU4Bli9HhUf9+ttbYbLASfIpnQbh74=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
+gopkg.in/yaml.v2 v2.2.2/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
+honnef.co/go/tools v0.0.0-20190102054323-c2f93a96b099/go.mod h1:rf3lG4BRIbNafJWhAfAdb/ePZxsR/4RtNHQocxwk9r4=
--- a/backend/lib/cron/.gitignore
+++ b/backend/lib/cron/.gitignore
@@ -0,0 +1,22 @@
+# Compiled Object files, Static and Dynamic libs (Shared Objects)
+*.o
+*.a
+*.so
+
+# Folders
+_obj
+_test
+
+# Architecture specific extensions/prefixes
+*.[568vq]
+[568vq].out
+
+*.cgo1.go
+*.cgo2.c
+_cgo_defun.c
+_cgo_gotypes.go
+_cgo_export.*
+
+_testmain.go
+
+*.exe
--- a/backend/lib/cron/.travis.yml
+++ b/backend/lib/cron/.travis.yml
@@ -0,0 +1 @@
+language: go
--- a/backend/lib/cron/LICENSE
+++ b/backend/lib/cron/LICENSE
@@ -0,0 +1,21 @@
+Copyright (C) 2012 Rob Figueiredo
+All Rights Reserved.
+
+MIT LICENSE
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of
+this software and associated documentation files (the "Software"), to deal in
+the Software without restriction, including without limitation the rights to
+use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of
+the Software, and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS
+FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR
+COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER
+IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN
+CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/backend/lib/cron/README.md
+++ b/backend/lib/cron/README.md
@@ -0,0 +1,125 @@
+[![GoDoc](http://godoc.org/github.com/robfig/cron?status.png)](http://godoc.org/github.com/robfig/cron)
+[![Build Status](https://travis-ci.org/robfig/cron.svg?branch=master)](https://travis-ci.org/robfig/cron)
+
+# cron
+
+Cron V3 has been released!
+
+To download the specific tagged release, run:
+
+	go get github.com/robfig/cron/v3@v3.0.0
+
+Import it in your program as:
+
+	import "github.com/robfig/cron/v3"
+
+It requires Go 1.11 or later due to usage of Go Modules.
+
+Refer to the documentation here:
+http://godoc.org/github.com/robfig/cron
+
+The rest of this document describes the the advances in v3 and a list of
+breaking changes for users that wish to upgrade from an earlier version.
+
+## Upgrading to v3 (June 2019)
+
+cron v3 is a major upgrade to the library that addresses all outstanding bugs,
+feature requests, and rough edges. It is based on a merge of master which
+contains various fixes to issues found over the years and the v2 branch which
+contains some backwards-incompatible features like the ability to remove cron
+jobs. In addition, v3 adds support for Go Modules, cleans up rough edges like
+the timezone support, and fixes a number of bugs.
+
+New features:
+
+- Support for Go modules. Callers must now import this library as
+  `github.com/robfig/cron/v3`, instead of `gopkg.in/...`
+
+- Fixed bugs:
+  - 0f01e6b parser: fix combining of Dow and Dom (#70)
+  - dbf3220 adjust times when rolling the clock forward to handle non-existent midnight (#157)
+  - eeecf15 spec_test.go: ensure an error is returned on 0 increment (#144)
+  - 70971dc cron.Entries(): update request for snapshot to include a reply channel (#97)
+  - 1cba5e6 cron: fix: removing a job causes the next scheduled job to run too late (#206)
+
+- Standard cron spec parsing by default (first field is "minute"), with an easy
+  way to opt into the seconds field (quartz-compatible). Although, note that the
+  year field (optional in Quartz) is not supported.
+
+- Extensible, key/value logging via an interface that complies with
+  the https://github.com/go-logr/logr project.
+
+- The new Chain & JobWrapper types allow you to install "interceptors" to add
+  cross-cutting behavior like the following:
+  - Recover any panics from jobs
+  - Delay a job's execution if the previous run hasn't completed yet
+  - Skip a job's execution if the previous run hasn't completed yet
+  - Log each job's invocations
+  - Notification when jobs are completed
+
+It is backwards incompatible with both v1 and v2. These updates are required:
+
+- The v1 branch accepted an optional seconds field at the beginning of the cron
+  spec. This is non-standard and has led to a lot of confusion. The new default
+  parser conforms to the standard as described by [the Cron wikipedia page].
+
+  UPDATING: To retain the old behavior, construct your Cron with a custom
+  parser:
+
+      // Seconds field, required
+      cron.New(cron.WithSeconds())
+
+      // Seconds field, optional
+      cron.New(
+          cron.WithParser(
+              cron.SecondOptional | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor))
+
+- The Cron type now accepts functional options on construction rather than the
+  previous ad-hoc behavior modification mechanisms (setting a field, calling a setter).
+
+  UPDATING: Code that sets Cron.ErrorLogger or calls Cron.SetLocation must be
+  updated to provide those values on construction.
+
+- CRON_TZ is now the recommended way to specify the timezone of a single
+  schedule, which is sanctioned by the specification. The legacy "TZ=" prefix
+  will continue to be supported since it is unambiguous and easy to do so.
+
+  UPDATING: No update is required.
+
+- By default, cron will no longer recover panics in jobs that it runs.
+  Recovering can be surprising (see issue #192) and seems to be at odds with
+  typical behavior of libraries. Relatedly, the `cron.WithPanicLogger` option
+  has been removed to accommodate the more general JobWrapper type.
+
+  UPDATING: To opt into panic recovery and configure the panic logger:
+
+      cron.New(cron.WithChain(
+          cron.Recover(logger),  // or use cron.DefaultLogger
+      ))
+
+- In adding support for https://github.com/go-logr/logr, `cron.WithVerboseLogger` was
+  removed, since it is duplicative with the leveled logging.
+
+  UPDATING: Callers should use `WithLogger` and specify a logger that does not
+  discard `Info` logs. For convenience, one is provided that wraps `*log.Logger`:
+
+      cron.New(
+          cron.WithLogger(cron.VerbosePrintfLogger(logger)))
+
+
+### Background - Cron spec format
+
+There are two cron spec formats in common usage:
+
+- The "standard" cron format, described on [the Cron wikipedia page] and used by
+  the cron Linux system utility.
+
+- The cron format used by [the Quartz Scheduler], commonly used for scheduled
+  jobs in Java software
+
+[the Cron wikipedia page]: https://en.wikipedia.org/wiki/Cron
+[the Quartz Scheduler]: http://www.quartz-scheduler.org/documentation/quartz-2.x/tutorials/crontrigger.html
+
+The original version of this package included an optional "seconds" field, which
+made it incompatible with both of these formats. Now, the "standard" format is
+the default format accepted, and the Quartz format is opt-in.
--- a/backend/lib/cron/chain.go
+++ b/backend/lib/cron/chain.go
@@ -0,0 +1,92 @@
+package cron
+
+import (
+	"fmt"
+	"runtime"
+	"sync"
+	"time"
+)
+
+// JobWrapper decorates the given Job with some behavior.
+type JobWrapper func(Job) Job
+
+// Chain is a sequence of JobWrappers that decorates submitted jobs with
+// cross-cutting behaviors like logging or synchronization.
+type Chain struct {
+	wrappers []JobWrapper
+}
+
+// NewChain returns a Chain consisting of the given JobWrappers.
+func NewChain(c ...JobWrapper) Chain {
+	return Chain{c}
+}
+
+// Then decorates the given job with all JobWrappers in the chain.
+//
+// This:
+//     NewChain(m1, m2, m3).Then(job)
+// is equivalent to:
+//     m1(m2(m3(job)))
+func (c Chain) Then(j Job) Job {
+	for i := range c.wrappers {
+		j = c.wrappers[len(c.wrappers)-i-1](j)
+	}
+	return j
+}
+
+// Recover panics in wrapped jobs and log them with the provided logger.
+func Recover(logger Logger) JobWrapper {
+	return func(j Job) Job {
+		return FuncJob(func() {
+			defer func() {
+				if r := recover(); r != nil {
+					const size = 64 << 10
+					buf := make([]byte, size)
+					buf = buf[:runtime.Stack(buf, false)]
+					err, ok := r.(error)
+					if !ok {
+						err = fmt.Errorf("%v", r)
+					}
+					logger.Error(err, "panic", "stack", "...\n"+string(buf))
+				}
+			}()
+			j.Run()
+		})
+	}
+}
+
+// DelayIfStillRunning serializes jobs, delaying subsequent runs until the
+// previous one is complete. Jobs running after a delay of more than a minute
+// have the delay logged at Info.
+func DelayIfStillRunning(logger Logger) JobWrapper {
+	return func(j Job) Job {
+		var mu sync.Mutex
+		return FuncJob(func() {
+			start := time.Now()
+			mu.Lock()
+			defer mu.Unlock()
+			if dur := time.Since(start); dur > time.Minute {
+				logger.Info("delay", "duration", dur)
+			}
+			j.Run()
+		})
+	}
+}
+
+// SkipIfStillRunning skips an invocation of the Job if a previous invocation is
+// still running. It logs skips to the given logger at Info level.
+func SkipIfStillRunning(logger Logger) JobWrapper {
+	var ch = make(chan struct{}, 1)
+	ch <- struct{}{}
+	return func(j Job) Job {
+		return FuncJob(func() {
+			select {
+			case v := <-ch:
+				j.Run()
+				ch <- v
+			default:
+				logger.Info("skip")
+			}
+		})
+	}
+}
--- a/backend/lib/cron/chain_test.go
+++ b/backend/lib/cron/chain_test.go
@@ -0,0 +1,221 @@
+package cron
+
+import (
+	"io/ioutil"
+	"log"
+	"reflect"
+	"sync"
+	"testing"
+	"time"
+)
+
+func appendingJob(slice *[]int, value int) Job {
+	var m sync.Mutex
+	return FuncJob(func() {
+		m.Lock()
+		*slice = append(*slice, value)
+		m.Unlock()
+	})
+}
+
+func appendingWrapper(slice *[]int, value int) JobWrapper {
+	return func(j Job) Job {
+		return FuncJob(func() {
+			appendingJob(slice, value).Run()
+			j.Run()
+		})
+	}
+}
+
+func TestChain(t *testing.T) {
+	var nums []int
+	var (
+		append1 = appendingWrapper(&nums, 1)
+		append2 = appendingWrapper(&nums, 2)
+		append3 = appendingWrapper(&nums, 3)
+		append4 = appendingJob(&nums, 4)
+	)
+	NewChain(append1, append2, append3).Then(append4).Run()
+	if !reflect.DeepEqual(nums, []int{1, 2, 3, 4}) {
+		t.Error("unexpected order of calls:", nums)
+	}
+}
+
+func TestChainRecover(t *testing.T) {
+	panickingJob := FuncJob(func() {
+		panic("panickingJob panics")
+	})
+
+	t.Run("panic exits job by default", func(t *testing.T) {
+		defer func() {
+			if err := recover(); err == nil {
+				t.Errorf("panic expected, but none received")
+			}
+		}()
+		NewChain().Then(panickingJob).
+			Run()
+	})
+
+	t.Run("Recovering JobWrapper recovers", func(t *testing.T) {
+		NewChain(Recover(PrintfLogger(log.New(ioutil.Discard, "", 0)))).
+			Then(panickingJob).
+			Run()
+	})
+
+	t.Run("composed with the *IfStillRunning wrappers", func(t *testing.T) {
+		NewChain(Recover(PrintfLogger(log.New(ioutil.Discard, "", 0)))).
+			Then(panickingJob).
+			Run()
+	})
+}
+
+type countJob struct {
+	m       sync.Mutex
+	started int
+	done    int
+	delay   time.Duration
+}
+
+func (j *countJob) Run() {
+	j.m.Lock()
+	j.started++
+	j.m.Unlock()
+	time.Sleep(j.delay)
+	j.m.Lock()
+	j.done++
+	j.m.Unlock()
+}
+
+func (j *countJob) Started() int {
+	defer j.m.Unlock()
+	j.m.Lock()
+	return j.started
+}
+
+func (j *countJob) Done() int {
+	defer j.m.Unlock()
+	j.m.Lock()
+	return j.done
+}
+
+func TestChainDelayIfStillRunning(t *testing.T) {
+
+	t.Run("runs immediately", func(t *testing.T) {
+		var j countJob
+		wrappedJob := NewChain(DelayIfStillRunning(DiscardLogger)).Then(&j)
+		go wrappedJob.Run()
+		time.Sleep(2 * time.Millisecond) // Give the job 2ms to complete.
+		if c := j.Done(); c != 1 {
+			t.Errorf("expected job run once, immediately, got %d", c)
+		}
+	})
+
+	t.Run("second run immediate if first done", func(t *testing.T) {
+		var j countJob
+		wrappedJob := NewChain(DelayIfStillRunning(DiscardLogger)).Then(&j)
+		go func() {
+			go wrappedJob.Run()
+			time.Sleep(time.Millisecond)
+			go wrappedJob.Run()
+		}()
+		time.Sleep(3 * time.Millisecond) // Give both jobs 3ms to complete.
+		if c := j.Done(); c != 2 {
+			t.Errorf("expected job run twice, immediately, got %d", c)
+		}
+	})
+
+	t.Run("second run delayed if first not done", func(t *testing.T) {
+		var j countJob
+		j.delay = 10 * time.Millisecond
+		wrappedJob := NewChain(DelayIfStillRunning(DiscardLogger)).Then(&j)
+		go func() {
+			go wrappedJob.Run()
+			time.Sleep(time.Millisecond)
+			go wrappedJob.Run()
+		}()
+
+		// After 5ms, the first job is still in progress, and the second job was
+		// run but should be waiting for it to finish.
+		time.Sleep(5 * time.Millisecond)
+		started, done := j.Started(), j.Done()
+		if started != 1 || done != 0 {
+			t.Error("expected first job started, but not finished, got", started, done)
+		}
+
+		// Verify that the second job completes.
+		time.Sleep(25 * time.Millisecond)
+		started, done = j.Started(), j.Done()
+		if started != 2 || done != 2 {
+			t.Error("expected both jobs done, got", started, done)
+		}
+	})
+
+}
+
+func TestChainSkipIfStillRunning(t *testing.T) {
+
+	t.Run("runs immediately", func(t *testing.T) {
+		var j countJob
+		wrappedJob := NewChain(SkipIfStillRunning(DiscardLogger)).Then(&j)
+		go wrappedJob.Run()
+		time.Sleep(2 * time.Millisecond) // Give the job 2ms to complete.
+		if c := j.Done(); c != 1 {
+			t.Errorf("expected job run once, immediately, got %d", c)
+		}
+	})
+
+	t.Run("second run immediate if first done", func(t *testing.T) {
+		var j countJob
+		wrappedJob := NewChain(SkipIfStillRunning(DiscardLogger)).Then(&j)
+		go func() {
+			go wrappedJob.Run()
+			time.Sleep(time.Millisecond)
+			go wrappedJob.Run()
+		}()
+		time.Sleep(3 * time.Millisecond) // Give both jobs 3ms to complete.
+		if c := j.Done(); c != 2 {
+			t.Errorf("expected job run twice, immediately, got %d", c)
+		}
+	})
+
+	t.Run("second run skipped if first not done", func(t *testing.T) {
+		var j countJob
+		j.delay = 10 * time.Millisecond
+		wrappedJob := NewChain(SkipIfStillRunning(DiscardLogger)).Then(&j)
+		go func() {
+			go wrappedJob.Run()
+			time.Sleep(time.Millisecond)
+			go wrappedJob.Run()
+		}()
+
+		// After 5ms, the first job is still in progress, and the second job was
+		// aleady skipped.
+		time.Sleep(5 * time.Millisecond)
+		started, done := j.Started(), j.Done()
+		if started != 1 || done != 0 {
+			t.Error("expected first job started, but not finished, got", started, done)
+		}
+
+		// Verify that the first job completes and second does not run.
+		time.Sleep(25 * time.Millisecond)
+		started, done = j.Started(), j.Done()
+		if started != 1 || done != 1 {
+			t.Error("expected second job skipped, got", started, done)
+		}
+	})
+
+	t.Run("skip 10 jobs on rapid fire", func(t *testing.T) {
+		var j countJob
+		j.delay = 10 * time.Millisecond
+		wrappedJob := NewChain(SkipIfStillRunning(DiscardLogger)).Then(&j)
+		for i := 0; i < 11; i++ {
+			go wrappedJob.Run()
+		}
+		time.Sleep(200 * time.Millisecond)
+		done := j.Done()
+		if done != 1 {
+			t.Error("expected 1 jobs executed, 10 jobs dropped, got", done)
+		}
+	})
+
+}
--- a/backend/lib/cron/constantdelay.go
+++ b/backend/lib/cron/constantdelay.go
@@ -0,0 +1,27 @@
+package cron
+
+import "time"
+
+// ConstantDelaySchedule represents a simple recurring duty cycle, e.g. "Every 5 minutes".
+// It does not support jobs more frequent than once a second.
+type ConstantDelaySchedule struct {
+	Delay time.Duration
+}
+
+// Every returns a crontab Schedule that activates once every duration.
+// Delays of less than a second are not supported (will round up to 1 second).
+// Any fields less than a Second are truncated.
+func Every(duration time.Duration) ConstantDelaySchedule {
+	if duration < time.Second {
+		duration = time.Second
+	}
+	return ConstantDelaySchedule{
+		Delay: duration - time.Duration(duration.Nanoseconds())%time.Second,
+	}
+}
+
+// Next returns the next time this should be run.
+// This rounds so that the next activation time will be on the second.
+func (schedule ConstantDelaySchedule) Next(t time.Time) time.Time {
+	return t.Add(schedule.Delay - time.Duration(t.Nanosecond())*time.Nanosecond)
+}
--- a/backend/lib/cron/constantdelay_test.go
+++ b/backend/lib/cron/constantdelay_test.go
@@ -0,0 +1,54 @@
+package cron
+
+import (
+	"testing"
+	"time"
+)
+
+func TestConstantDelayNext(t *testing.T) {
+	tests := []struct {
+		time     string
+		delay    time.Duration
+		expected string
+	}{
+		// Simple cases
+		{"Mon Jul 9 14:45 2012", 15*time.Minute + 50*time.Nanosecond, "Mon Jul 9 15:00 2012"},
+		{"Mon Jul 9 14:59 2012", 15 * time.Minute, "Mon Jul 9 15:14 2012"},
+		{"Mon Jul 9 14:59:59 2012", 15 * time.Minute, "Mon Jul 9 15:14:59 2012"},
+
+		// Wrap around hours
+		{"Mon Jul 9 15:45 2012", 35 * time.Minute, "Mon Jul 9 16:20 2012"},
+
+		// Wrap around days
+		{"Mon Jul 9 23:46 2012", 14 * time.Minute, "Tue Jul 10 00:00 2012"},
+		{"Mon Jul 9 23:45 2012", 35 * time.Minute, "Tue Jul 10 00:20 2012"},
+		{"Mon Jul 9 23:35:51 2012", 44*time.Minute + 24*time.Second, "Tue Jul 10 00:20:15 2012"},
+		{"Mon Jul 9 23:35:51 2012", 25*time.Hour + 44*time.Minute + 24*time.Second, "Thu Jul 11 01:20:15 2012"},
+
+		// Wrap around months
+		{"Mon Jul 9 23:35 2012", 91*24*time.Hour + 25*time.Minute, "Thu Oct 9 00:00 2012"},
+
+		// Wrap around minute, hour, day, month, and year
+		{"Mon Dec 31 23:59:45 2012", 15 * time.Second, "Tue Jan 1 00:00:00 2013"},
+
+		// Round to nearest second on the delay
+		{"Mon Jul 9 14:45 2012", 15*time.Minute + 50*time.Nanosecond, "Mon Jul 9 15:00 2012"},
+
+		// Round up to 1 second if the duration is less.
+		{"Mon Jul 9 14:45:00 2012", 15 * time.Millisecond, "Mon Jul 9 14:45:01 2012"},
+
+		// Round to nearest second when calculating the next time.
+		{"Mon Jul 9 14:45:00.005 2012", 15 * time.Minute, "Mon Jul 9 15:00 2012"},
+
+		// Round to nearest second for both.
+		{"Mon Jul 9 14:45:00.005 2012", 15*time.Minute + 50*time.Nanosecond, "Mon Jul 9 15:00 2012"},
+	}
+
+	for _, c := range tests {
+		actual := Every(c.delay).Next(getTime(c.time))
+		expected := getTime(c.expected)
+		if actual != expected {
+			t.Errorf("%s, \"%s\": (expected) %v != %v (actual)", c.time, c.delay, expected, actual)
+		}
+	}
+}
--- a/backend/lib/cron/cron.go
+++ b/backend/lib/cron/cron.go
@@ -0,0 +1,350 @@
+package cron
+
+import (
+	"context"
+	"sort"
+	"sync"
+	"time"
+)
+
+// Cron keeps track of any number of entries, invoking the associated func as
+// specified by the schedule. It may be started, stopped, and the entries may
+// be inspected while running.
+type Cron struct {
+	entries   []*Entry
+	chain     Chain
+	stop      chan struct{}
+	add       chan *Entry
+	remove    chan EntryID
+	snapshot  chan chan []Entry
+	running   bool
+	logger    Logger
+	runningMu sync.Mutex
+	location  *time.Location
+	parser    Parser
+	nextID    EntryID
+	jobWaiter sync.WaitGroup
+}
+
+// Job is an interface for submitted cron jobs.
+type Job interface {
+	Run()
+}
+
+// Schedule describes a job's duty cycle.
+type Schedule interface {
+	// Next returns the next activation time, later than the given time.
+	// Next is invoked initially, and then each time the job is run.
+	Next(time.Time) time.Time
+}
+
+// EntryID identifies an entry within a Cron instance
+type EntryID int
+
+// Entry consists of a schedule and the func to execute on that schedule.
+type Entry struct {
+	// ID is the cron-assigned ID of this entry, which may be used to look up a
+	// snapshot or remove it.
+	ID EntryID
+
+	// Schedule on which this job should be run.
+	Schedule Schedule
+
+	// Next time the job will run, or the zero time if Cron has not been
+	// started or this entry's schedule is unsatisfiable
+	Next time.Time
+
+	// Prev is the last time this job was run, or the zero time if never.
+	Prev time.Time
+
+	// WrappedJob is the thing to run when the Schedule is activated.
+	WrappedJob Job
+
+	// Job is the thing that was submitted to cron.
+	// It is kept around so that user code that needs to get at the job later,
+	// e.g. via Entries() can do so.
+	Job Job
+}
+
+// Valid returns true if this is not the zero entry.
+func (e Entry) Valid() bool { return e.ID != 0 }
+
+// byTime is a wrapper for sorting the entry array by time
+// (with zero time at the end).
+type byTime []*Entry
+
+func (s byTime) Len() int      { return len(s) }
+func (s byTime) Swap(i, j int) { s[i], s[j] = s[j], s[i] }
+func (s byTime) Less(i, j int) bool {
+	// Two zero times should return false.
+	// Otherwise, zero is "greater" than any other time.
+	// (To sort it at the end of the list.)
+	if s[i].Next.IsZero() {
+		return false
+	}
+	if s[j].Next.IsZero() {
+		return true
+	}
+	return s[i].Next.Before(s[j].Next)
+}
+
+// New returns a new Cron job runner, modified by the given options.
+//
+// Available Settings
+//
+//   Time Zone
+//     Description: The time zone in which schedules are interpreted
+//     Default:     time.Local
+//
+//   Parser
+//     Description: Parser converts cron spec strings into cron.Schedules.
+//     Default:     Accepts this spec: https://en.wikipedia.org/wiki/Cron
+//
+//   Chain
+//     Description: Wrap submitted jobs to customize behavior.
+//     Default:     A chain that recovers panics and logs them to stderr.
+//
+// See "cron.With*" to modify the default behavior.
+func New(opts ...Option) *Cron {
+	c := &Cron{
+		entries:   nil,
+		chain:     NewChain(),
+		add:       make(chan *Entry),
+		stop:      make(chan struct{}),
+		snapshot:  make(chan chan []Entry),
+		remove:    make(chan EntryID),
+		running:   false,
+		runningMu: sync.Mutex{},
+		logger:    DefaultLogger,
+		location:  time.Local,
+		parser:    standardParser,
+	}
+	for _, opt := range opts {
+		opt(c)
+	}
+	return c
+}
+
+// FuncJob is a wrapper that turns a func() into a cron.Job
+type FuncJob func()
+
+func (f FuncJob) Run() { f() }
+
+// AddFunc adds a func to the Cron to be run on the given schedule.
+// The spec is parsed using the time zone of this Cron instance as the default.
+// An opaque ID is returned that can be used to later remove it.
+func (c *Cron) AddFunc(spec string, cmd func()) (EntryID, error) {
+	return c.AddJob(spec, FuncJob(cmd))
+}
+
+// AddJob adds a Job to the Cron to be run on the given schedule.
+// The spec is parsed using the time zone of this Cron instance as the default.
+// An opaque ID is returned that can be used to later remove it.
+func (c *Cron) AddJob(spec string, cmd Job) (EntryID, error) {
+	schedule, err := c.parser.Parse(spec)
+	if err != nil {
+		return 0, err
+	}
+	return c.Schedule(schedule, cmd), nil
+}
+
+// Schedule adds a Job to the Cron to be run on the given schedule.
+// The job is wrapped with the configured Chain.
+func (c *Cron) Schedule(schedule Schedule, cmd Job) EntryID {
+	c.runningMu.Lock()
+	defer c.runningMu.Unlock()
+	c.nextID++
+	entry := &Entry{
+		ID:         c.nextID,
+		Schedule:   schedule,
+		WrappedJob: c.chain.Then(cmd),
+		Job:        cmd,
+	}
+	if !c.running {
+		c.entries = append(c.entries, entry)
+	} else {
+		c.add <- entry
+	}
+	return entry.ID
+}
+
+// Entries returns a snapshot of the cron entries.
+func (c *Cron) Entries() []Entry {
+	c.runningMu.Lock()
+	defer c.runningMu.Unlock()
+	if c.running {
+		replyChan := make(chan []Entry, 1)
+		c.snapshot <- replyChan
+		return <-replyChan
+	}
+	return c.entrySnapshot()
+}
+
+// Location gets the time zone location
+func (c *Cron) Location() *time.Location {
+	return c.location
+}
+
+// Entry returns a snapshot of the given entry, or nil if it couldn't be found.
+func (c *Cron) Entry(id EntryID) Entry {
+	for _, entry := range c.Entries() {
+		if id == entry.ID {
+			return entry
+		}
+	}
+	return Entry{}
+}
+
+// Remove an entry from being run in the future.
+func (c *Cron) Remove(id EntryID) {
+	c.runningMu.Lock()
+	defer c.runningMu.Unlock()
+	if c.running {
+		c.remove <- id
+	} else {
+		c.removeEntry(id)
+	}
+}
+
+// Start the cron scheduler in its own goroutine, or no-op if already started.
+func (c *Cron) Start() {
+	c.runningMu.Lock()
+	defer c.runningMu.Unlock()
+	if c.running {
+		return
+	}
+	c.running = true
+	go c.run()
+}
+
+// Run the cron scheduler, or no-op if already running.
+func (c *Cron) Run() {
+	c.runningMu.Lock()
+	if c.running {
+		c.runningMu.Unlock()
+		return
+	}
+	c.running = true
+	c.runningMu.Unlock()
+	c.run()
+}
+
+// run the scheduler.. this is private just due to the need to synchronize
+// access to the 'running' state variable.
+func (c *Cron) run() {
+	c.logger.Info("start")
+
+	// Figure out the next activation times for each entry.
+	now := c.now()
+	for _, entry := range c.entries {
+		entry.Next = entry.Schedule.Next(now)
+		c.logger.Info("schedule", "now", now, "entry", entry.ID, "next", entry.Next)
+	}
+
+	for {
+		// Determine the next entry to run.
+		sort.Sort(byTime(c.entries))
+
+		var timer *time.Timer
+		if len(c.entries) == 0 || c.entries[0].Next.IsZero() {
+			// If there are no entries yet, just sleep - it still handles new entries
+			// and stop requests.
+			timer = time.NewTimer(100000 * time.Hour)
+		} else {
+			timer = time.NewTimer(c.entries[0].Next.Sub(now))
+		}
+
+		for {
+			select {
+			case now = <-timer.C:
+				now = now.In(c.location)
+				c.logger.Info("wake", "now", now)
+
+				// Run every entry whose next time was less than now
+				for _, e := range c.entries {
+					if e.Next.After(now) || e.Next.IsZero() {
+						break
+					}
+					c.startJob(e.WrappedJob)
+					e.Prev = e.Next
+					e.Next = e.Schedule.Next(now)
+					c.logger.Info("run", "now", now, "entry", e.ID, "next", e.Next)
+				}
+
+			case newEntry := <-c.add:
+				timer.Stop()
+				now = c.now()
+				newEntry.Next = newEntry.Schedule.Next(now)
+				c.entries = append(c.entries, newEntry)
+				c.logger.Info("added", "now", now, "entry", newEntry.ID, "next", newEntry.Next)
+
+			case replyChan := <-c.snapshot:
+				replyChan <- c.entrySnapshot()
+				continue
+
+			case <-c.stop:
+				timer.Stop()
+				c.logger.Info("stop")
+				return
+
+			case id := <-c.remove:
+				timer.Stop()
+				now = c.now()
+				c.removeEntry(id)
+				c.logger.Info("removed", "entry", id)
+			}
+
+			break
+		}
+	}
+}
+
+// startJob runs the given job in a new goroutine.
+func (c *Cron) startJob(j Job) {
+	c.jobWaiter.Add(1)
+	go func() {
+		defer c.jobWaiter.Done()
+		j.Run()
+	}()
+}
+
+// now returns current time in c location
+func (c *Cron) now() time.Time {
+	return time.Now().In(c.location)
+}
+
+// Stop stops the cron scheduler if it is running; otherwise it does nothing.
+// A context is returned so the caller can wait for running jobs to complete.
+func (c *Cron) Stop() context.Context {
+	c.runningMu.Lock()
+	defer c.runningMu.Unlock()
+	if c.running {
+		c.stop <- struct{}{}
+		c.running = false
+	}
+	ctx, cancel := context.WithCancel(context.Background())
+	go func() {
+		c.jobWaiter.Wait()
+		cancel()
+	}()
+	return ctx
+}
+
+// entrySnapshot returns a copy of the current cron entry list.
+func (c *Cron) entrySnapshot() []Entry {
+	var entries = make([]Entry, len(c.entries))
+	for i, e := range c.entries {
+		entries[i] = *e
+	}
+	return entries
+}
+
+func (c *Cron) removeEntry(id EntryID) {
+	var entries []*Entry
+	for _, e := range c.entries {
+		if e.ID != id {
+			entries = append(entries, e)
+		}
+	}
+	c.entries = entries
+}
--- a/backend/lib/cron/cron_test.go
+++ b/backend/lib/cron/cron_test.go
@@ -0,0 +1,702 @@
+package cron
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"strings"
+	"sync"
+	"sync/atomic"
+	"testing"
+	"time"
+)
+
+// Many tests schedule a job for every second, and then wait at most a second
+// for it to run.  This amount is just slightly larger than 1 second to
+// compensate for a few milliseconds of runtime.
+const OneSecond = 1*time.Second + 50*time.Millisecond
+
+type syncWriter struct {
+	wr bytes.Buffer
+	m  sync.Mutex
+}
+
+func (sw *syncWriter) Write(data []byte) (n int, err error) {
+	sw.m.Lock()
+	n, err = sw.wr.Write(data)
+	sw.m.Unlock()
+	return
+}
+
+func (sw *syncWriter) String() string {
+	sw.m.Lock()
+	defer sw.m.Unlock()
+	return sw.wr.String()
+}
+
+func newBufLogger(sw *syncWriter) Logger {
+	return PrintfLogger(log.New(sw, "", log.LstdFlags))
+}
+
+func TestFuncPanicRecovery(t *testing.T) {
+	var buf syncWriter
+	cron := New(WithParser(secondParser),
+		WithChain(Recover(newBufLogger(&buf))))
+	cron.Start()
+	defer cron.Stop()
+	cron.AddFunc("* * * * * ?", func() {
+		panic("YOLO")
+	})
+
+	select {
+	case <-time.After(OneSecond):
+		if !strings.Contains(buf.String(), "YOLO") {
+			t.Error("expected a panic to be logged, got none")
+		}
+		return
+	}
+}
+
+type DummyJob struct{}
+
+func (d DummyJob) Run() {
+	panic("YOLO")
+}
+
+func TestJobPanicRecovery(t *testing.T) {
+	var job DummyJob
+
+	var buf syncWriter
+	cron := New(WithParser(secondParser),
+		WithChain(Recover(newBufLogger(&buf))))
+	cron.Start()
+	defer cron.Stop()
+	cron.AddJob("* * * * * ?", job)
+
+	select {
+	case <-time.After(OneSecond):
+		if !strings.Contains(buf.String(), "YOLO") {
+			t.Error("expected a panic to be logged, got none")
+		}
+		return
+	}
+}
+
+// Start and stop cron with no entries.
+func TestNoEntries(t *testing.T) {
+	cron := newWithSeconds()
+	cron.Start()
+
+	select {
+	case <-time.After(OneSecond):
+		t.Fatal("expected cron will be stopped immediately")
+	case <-stop(cron):
+	}
+}
+
+// Start, stop, then add an entry. Verify entry doesn't run.
+func TestStopCausesJobsToNotRun(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	cron := newWithSeconds()
+	cron.Start()
+	cron.Stop()
+	cron.AddFunc("* * * * * ?", func() { wg.Done() })
+
+	select {
+	case <-time.After(OneSecond):
+		// No job ran!
+	case <-wait(wg):
+		t.Fatal("expected stopped cron does not run any job")
+	}
+}
+
+// Add a job, start cron, expect it runs.
+func TestAddBeforeRunning(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	cron := newWithSeconds()
+	cron.AddFunc("* * * * * ?", func() { wg.Done() })
+	cron.Start()
+	defer cron.Stop()
+
+	// Give cron 2 seconds to run our job (which is always activated).
+	select {
+	case <-time.After(OneSecond):
+		t.Fatal("expected job runs")
+	case <-wait(wg):
+	}
+}
+
+// Start cron, add a job, expect it runs.
+func TestAddWhileRunning(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	cron := newWithSeconds()
+	cron.Start()
+	defer cron.Stop()
+	cron.AddFunc("* * * * * ?", func() { wg.Done() })
+
+	select {
+	case <-time.After(OneSecond):
+		t.Fatal("expected job runs")
+	case <-wait(wg):
+	}
+}
+
+// Test for #34. Adding a job after calling start results in multiple job invocations
+func TestAddWhileRunningWithDelay(t *testing.T) {
+	cron := newWithSeconds()
+	cron.Start()
+	defer cron.Stop()
+	time.Sleep(5 * time.Second)
+	var calls int64
+	cron.AddFunc("* * * * * *", func() { atomic.AddInt64(&calls, 1) })
+
+	<-time.After(OneSecond)
+	if atomic.LoadInt64(&calls) != 1 {
+		t.Errorf("called %d times, expected 1\n", calls)
+	}
+}
+
+// Add a job, remove a job, start cron, expect nothing runs.
+func TestRemoveBeforeRunning(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	cron := newWithSeconds()
+	id, _ := cron.AddFunc("* * * * * ?", func() { wg.Done() })
+	cron.Remove(id)
+	cron.Start()
+	defer cron.Stop()
+
+	select {
+	case <-time.After(OneSecond):
+		// Success, shouldn't run
+	case <-wait(wg):
+		t.FailNow()
+	}
+}
+
+// Start cron, add a job, remove it, expect it doesn't run.
+func TestRemoveWhileRunning(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	cron := newWithSeconds()
+	cron.Start()
+	defer cron.Stop()
+	id, _ := cron.AddFunc("* * * * * ?", func() { wg.Done() })
+	cron.Remove(id)
+
+	select {
+	case <-time.After(OneSecond):
+	case <-wait(wg):
+		t.FailNow()
+	}
+}
+
+// Test timing with Entries.
+func TestSnapshotEntries(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	cron := New()
+	cron.AddFunc("@every 2s", func() { wg.Done() })
+	cron.Start()
+	defer cron.Stop()
+
+	// Cron should fire in 2 seconds. After 1 second, call Entries.
+	select {
+	case <-time.After(OneSecond):
+		cron.Entries()
+	}
+
+	// Even though Entries was called, the cron should fire at the 2 second mark.
+	select {
+	case <-time.After(OneSecond):
+		t.Error("expected job runs at 2 second mark")
+	case <-wait(wg):
+	}
+}
+
+// Test that the entries are correctly sorted.
+// Add a bunch of long-in-the-future entries, and an immediate entry, and ensure
+// that the immediate entry runs immediately.
+// Also: Test that multiple jobs run in the same instant.
+func TestMultipleEntries(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	cron := newWithSeconds()
+	cron.AddFunc("0 0 0 1 1 ?", func() {})
+	cron.AddFunc("* * * * * ?", func() { wg.Done() })
+	id1, _ := cron.AddFunc("* * * * * ?", func() { t.Fatal() })
+	id2, _ := cron.AddFunc("* * * * * ?", func() { t.Fatal() })
+	cron.AddFunc("0 0 0 31 12 ?", func() {})
+	cron.AddFunc("* * * * * ?", func() { wg.Done() })
+
+	cron.Remove(id1)
+	cron.Start()
+	cron.Remove(id2)
+	defer cron.Stop()
+
+	select {
+	case <-time.After(OneSecond):
+		t.Error("expected job run in proper order")
+	case <-wait(wg):
+	}
+}
+
+// Test running the same job twice.
+func TestRunningJobTwice(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	cron := newWithSeconds()
+	cron.AddFunc("0 0 0 1 1 ?", func() {})
+	cron.AddFunc("0 0 0 31 12 ?", func() {})
+	cron.AddFunc("* * * * * ?", func() { wg.Done() })
+
+	cron.Start()
+	defer cron.Stop()
+
+	select {
+	case <-time.After(2 * OneSecond):
+		t.Error("expected job fires 2 times")
+	case <-wait(wg):
+	}
+}
+
+func TestRunningMultipleSchedules(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	cron := newWithSeconds()
+	cron.AddFunc("0 0 0 1 1 ?", func() {})
+	cron.AddFunc("0 0 0 31 12 ?", func() {})
+	cron.AddFunc("* * * * * ?", func() { wg.Done() })
+	cron.Schedule(Every(time.Minute), FuncJob(func() {}))
+	cron.Schedule(Every(time.Second), FuncJob(func() { wg.Done() }))
+	cron.Schedule(Every(time.Hour), FuncJob(func() {}))
+
+	cron.Start()
+	defer cron.Stop()
+
+	select {
+	case <-time.After(2 * OneSecond):
+		t.Error("expected job fires 2 times")
+	case <-wait(wg):
+	}
+}
+
+// Test that the cron is run in the local time zone (as opposed to UTC).
+func TestLocalTimezone(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	now := time.Now()
+	// FIX: Issue #205
+	// This calculation doesn't work in seconds 58 or 59.
+	// Take the easy way out and sleep.
+	if now.Second() >= 58 {
+		time.Sleep(2 * time.Second)
+		now = time.Now()
+	}
+	spec := fmt.Sprintf("%d,%d %d %d %d %d ?",
+		now.Second()+1, now.Second()+2, now.Minute(), now.Hour(), now.Day(), now.Month())
+
+	cron := newWithSeconds()
+	cron.AddFunc(spec, func() { wg.Done() })
+	cron.Start()
+	defer cron.Stop()
+
+	select {
+	case <-time.After(OneSecond * 2):
+		t.Error("expected job fires 2 times")
+	case <-wait(wg):
+	}
+}
+
+// Test that the cron is run in the given time zone (as opposed to local).
+func TestNonLocalTimezone(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(2)
+
+	loc, err := time.LoadLocation("Atlantic/Cape_Verde")
+	if err != nil {
+		fmt.Printf("Failed to load time zone Atlantic/Cape_Verde: %+v", err)
+		t.Fail()
+	}
+
+	now := time.Now().In(loc)
+	// FIX: Issue #205
+	// This calculation doesn't work in seconds 58 or 59.
+	// Take the easy way out and sleep.
+	if now.Second() >= 58 {
+		time.Sleep(2 * time.Second)
+		now = time.Now().In(loc)
+	}
+	spec := fmt.Sprintf("%d,%d %d %d %d %d ?",
+		now.Second()+1, now.Second()+2, now.Minute(), now.Hour(), now.Day(), now.Month())
+
+	cron := New(WithLocation(loc), WithParser(secondParser))
+	cron.AddFunc(spec, func() { wg.Done() })
+	cron.Start()
+	defer cron.Stop()
+
+	select {
+	case <-time.After(OneSecond * 2):
+		t.Error("expected job fires 2 times")
+	case <-wait(wg):
+	}
+}
+
+// Test that calling stop before start silently returns without
+// blocking the stop channel.
+func TestStopWithoutStart(t *testing.T) {
+	cron := New()
+	cron.Stop()
+}
+
+type testJob struct {
+	wg   *sync.WaitGroup
+	name string
+}
+
+func (t testJob) Run() {
+	t.wg.Done()
+}
+
+// Test that adding an invalid job spec returns an error
+func TestInvalidJobSpec(t *testing.T) {
+	cron := New()
+	_, err := cron.AddJob("this will not parse", nil)
+	if err == nil {
+		t.Errorf("expected an error with invalid spec, got nil")
+	}
+}
+
+// Test blocking run method behaves as Start()
+func TestBlockingRun(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	cron := newWithSeconds()
+	cron.AddFunc("* * * * * ?", func() { wg.Done() })
+
+	var unblockChan = make(chan struct{})
+
+	go func() {
+		cron.Run()
+		close(unblockChan)
+	}()
+	defer cron.Stop()
+
+	select {
+	case <-time.After(OneSecond):
+		t.Error("expected job fires")
+	case <-unblockChan:
+		t.Error("expected that Run() blocks")
+	case <-wait(wg):
+	}
+}
+
+// Test that double-running is a no-op
+func TestStartNoop(t *testing.T) {
+	var tickChan = make(chan struct{}, 2)
+
+	cron := newWithSeconds()
+	cron.AddFunc("* * * * * ?", func() {
+		tickChan <- struct{}{}
+	})
+
+	cron.Start()
+	defer cron.Stop()
+
+	// Wait for the first firing to ensure the runner is going
+	<-tickChan
+
+	cron.Start()
+
+	<-tickChan
+
+	// Fail if this job fires again in a short period, indicating a double-run
+	select {
+	case <-time.After(time.Millisecond):
+	case <-tickChan:
+		t.Error("expected job fires exactly twice")
+	}
+}
+
+// Simple test using Runnables.
+func TestJob(t *testing.T) {
+	wg := &sync.WaitGroup{}
+	wg.Add(1)
+
+	cron := newWithSeconds()
+	cron.AddJob("0 0 0 30 Feb ?", testJob{wg, "job0"})
+	cron.AddJob("0 0 0 1 1 ?", testJob{wg, "job1"})
+	job2, _ := cron.AddJob("* * * * * ?", testJob{wg, "job2"})
+	cron.AddJob("1 0 0 1 1 ?", testJob{wg, "job3"})
+	cron.Schedule(Every(5*time.Second+5*time.Nanosecond), testJob{wg, "job4"})
+	job5 := cron.Schedule(Every(5*time.Minute), testJob{wg, "job5"})
+
+	// Test getting an Entry pre-Start.
+	if actualName := cron.Entry(job2).Job.(testJob).name; actualName != "job2" {
+		t.Error("wrong job retrieved:", actualName)
+	}
+	if actualName := cron.Entry(job5).Job.(testJob).name; actualName != "job5" {
+		t.Error("wrong job retrieved:", actualName)
+	}
+
+	cron.Start()
+	defer cron.Stop()
+
+	select {
+	case <-time.After(OneSecond):
+		t.FailNow()
+	case <-wait(wg):
+	}
+
+	// Ensure the entries are in the right order.
+	expecteds := []string{"job2", "job4", "job5", "job1", "job3", "job0"}
+
+	var actuals []string
+	for _, entry := range cron.Entries() {
+		actuals = append(actuals, entry.Job.(testJob).name)
+	}
+
+	for i, expected := range expecteds {
+		if actuals[i] != expected {
+			t.Fatalf("Jobs not in the right order.  (expected) %s != %s (actual)", expecteds, actuals)
+		}
+	}
+
+	// Test getting Entries.
+	if actualName := cron.Entry(job2).Job.(testJob).name; actualName != "job2" {
+		t.Error("wrong job retrieved:", actualName)
+	}
+	if actualName := cron.Entry(job5).Job.(testJob).name; actualName != "job5" {
+		t.Error("wrong job retrieved:", actualName)
+	}
+}
+
+// Issue #206
+// Ensure that the next run of a job after removing an entry is accurate.
+func TestScheduleAfterRemoval(t *testing.T) {
+	var wg1 sync.WaitGroup
+	var wg2 sync.WaitGroup
+	wg1.Add(1)
+	wg2.Add(1)
+
+	// The first time this job is run, set a timer and remove the other job
+	// 750ms later. Correct behavior would be to still run the job again in
+	// 250ms, but the bug would cause it to run instead 1s later.
+
+	var calls int
+	var mu sync.Mutex
+
+	cron := newWithSeconds()
+	hourJob := cron.Schedule(Every(time.Hour), FuncJob(func() {}))
+	cron.Schedule(Every(time.Second), FuncJob(func() {
+		mu.Lock()
+		defer mu.Unlock()
+		switch calls {
+		case 0:
+			wg1.Done()
+			calls++
+		case 1:
+			time.Sleep(750 * time.Millisecond)
+			cron.Remove(hourJob)
+			calls++
+		case 2:
+			calls++
+			wg2.Done()
+		case 3:
+			panic("unexpected 3rd call")
+		}
+	}))
+
+	cron.Start()
+	defer cron.Stop()
+
+	// the first run might be any length of time 0 - 1s, since the schedule
+	// rounds to the second. wait for the first run to true up.
+	wg1.Wait()
+
+	select {
+	case <-time.After(2 * OneSecond):
+		t.Error("expected job fires 2 times")
+	case <-wait(&wg2):
+	}
+}
+
+type ZeroSchedule struct{}
+
+func (*ZeroSchedule) Next(time.Time) time.Time {
+	return time.Time{}
+}
+
+// Tests that job without time does not run
+func TestJobWithZeroTimeDoesNotRun(t *testing.T) {
+	cron := newWithSeconds()
+	var calls int64
+	cron.AddFunc("* * * * * *", func() { atomic.AddInt64(&calls, 1) })
+	cron.Schedule(new(ZeroSchedule), FuncJob(func() { t.Error("expected zero task will not run") }))
+	cron.Start()
+	defer cron.Stop()
+	<-time.After(OneSecond)
+	if atomic.LoadInt64(&calls) != 1 {
+		t.Errorf("called %d times, expected 1\n", calls)
+	}
+}
+
+func TestStopAndWait(t *testing.T) {
+	t.Run("nothing running, returns immediately", func(t *testing.T) {
+		cron := newWithSeconds()
+		cron.Start()
+		ctx := cron.Stop()
+		select {
+		case <-ctx.Done():
+		case <-time.After(time.Millisecond):
+			t.Error("context was not done immediately")
+		}
+	})
+
+	t.Run("repeated calls to Stop", func(t *testing.T) {
+		cron := newWithSeconds()
+		cron.Start()
+		_ = cron.Stop()
+		time.Sleep(time.Millisecond)
+		ctx := cron.Stop()
+		select {
+		case <-ctx.Done():
+		case <-time.After(time.Millisecond):
+			t.Error("context was not done immediately")
+		}
+	})
+
+	t.Run("a couple fast jobs added, still returns immediately", func(t *testing.T) {
+		cron := newWithSeconds()
+		cron.AddFunc("* * * * * *", func() {})
+		cron.Start()
+		cron.AddFunc("* * * * * *", func() {})
+		cron.AddFunc("* * * * * *", func() {})
+		cron.AddFunc("* * * * * *", func() {})
+		time.Sleep(time.Second)
+		ctx := cron.Stop()
+		select {
+		case <-ctx.Done():
+		case <-time.After(time.Millisecond):
+			t.Error("context was not done immediately")
+		}
+	})
+
+	t.Run("a couple fast jobs and a slow job added, waits for slow job", func(t *testing.T) {
+		cron := newWithSeconds()
+		cron.AddFunc("* * * * * *", func() {})
+		cron.Start()
+		cron.AddFunc("* * * * * *", func() { time.Sleep(2 * time.Second) })
+		cron.AddFunc("* * * * * *", func() {})
+		time.Sleep(time.Second)
+
+		ctx := cron.Stop()
+
+		// Verify that it is not done for at least 750ms
+		select {
+		case <-ctx.Done():
+			t.Error("context was done too quickly immediately")
+		case <-time.After(750 * time.Millisecond):
+			// expected, because the job sleeping for 1 second is still running
+		}
+
+		// Verify that it IS done in the next 500ms (giving 250ms buffer)
+		select {
+		case <-ctx.Done():
+			// expected
+		case <-time.After(1500 * time.Millisecond):
+			t.Error("context not done after job should have completed")
+		}
+	})
+
+	t.Run("repeated calls to stop, waiting for completion and after", func(t *testing.T) {
+		cron := newWithSeconds()
+		cron.AddFunc("* * * * * *", func() {})
+		cron.AddFunc("* * * * * *", func() { time.Sleep(2 * time.Second) })
+		cron.Start()
+		cron.AddFunc("* * * * * *", func() {})
+		time.Sleep(time.Second)
+		ctx := cron.Stop()
+		ctx2 := cron.Stop()
+
+		// Verify that it is not done for at least 1500ms
+		select {
+		case <-ctx.Done():
+			t.Error("context was done too quickly immediately")
+		case <-ctx2.Done():
+			t.Error("context2 was done too quickly immediately")
+		case <-time.After(1500 * time.Millisecond):
+			// expected, because the job sleeping for 2 seconds is still running
+		}
+
+		// Verify that it IS done in the next 1s (giving 500ms buffer)
+		select {
+		case <-ctx.Done():
+			// expected
+		case <-time.After(time.Second):
+			t.Error("context not done after job should have completed")
+		}
+
+		// Verify that ctx2 is also done.
+		select {
+		case <-ctx2.Done():
+			// expected
+		case <-time.After(time.Millisecond):
+			t.Error("context2 not done even though context1 is")
+		}
+
+		// Verify that a new context retrieved from stop is immediately done.
+		ctx3 := cron.Stop()
+		select {
+		case <-ctx3.Done():
+			// expected
+		case <-time.After(time.Millisecond):
+			t.Error("context not done even when cron Stop is completed")
+		}
+
+	})
+}
+
+func TestMultiThreadedStartAndStop(t *testing.T) {
+	cron := New()
+	go cron.Run()
+	time.Sleep(2 * time.Millisecond)
+	cron.Stop()
+}
+
+func wait(wg *sync.WaitGroup) chan bool {
+	ch := make(chan bool)
+	go func() {
+		wg.Wait()
+		ch <- true
+	}()
+	return ch
+}
+
+func stop(cron *Cron) chan bool {
+	ch := make(chan bool)
+	go func() {
+		cron.Stop()
+		ch <- true
+	}()
+	return ch
+}
+
+// newWithSeconds returns a Cron with the seconds field enabled.
+func newWithSeconds() *Cron {
+	return New(WithParser(secondParser), WithChain())
+}
--- a/backend/lib/cron/doc.go
+++ b/backend/lib/cron/doc.go
@@ -0,0 +1,212 @@
+/*
+Package cron implements a cron spec parser and job runner.
+
+Usage
+
+Callers may register Funcs to be invoked on a given schedule.  Cron will run
+them in their own goroutines.
+
+	c := cron.New()
+	c.AddFunc("30 * * * *", func() { fmt.Println("Every hour on the half hour") })
+	c.AddFunc("30 3-6,20-23 * * *", func() { fmt.Println(".. in the range 3-6am, 8-11pm") })
+	c.AddFunc("CRON_TZ=Asia/Tokyo 30 04 * * * *", func() { fmt.Println("Runs at 04:30 Tokyo time every day") })
+	c.AddFunc("@hourly",      func() { fmt.Println("Every hour, starting an hour from now") })
+	c.AddFunc("@every 1h30m", func() { fmt.Println("Every hour thirty, starting an hour thirty from now") })
+	c.Start()
+	..
+	// Funcs are invoked in their own goroutine, asynchronously.
+	...
+	// Funcs may also be added to a running Cron
+	c.AddFunc("@daily", func() { fmt.Println("Every day") })
+	..
+	// Inspect the cron job entries' next and previous run times.
+	inspect(c.Entries())
+	..
+	c.Stop()  // Stop the scheduler (does not stop any jobs already running).
+
+CRON Expression Format
+
+A cron expression represents a set of times, using 5 space-separated fields.
+
+	Field name   | Mandatory? | Allowed values  | Allowed special characters
+	----------   | ---------- | --------------  | --------------------------
+	Minutes      | Yes        | 0-59            | * / , -
+	Hours        | Yes        | 0-23            | * / , -
+	Day of month | Yes        | 1-31            | * / , - ?
+	Month        | Yes        | 1-12 or JAN-DEC | * / , -
+	Day of week  | Yes        | 0-6 or SUN-SAT  | * / , - ?
+
+Month and Day-of-week field values are case insensitive.  "SUN", "Sun", and
+"sun" are equally accepted.
+
+The specific interpretation of the format is based on the Cron Wikipedia page:
+https://en.wikipedia.org/wiki/Cron
+
+Alternative Formats
+
+Alternative Cron expression formats support other fields like seconds. You can
+implement that by creating a custom Parser as follows.
+
+      cron.New(
+          cron.WithParser(
+              cron.SecondOptional | cron.Minute | cron.Hour | cron.Dom | cron.Month | cron.Dow | cron.Descriptor))
+
+The most popular alternative Cron expression format is Quartz:
+http://www.quartz-scheduler.org/documentation/quartz-2.x/tutorials/crontrigger.html
+
+Special Characters
+
+Asterisk ( * )
+
+The asterisk indicates that the cron expression will match for all values of the
+field; e.g., using an asterisk in the 5th field (month) would indicate every
+month.
+
+Slash ( / )
+
+Slashes are used to describe increments of ranges. For example 3-59/15 in the
+1st field (minutes) would indicate the 3rd minute of the hour and every 15
+minutes thereafter. The form "*\/..." is equivalent to the form "first-last/...",
+that is, an increment over the largest possible range of the field.  The form
+"N/..." is accepted as meaning "N-MAX/...", that is, starting at N, use the
+increment until the end of that specific range.  It does not wrap around.
+
+Comma ( , )
+
+Commas are used to separate items of a list. For example, using "MON,WED,FRI" in
+the 5th field (day of week) would mean Mondays, Wednesdays and Fridays.
+
+Hyphen ( - )
+
+Hyphens are used to define ranges. For example, 9-17 would indicate every
+hour between 9am and 5pm inclusive.
+
+Question mark ( ? )
+
+Question mark may be used instead of '*' for leaving either day-of-month or
+day-of-week blank.
+
+Predefined schedules
+
+You may use one of several pre-defined schedules in place of a cron expression.
+
+	Entry                  | Description                                | Equivalent To
+	-----                  | -----------                                | -------------
+	@yearly (or @annually) | Run once a year, midnight, Jan. 1st        | 0 0 1 1 *
+	@monthly               | Run once a month, midnight, first of month | 0 0 1 * *
+	@weekly                | Run once a week, midnight between Sat/Sun  | 0 0 * * 0
+	@daily (or @midnight)  | Run once a day, midnight                   | 0 0 * * *
+	@hourly                | Run once an hour, beginning of hour        | 0 * * * *
+
+Intervals
+
+You may also schedule a job to execute at fixed intervals, starting at the time it's added
+or cron is run. This is supported by formatting the cron spec like this:
+
+    @every <duration>
+
+where "duration" is a string accepted by time.ParseDuration
+(http://golang.org/pkg/time/#ParseDuration).
+
+For example, "@every 1h30m10s" would indicate a schedule that activates after
+1 hour, 30 minutes, 10 seconds, and then every interval after that.
+
+Note: The interval does not take the job runtime into account.  For example,
+if a job takes 3 minutes to run, and it is scheduled to run every 5 minutes,
+it will have only 2 minutes of idle time between each run.
+
+Time zones
+
+By default, all interpretation and scheduling is done in the machine's local
+time zone (time.Local). You can specify a different time zone on construction:
+
+      cron.New(
+          cron.WithLocation(time.UTC))
+
+Individual cron schedules may also override the time zone they are to be
+interpreted in by providing an additional space-separated field at the beginning
+of the cron spec, of the form "CRON_TZ=Asia/Tokyo".
+
+For example:
+
+	# Runs at 6am in time.Local
+	cron.New().AddFunc("0 6 * * ?", ...)
+
+	# Runs at 6am in America/New_York
+	nyc, _ := time.LoadLocation("America/New_York")
+	c := cron.New(cron.WithLocation(nyc))
+	c.AddFunc("0 6 * * ?", ...)
+
+	# Runs at 6am in Asia/Tokyo
+	cron.New().AddFunc("CRON_TZ=Asia/Tokyo 0 6 * * ?", ...)
+
+	# Runs at 6am in Asia/Tokyo
+	c := cron.New(cron.WithLocation(nyc))
+	c.SetLocation("America/New_York")
+	c.AddFunc("CRON_TZ=Asia/Tokyo 0 6 * * ?", ...)
+
+The prefix "TZ=(TIME ZONE)" is also supported for legacy compatibility.
+
+Be aware that jobs scheduled during daylight-savings leap-ahead transitions will
+not be run!
+
+Job Wrappers / Chain
+
+A Cron runner may be configured with a chain of job wrappers to add
+cross-cutting functionality to all submitted jobs. For example, they may be used
+to achieve the following effects:
+
+  - Recover any panics from jobs (activated by default)
+  - Delay a job's execution if the previous run hasn't completed yet
+  - Skip a job's execution if the previous run hasn't completed yet
+  - Log each job's invocations
+
+Install wrappers for all jobs added to a cron using the `cron.WithChain` option:
+
+	cron.New(cron.WithChain(
+		cron.SkipIfStillRunning(logger),
+	))
+
+Install wrappers for individual jobs by explicitly wrapping them:
+
+	job = cron.NewChain(
+		cron.SkipIfStillRunning(logger),
+	).Then(job)
+
+Thread safety
+
+Since the Cron service runs concurrently with the calling code, some amount of
+care must be taken to ensure proper synchronization.
+
+All cron methods are designed to be correctly synchronized as long as the caller
+ensures that invocations have a clear happens-before ordering between them.
+
+Logging
+
+Cron defines a Logger interface that is a subset of the one defined in
+github.com/go-logr/logr. It has two logging levels (Info and Error), and
+parameters are key/value pairs. This makes it possible for cron logging to plug
+into structured logging systems. An adapter, [Verbose]PrintfLogger, is provided
+to wrap the standard library *log.Logger.
+
+For additional insight into Cron operations, verbose logging may be activated
+which will record job runs, scheduling decisions, and added or removed jobs.
+Activate it with a one-off logger as follows:
+
+	cron.New(
+		cron.WithLogger(
+			cron.VerbosePrintfLogger(log.New(os.Stdout, "cron: ", log.LstdFlags))))
+
+
+Implementation
+
+Cron entries are stored in an array, sorted by their next activation time.  Cron
+sleeps until the next job is due to be run.
+
+Upon waking:
+ - it runs each entry that is active on that second
+ - it calculates the next run times for the jobs that were run
+ - it re-sorts the array of entries by next activation time.
+ - it goes to sleep until the soonest job.
+*/
+package cron
--- a/backend/lib/cron/logger.go
+++ b/backend/lib/cron/logger.go
@@ -0,0 +1,86 @@
+package cron
+
+import (
+	"io/ioutil"
+	"log"
+	"os"
+	"strings"
+	"time"
+)
+
+// DefaultLogger is used by Cron if none is specified.
+var DefaultLogger Logger = PrintfLogger(log.New(os.Stdout, "cron: ", log.LstdFlags))
+
+// DiscardLogger can be used by callers to discard all log messages.
+var DiscardLogger Logger = PrintfLogger(log.New(ioutil.Discard, "", 0))
+
+// Logger is the interface used in this package for logging, so that any backend
+// can be plugged in. It is a subset of the github.com/go-logr/logr interface.
+type Logger interface {
+	// Info logs routine messages about cron's operation.
+	Info(msg string, keysAndValues ...interface{})
+	// Error logs an error condition.
+	Error(err error, msg string, keysAndValues ...interface{})
+}
+
+// PrintfLogger wraps a Printf-based logger (such as the standard library "log")
+// into an implementation of the Logger interface which logs errors only.
+func PrintfLogger(l interface{ Printf(string, ...interface{}) }) Logger {
+	return printfLogger{l, false}
+}
+
+// VerbosePrintfLogger wraps a Printf-based logger (such as the standard library
+// "log") into an implementation of the Logger interface which logs everything.
+func VerbosePrintfLogger(l interface{ Printf(string, ...interface{}) }) Logger {
+	return printfLogger{l, true}
+}
+
+type printfLogger struct {
+	logger  interface{ Printf(string, ...interface{}) }
+	logInfo bool
+}
+
+func (pl printfLogger) Info(msg string, keysAndValues ...interface{}) {
+	if pl.logInfo {
+		keysAndValues = formatTimes(keysAndValues)
+		pl.logger.Printf(
+			formatString(len(keysAndValues)),
+			append([]interface{}{msg}, keysAndValues...)...)
+	}
+}
+
+func (pl printfLogger) Error(err error, msg string, keysAndValues ...interface{}) {
+	keysAndValues = formatTimes(keysAndValues)
+	pl.logger.Printf(
+		formatString(len(keysAndValues)+2),
+		append([]interface{}{msg, "error", err}, keysAndValues...)...)
+}
+
+// formatString returns a logfmt-like format string for the number of
+// key/values.
+func formatString(numKeysAndValues int) string {
+	var sb strings.Builder
+	sb.WriteString("%s")
+	if numKeysAndValues > 0 {
+		sb.WriteString(", ")
+	}
+	for i := 0; i < numKeysAndValues/2; i++ {
+		if i > 0 {
+			sb.WriteString(", ")
+		}
+		sb.WriteString("%v=%v")
+	}
+	return sb.String()
+}
+
+// formatTimes formats any time.Time values as RFC3339.
+func formatTimes(keysAndValues []interface{}) []interface{} {
+	var formattedArgs []interface{}
+	for _, arg := range keysAndValues {
+		if t, ok := arg.(time.Time); ok {
+			arg = t.Format(time.RFC3339)
+		}
+		formattedArgs = append(formattedArgs, arg)
+	}
+	return formattedArgs
+}
--- a/backend/lib/cron/option.go
+++ b/backend/lib/cron/option.go
@@ -0,0 +1,45 @@
+package cron
+
+import (
+	"time"
+)
+
+// Option represents a modification to the default behavior of a Cron.
+type Option func(*Cron)
+
+// WithLocation overrides the timezone of the cron instance.
+func WithLocation(loc *time.Location) Option {
+	return func(c *Cron) {
+		c.location = loc
+	}
+}
+
+// WithSeconds overrides the parser used for interpreting job schedules to
+// include a seconds field as the first one.
+func WithSeconds() Option {
+	return WithParser(NewParser(
+		Second | Minute | Hour | Dom | Month | Dow | Descriptor,
+	))
+}
+
+// WithParser overrides the parser used for interpreting job schedules.
+func WithParser(p Parser) Option {
+	return func(c *Cron) {
+		c.parser = p
+	}
+}
+
+// WithChain specifies Job wrappers to apply to all jobs added to this cron.
+// Refer to the Chain* functions in this package for provided wrappers.
+func WithChain(wrappers ...JobWrapper) Option {
+	return func(c *Cron) {
+		c.chain = NewChain(wrappers...)
+	}
+}
+
+// WithLogger uses the provided logger.
+func WithLogger(logger Logger) Option {
+	return func(c *Cron) {
+		c.logger = logger
+	}
+}
--- a/backend/lib/cron/option_test.go
+++ b/backend/lib/cron/option_test.go
@@ -0,0 +1,42 @@
+package cron
+
+import (
+	"log"
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestWithLocation(t *testing.T) {
+	c := New(WithLocation(time.UTC))
+	if c.location != time.UTC {
+		t.Errorf("expected UTC, got %v", c.location)
+	}
+}
+
+func TestWithParser(t *testing.T) {
+	var parser = NewParser(Dow)
+	c := New(WithParser(parser))
+	if c.parser != parser {
+		t.Error("expected provided parser")
+	}
+}
+
+func TestWithVerboseLogger(t *testing.T) {
+	var buf syncWriter
+	var logger = log.New(&buf, "", log.LstdFlags)
+	c := New(WithLogger(VerbosePrintfLogger(logger)))
+	if c.logger.(printfLogger).logger != logger {
+		t.Error("expected provided logger")
+	}
+
+	c.AddFunc("@every 1s", func() {})
+	c.Start()
+	time.Sleep(OneSecond)
+	c.Stop()
+	out := buf.String()
+	if !strings.Contains(out, "schedule,") ||
+		!strings.Contains(out, "run,") {
+		t.Error("expected to see some actions, got:", out)
+	}
+}
--- a/backend/lib/cron/parser.go
+++ b/backend/lib/cron/parser.go
@@ -0,0 +1,434 @@
+package cron
+
+import (
+	"fmt"
+	"math"
+	"strconv"
+	"strings"
+	"time"
+)
+
+// Configuration options for creating a parser. Most options specify which
+// fields should be included, while others enable features. If a field is not
+// included the parser will assume a default value. These options do not change
+// the order fields are parse in.
+type ParseOption int
+
+const (
+	Second         ParseOption = 1 << iota // Seconds field, default 0
+	SecondOptional                         // Optional seconds field, default 0
+	Minute                                 // Minutes field, default 0
+	Hour                                   // Hours field, default 0
+	Dom                                    // Day of month field, default *
+	Month                                  // Month field, default *
+	Dow                                    // Day of week field, default *
+	DowOptional                            // Optional day of week field, default *
+	Descriptor                             // Allow descriptors such as @monthly, @weekly, etc.
+)
+
+var places = []ParseOption{
+	Second,
+	Minute,
+	Hour,
+	Dom,
+	Month,
+	Dow,
+}
+
+var defaults = []string{
+	"0",
+	"0",
+	"0",
+	"*",
+	"*",
+	"*",
+}
+
+// A custom Parser that can be configured.
+type Parser struct {
+	options ParseOption
+}
+
+// NewParser creates a Parser with custom options.
+//
+// It panics if more than one Optional is given, since it would be impossible to
+// correctly infer which optional is provided or missing in general.
+//
+// Examples
+//
+//  // Standard parser without descriptors
+//  specParser := NewParser(Minute | Hour | Dom | Month | Dow)
+//  sched, err := specParser.Parse("0 0 15 */3 *")
+//
+//  // Same as above, just excludes time fields
+//  subsParser := NewParser(Dom | Month | Dow)
+//  sched, err := specParser.Parse("15 */3 *")
+//
+//  // Same as above, just makes Dow optional
+//  subsParser := NewParser(Dom | Month | DowOptional)
+//  sched, err := specParser.Parse("15 */3")
+//
+func NewParser(options ParseOption) Parser {
+	optionals := 0
+	if options&DowOptional > 0 {
+		optionals++
+	}
+	if options&SecondOptional > 0 {
+		optionals++
+	}
+	if optionals > 1 {
+		panic("multiple optionals may not be configured")
+	}
+	return Parser{options}
+}
+
+// Parse returns a new crontab schedule representing the given spec.
+// It returns a descriptive error if the spec is not valid.
+// It accepts crontab specs and features configured by NewParser.
+func (p Parser) Parse(spec string) (Schedule, error) {
+	if len(spec) == 0 {
+		return nil, fmt.Errorf("empty spec string")
+	}
+
+	// Extract timezone if present
+	var loc = time.Local
+	if strings.HasPrefix(spec, "TZ=") || strings.HasPrefix(spec, "CRON_TZ=") {
+		var err error
+		i := strings.Index(spec, " ")
+		eq := strings.Index(spec, "=")
+		if loc, err = time.LoadLocation(spec[eq+1 : i]); err != nil {
+			return nil, fmt.Errorf("provided bad location %s: %v", spec[eq+1:i], err)
+		}
+		spec = strings.TrimSpace(spec[i:])
+	}
+
+	// Handle named schedules (descriptors), if configured
+	if strings.HasPrefix(spec, "@") {
+		if p.options&Descriptor == 0 {
+			return nil, fmt.Errorf("parser does not accept descriptors: %v", spec)
+		}
+		return parseDescriptor(spec, loc)
+	}
+
+	// Split on whitespace.
+	fields := strings.Fields(spec)
+
+	// Validate & fill in any omitted or optional fields
+	var err error
+	fields, err = normalizeFields(fields, p.options)
+	if err != nil {
+		return nil, err
+	}
+
+	field := func(field string, r bounds) uint64 {
+		if err != nil {
+			return 0
+		}
+		var bits uint64
+		bits, err = getField(field, r)
+		return bits
+	}
+
+	var (
+		second     = field(fields[0], seconds)
+		minute     = field(fields[1], minutes)
+		hour       = field(fields[2], hours)
+		dayofmonth = field(fields[3], dom)
+		month      = field(fields[4], months)
+		dayofweek  = field(fields[5], dow)
+	)
+	if err != nil {
+		return nil, err
+	}
+
+	return &SpecSchedule{
+		Second:   second,
+		Minute:   minute,
+		Hour:     hour,
+		Dom:      dayofmonth,
+		Month:    month,
+		Dow:      dayofweek,
+		Location: loc,
+	}, nil
+}
+
+// normalizeFields takes a subset set of the time fields and returns the full set
+// with defaults (zeroes) populated for unset fields.
+//
+// As part of performing this function, it also validates that the provided
+// fields are compatible with the configured options.
+func normalizeFields(fields []string, options ParseOption) ([]string, error) {
+	// Validate optionals & add their field to options
+	optionals := 0
+	if options&SecondOptional > 0 {
+		options |= Second
+		optionals++
+	}
+	if options&DowOptional > 0 {
+		options |= Dow
+		optionals++
+	}
+	if optionals > 1 {
+		return nil, fmt.Errorf("multiple optionals may not be configured")
+	}
+
+	// Figure out how many fields we need
+	max := 0
+	for _, place := range places {
+		if options&place > 0 {
+			max++
+		}
+	}
+	min := max - optionals
+
+	// Validate number of fields
+	if count := len(fields); count < min || count > max {
+		if min == max {
+			return nil, fmt.Errorf("expected exactly %d fields, found %d: %s", min, count, fields)
+		}
+		return nil, fmt.Errorf("expected %d to %d fields, found %d: %s", min, max, count, fields)
+	}
+
+	// Populate the optional field if not provided
+	if min < max && len(fields) == min {
+		switch {
+		case options&DowOptional > 0:
+			fields = append(fields, defaults[5]) // TODO: improve access to default
+		case options&SecondOptional > 0:
+			fields = append([]string{defaults[0]}, fields...)
+		default:
+			return nil, fmt.Errorf("unknown optional field")
+		}
+	}
+
+	// Populate all fields not part of options with their defaults
+	n := 0
+	expandedFields := make([]string, len(places))
+	copy(expandedFields, defaults)
+	for i, place := range places {
+		if options&place > 0 {
+			expandedFields[i] = fields[n]
+			n++
+		}
+	}
+	return expandedFields, nil
+}
+
+var standardParser = NewParser(
+	Minute | Hour | Dom | Month | Dow | Descriptor,
+)
+
+// ParseStandard returns a new crontab schedule representing the given
+// standardSpec (https://en.wikipedia.org/wiki/Cron). It requires 5 entries
+// representing: minute, hour, day of month, month and day of week, in that
+// order. It returns a descriptive error if the spec is not valid.
+//
+// It accepts
+//   - Standard crontab specs, e.g. "* * * * ?"
+//   - Descriptors, e.g. "@midnight", "@every 1h30m"
+func ParseStandard(standardSpec string) (Schedule, error) {
+	return standardParser.Parse(standardSpec)
+}
+
+// getField returns an Int with the bits set representing all of the times that
+// the field represents or error parsing field value.  A "field" is a comma-separated
+// list of "ranges".
+func getField(field string, r bounds) (uint64, error) {
+	var bits uint64
+	ranges := strings.FieldsFunc(field, func(r rune) bool { return r == ',' })
+	for _, expr := range ranges {
+		bit, err := getRange(expr, r)
+		if err != nil {
+			return bits, err
+		}
+		bits |= bit
+	}
+	return bits, nil
+}
+
+// getRange returns the bits indicated by the given expression:
+//   number | number "-" number [ "/" number ]
+// or error parsing range.
+func getRange(expr string, r bounds) (uint64, error) {
+	var (
+		start, end, step uint
+		rangeAndStep     = strings.Split(expr, "/")
+		lowAndHigh       = strings.Split(rangeAndStep[0], "-")
+		singleDigit      = len(lowAndHigh) == 1
+		err              error
+	)
+
+	var extra uint64
+	if lowAndHigh[0] == "*" || lowAndHigh[0] == "?" {
+		start = r.min
+		end = r.max
+		extra = starBit
+	} else {
+		start, err = parseIntOrName(lowAndHigh[0], r.names)
+		if err != nil {
+			return 0, err
+		}
+		switch len(lowAndHigh) {
+		case 1:
+			end = start
+		case 2:
+			end, err = parseIntOrName(lowAndHigh[1], r.names)
+			if err != nil {
+				return 0, err
+			}
+		default:
+			return 0, fmt.Errorf("too many hyphens: %s", expr)
+		}
+	}
+
+	switch len(rangeAndStep) {
+	case 1:
+		step = 1
+	case 2:
+		step, err = mustParseInt(rangeAndStep[1])
+		if err != nil {
+			return 0, err
+		}
+
+		// Special handling: "N/step" means "N-max/step".
+		if singleDigit {
+			end = r.max
+		}
+		if step > 1 {
+			extra = 0
+		}
+	default:
+		return 0, fmt.Errorf("too many slashes: %s", expr)
+	}
+
+	if start < r.min {
+		return 0, fmt.Errorf("beginning of range (%d) below minimum (%d): %s", start, r.min, expr)
+	}
+	if end > r.max {
+		return 0, fmt.Errorf("end of range (%d) above maximum (%d): %s", end, r.max, expr)
+	}
+	if start > end {
+		return 0, fmt.Errorf("beginning of range (%d) beyond end of range (%d): %s", start, end, expr)
+	}
+	if step == 0 {
+		return 0, fmt.Errorf("step of range should be a positive number: %s", expr)
+	}
+
+	return getBits(start, end, step) | extra, nil
+}
+
+// parseIntOrName returns the (possibly-named) integer contained in expr.
+func parseIntOrName(expr string, names map[string]uint) (uint, error) {
+	if names != nil {
+		if namedInt, ok := names[strings.ToLower(expr)]; ok {
+			return namedInt, nil
+		}
+	}
+	return mustParseInt(expr)
+}
+
+// mustParseInt parses the given expression as an int or returns an error.
+func mustParseInt(expr string) (uint, error) {
+	num, err := strconv.Atoi(expr)
+	if err != nil {
+		return 0, fmt.Errorf("failed to parse int from %s: %s", expr, err)
+	}
+	if num < 0 {
+		return 0, fmt.Errorf("negative number (%d) not allowed: %s", num, expr)
+	}
+
+	return uint(num), nil
+}
+
+// getBits sets all bits in the range [min, max], modulo the given step size.
+func getBits(min, max, step uint) uint64 {
+	var bits uint64
+
+	// If step is 1, use shifts.
+	if step == 1 {
+		return ^(math.MaxUint64 << (max + 1)) & (math.MaxUint64 << min)
+	}
+
+	// Else, use a simple loop.
+	for i := min; i <= max; i += step {
+		bits |= 1 << i
+	}
+	return bits
+}
+
+// all returns all bits within the given bounds.  (plus the star bit)
+func all(r bounds) uint64 {
+	return getBits(r.min, r.max, 1) | starBit
+}
+
+// parseDescriptor returns a predefined schedule for the expression, or error if none matches.
+func parseDescriptor(descriptor string, loc *time.Location) (Schedule, error) {
+	switch descriptor {
+	case "@yearly", "@annually":
+		return &SpecSchedule{
+			Second:   1 << seconds.min,
+			Minute:   1 << minutes.min,
+			Hour:     1 << hours.min,
+			Dom:      1 << dom.min,
+			Month:    1 << months.min,
+			Dow:      all(dow),
+			Location: loc,
+		}, nil
+
+	case "@monthly":
+		return &SpecSchedule{
+			Second:   1 << seconds.min,
+			Minute:   1 << minutes.min,
+			Hour:     1 << hours.min,
+			Dom:      1 << dom.min,
+			Month:    all(months),
+			Dow:      all(dow),
+			Location: loc,
+		}, nil
+
+	case "@weekly":
+		return &SpecSchedule{
+			Second:   1 << seconds.min,
+			Minute:   1 << minutes.min,
+			Hour:     1 << hours.min,
+			Dom:      all(dom),
+			Month:    all(months),
+			Dow:      1 << dow.min,
+			Location: loc,
+		}, nil
+
+	case "@daily", "@midnight":
+		return &SpecSchedule{
+			Second:   1 << seconds.min,
+			Minute:   1 << minutes.min,
+			Hour:     1 << hours.min,
+			Dom:      all(dom),
+			Month:    all(months),
+			Dow:      all(dow),
+			Location: loc,
+		}, nil
+
+	case "@hourly":
+		return &SpecSchedule{
+			Second:   1 << seconds.min,
+			Minute:   1 << minutes.min,
+			Hour:     all(hours),
+			Dom:      all(dom),
+			Month:    all(months),
+			Dow:      all(dow),
+			Location: loc,
+		}, nil
+
+	}
+
+	const every = "@every "
+	if strings.HasPrefix(descriptor, every) {
+		duration, err := time.ParseDuration(descriptor[len(every):])
+		if err != nil {
+			return nil, fmt.Errorf("failed to parse duration %s: %s", descriptor, err)
+		}
+		return Every(duration), nil
+	}
+
+	return nil, fmt.Errorf("unrecognized descriptor: %s", descriptor)
+}
--- a/backend/lib/cron/parser_test.go
+++ b/backend/lib/cron/parser_test.go
@@ -0,0 +1,383 @@
+package cron
+
+import (
+	"reflect"
+	"strings"
+	"testing"
+	"time"
+)
+
+var secondParser = NewParser(Second | Minute | Hour | Dom | Month | DowOptional | Descriptor)
+
+func TestRange(t *testing.T) {
+	zero := uint64(0)
+	ranges := []struct {
+		expr     string
+		min, max uint
+		expected uint64
+		err      string
+	}{
+		{"5", 0, 7, 1 << 5, ""},
+		{"0", 0, 7, 1 << 0, ""},
+		{"7", 0, 7, 1 << 7, ""},
+
+		{"5-5", 0, 7, 1 << 5, ""},
+		{"5-6", 0, 7, 1<<5 | 1<<6, ""},
+		{"5-7", 0, 7, 1<<5 | 1<<6 | 1<<7, ""},
+
+		{"5-6/2", 0, 7, 1 << 5, ""},
+		{"5-7/2", 0, 7, 1<<5 | 1<<7, ""},
+		{"5-7/1", 0, 7, 1<<5 | 1<<6 | 1<<7, ""},
+
+		{"*", 1, 3, 1<<1 | 1<<2 | 1<<3 | starBit, ""},
+		{"*/2", 1, 3, 1<<1 | 1<<3, ""},
+
+		{"5--5", 0, 0, zero, "too many hyphens"},
+		{"jan-x", 0, 0, zero, "failed to parse int from"},
+		{"2-x", 1, 5, zero, "failed to parse int from"},
+		{"*/-12", 0, 0, zero, "negative number"},
+		{"*//2", 0, 0, zero, "too many slashes"},
+		{"1", 3, 5, zero, "below minimum"},
+		{"6", 3, 5, zero, "above maximum"},
+		{"5-3", 3, 5, zero, "beyond end of range"},
+		{"*/0", 0, 0, zero, "should be a positive number"},
+	}
+
+	for _, c := range ranges {
+		actual, err := getRange(c.expr, bounds{c.min, c.max, nil})
+		if len(c.err) != 0 && (err == nil || !strings.Contains(err.Error(), c.err)) {
+			t.Errorf("%s => expected %v, got %v", c.expr, c.err, err)
+		}
+		if len(c.err) == 0 && err != nil {
+			t.Errorf("%s => unexpected error %v", c.expr, err)
+		}
+		if actual != c.expected {
+			t.Errorf("%s => expected %d, got %d", c.expr, c.expected, actual)
+		}
+	}
+}
+
+func TestField(t *testing.T) {
+	fields := []struct {
+		expr     string
+		min, max uint
+		expected uint64
+	}{
+		{"5", 1, 7, 1 << 5},
+		{"5,6", 1, 7, 1<<5 | 1<<6},
+		{"5,6,7", 1, 7, 1<<5 | 1<<6 | 1<<7},
+		{"1,5-7/2,3", 1, 7, 1<<1 | 1<<5 | 1<<7 | 1<<3},
+	}
+
+	for _, c := range fields {
+		actual, _ := getField(c.expr, bounds{c.min, c.max, nil})
+		if actual != c.expected {
+			t.Errorf("%s => expected %d, got %d", c.expr, c.expected, actual)
+		}
+	}
+}
+
+func TestAll(t *testing.T) {
+	allBits := []struct {
+		r        bounds
+		expected uint64
+	}{
+		{minutes, 0xfffffffffffffff}, // 0-59: 60 ones
+		{hours, 0xffffff},            // 0-23: 24 ones
+		{dom, 0xfffffffe},            // 1-31: 31 ones, 1 zero
+		{months, 0x1ffe},             // 1-12: 12 ones, 1 zero
+		{dow, 0x7f},                  // 0-6: 7 ones
+	}
+
+	for _, c := range allBits {
+		actual := all(c.r) // all() adds the starBit, so compensate for that..
+		if c.expected|starBit != actual {
+			t.Errorf("%d-%d/%d => expected %b, got %b",
+				c.r.min, c.r.max, 1, c.expected|starBit, actual)
+		}
+	}
+}
+
+func TestBits(t *testing.T) {
+	bits := []struct {
+		min, max, step uint
+		expected       uint64
+	}{
+		{0, 0, 1, 0x1},
+		{1, 1, 1, 0x2},
+		{1, 5, 2, 0x2a}, // 101010
+		{1, 4, 2, 0xa},  // 1010
+	}
+
+	for _, c := range bits {
+		actual := getBits(c.min, c.max, c.step)
+		if c.expected != actual {
+			t.Errorf("%d-%d/%d => expected %b, got %b",
+				c.min, c.max, c.step, c.expected, actual)
+		}
+	}
+}
+
+func TestParseScheduleErrors(t *testing.T) {
+	var tests = []struct{ expr, err string }{
+		{"* 5 j * * *", "failed to parse int from"},
+		{"@every Xm", "failed to parse duration"},
+		{"@unrecognized", "unrecognized descriptor"},
+		{"* * * *", "expected 5 to 6 fields"},
+		{"", "empty spec string"},
+	}
+	for _, c := range tests {
+		actual, err := secondParser.Parse(c.expr)
+		if err == nil || !strings.Contains(err.Error(), c.err) {
+			t.Errorf("%s => expected %v, got %v", c.expr, c.err, err)
+		}
+		if actual != nil {
+			t.Errorf("expected nil schedule on error, got %v", actual)
+		}
+	}
+}
+
+func TestParseSchedule(t *testing.T) {
+	tokyo, _ := time.LoadLocation("Asia/Tokyo")
+	entries := []struct {
+		parser   Parser
+		expr     string
+		expected Schedule
+	}{
+		{secondParser, "0 5 * * * *", every5min(time.Local)},
+		{standardParser, "5 * * * *", every5min(time.Local)},
+		{secondParser, "CRON_TZ=UTC  0 5 * * * *", every5min(time.UTC)},
+		{standardParser, "CRON_TZ=UTC  5 * * * *", every5min(time.UTC)},
+		{secondParser, "CRON_TZ=Asia/Tokyo 0 5 * * * *", every5min(tokyo)},
+		{secondParser, "@every 5m", ConstantDelaySchedule{5 * time.Minute}},
+		{secondParser, "@midnight", midnight(time.Local)},
+		{secondParser, "TZ=UTC  @midnight", midnight(time.UTC)},
+		{secondParser, "TZ=Asia/Tokyo @midnight", midnight(tokyo)},
+		{secondParser, "@yearly", annual(time.Local)},
+		{secondParser, "@annually", annual(time.Local)},
+		{
+			parser: secondParser,
+			expr:   "* 5 * * * *",
+			expected: &SpecSchedule{
+				Second:   all(seconds),
+				Minute:   1 << 5,
+				Hour:     all(hours),
+				Dom:      all(dom),
+				Month:    all(months),
+				Dow:      all(dow),
+				Location: time.Local,
+			},
+		},
+	}
+
+	for _, c := range entries {
+		actual, err := c.parser.Parse(c.expr)
+		if err != nil {
+			t.Errorf("%s => unexpected error %v", c.expr, err)
+		}
+		if !reflect.DeepEqual(actual, c.expected) {
+			t.Errorf("%s => expected %b, got %b", c.expr, c.expected, actual)
+		}
+	}
+}
+
+func TestOptionalSecondSchedule(t *testing.T) {
+	parser := NewParser(SecondOptional | Minute | Hour | Dom | Month | Dow | Descriptor)
+	entries := []struct {
+		expr     string
+		expected Schedule
+	}{
+		{"0 5 * * * *", every5min(time.Local)},
+		{"5 5 * * * *", every5min5s(time.Local)},
+		{"5 * * * *", every5min(time.Local)},
+	}
+
+	for _, c := range entries {
+		actual, err := parser.Parse(c.expr)
+		if err != nil {
+			t.Errorf("%s => unexpected error %v", c.expr, err)
+		}
+		if !reflect.DeepEqual(actual, c.expected) {
+			t.Errorf("%s => expected %b, got %b", c.expr, c.expected, actual)
+		}
+	}
+}
+
+func TestNormalizeFields(t *testing.T) {
+	tests := []struct {
+		name     string
+		input    []string
+		options  ParseOption
+		expected []string
+	}{
+		{
+			"AllFields_NoOptional",
+			[]string{"0", "5", "*", "*", "*", "*"},
+			Second | Minute | Hour | Dom | Month | Dow | Descriptor,
+			[]string{"0", "5", "*", "*", "*", "*"},
+		},
+		{
+			"AllFields_SecondOptional_Provided",
+			[]string{"0", "5", "*", "*", "*", "*"},
+			SecondOptional | Minute | Hour | Dom | Month | Dow | Descriptor,
+			[]string{"0", "5", "*", "*", "*", "*"},
+		},
+		{
+			"AllFields_SecondOptional_NotProvided",
+			[]string{"5", "*", "*", "*", "*"},
+			SecondOptional | Minute | Hour | Dom | Month | Dow | Descriptor,
+			[]string{"0", "5", "*", "*", "*", "*"},
+		},
+		{
+			"SubsetFields_NoOptional",
+			[]string{"5", "15", "*"},
+			Hour | Dom | Month,
+			[]string{"0", "0", "5", "15", "*", "*"},
+		},
+		{
+			"SubsetFields_DowOptional_Provided",
+			[]string{"5", "15", "*", "4"},
+			Hour | Dom | Month | DowOptional,
+			[]string{"0", "0", "5", "15", "*", "4"},
+		},
+		{
+			"SubsetFields_DowOptional_NotProvided",
+			[]string{"5", "15", "*"},
+			Hour | Dom | Month | DowOptional,
+			[]string{"0", "0", "5", "15", "*", "*"},
+		},
+		{
+			"SubsetFields_SecondOptional_NotProvided",
+			[]string{"5", "15", "*"},
+			SecondOptional | Hour | Dom | Month,
+			[]string{"0", "0", "5", "15", "*", "*"},
+		},
+	}
+
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			actual, err := normalizeFields(test.input, test.options)
+			if err != nil {
+				t.Errorf("unexpected error: %v", err)
+			}
+			if !reflect.DeepEqual(actual, test.expected) {
+				t.Errorf("expected %v, got %v", test.expected, actual)
+			}
+		})
+	}
+}
+
+func TestNormalizeFields_Errors(t *testing.T) {
+	tests := []struct {
+		name    string
+		input   []string
+		options ParseOption
+		err     string
+	}{
+		{
+			"TwoOptionals",
+			[]string{"0", "5", "*", "*", "*", "*"},
+			SecondOptional | Minute | Hour | Dom | Month | DowOptional,
+			"",
+		},
+		{
+			"TooManyFields",
+			[]string{"0", "5", "*", "*"},
+			SecondOptional | Minute | Hour,
+			"",
+		},
+		{
+			"NoFields",
+			[]string{},
+			SecondOptional | Minute | Hour,
+			"",
+		},
+		{
+			"TooFewFields",
+			[]string{"*"},
+			SecondOptional | Minute | Hour,
+			"",
+		},
+	}
+	for _, test := range tests {
+		t.Run(test.name, func(t *testing.T) {
+			actual, err := normalizeFields(test.input, test.options)
+			if err == nil {
+				t.Errorf("expected an error, got none. results: %v", actual)
+			}
+			if !strings.Contains(err.Error(), test.err) {
+				t.Errorf("expected error %q, got %q", test.err, err.Error())
+			}
+		})
+	}
+}
+
+func TestStandardSpecSchedule(t *testing.T) {
+	entries := []struct {
+		expr     string
+		expected Schedule
+		err      string
+	}{
+		{
+			expr:     "5 * * * *",
+			expected: &SpecSchedule{1 << seconds.min, 1 << 5, all(hours), all(dom), all(months), all(dow), time.Local},
+		},
+		{
+			expr:     "@every 5m",
+			expected: ConstantDelaySchedule{time.Duration(5) * time.Minute},
+		},
+		{
+			expr: "5 j * * *",
+			err:  "failed to parse int from",
+		},
+		{
+			expr: "* * * *",
+			err:  "expected exactly 5 fields",
+		},
+	}
+
+	for _, c := range entries {
+		actual, err := ParseStandard(c.expr)
+		if len(c.err) != 0 && (err == nil || !strings.Contains(err.Error(), c.err)) {
+			t.Errorf("%s => expected %v, got %v", c.expr, c.err, err)
+		}
+		if len(c.err) == 0 && err != nil {
+			t.Errorf("%s => unexpected error %v", c.expr, err)
+		}
+		if !reflect.DeepEqual(actual, c.expected) {
+			t.Errorf("%s => expected %b, got %b", c.expr, c.expected, actual)
+		}
+	}
+}
+
+func TestNoDescriptorParser(t *testing.T) {
+	parser := NewParser(Minute | Hour)
+	_, err := parser.Parse("@every 1m")
+	if err == nil {
+		t.Error("expected an error, got none")
+	}
+}
+
+func every5min(loc *time.Location) *SpecSchedule {
+	return &SpecSchedule{1 << 0, 1 << 5, all(hours), all(dom), all(months), all(dow), loc}
+}
+
+func every5min5s(loc *time.Location) *SpecSchedule {
+	return &SpecSchedule{1 << 5, 1 << 5, all(hours), all(dom), all(months), all(dow), loc}
+}
+
+func midnight(loc *time.Location) *SpecSchedule {
+	return &SpecSchedule{1, 1, 1, all(dom), all(months), all(dow), loc}
+}
+
+func annual(loc *time.Location) *SpecSchedule {
+	return &SpecSchedule{
+		Second:   1 << seconds.min,
+		Minute:   1 << minutes.min,
+		Hour:     1 << hours.min,
+		Dom:      1 << dom.min,
+		Month:    1 << months.min,
+		Dow:      all(dow),
+		Location: loc,
+	}
+}
--- a/backend/lib/cron/spec.go
+++ b/backend/lib/cron/spec.go
@@ -0,0 +1,188 @@
+package cron
+
+import "time"
+
+// SpecSchedule specifies a duty cycle (to the second granularity), based on a
+// traditional crontab specification. It is computed initially and stored as bit sets.
+type SpecSchedule struct {
+	Second, Minute, Hour, Dom, Month, Dow uint64
+
+	// Override location for this schedule.
+	Location *time.Location
+}
+
+// bounds provides a range of acceptable values (plus a map of name to value).
+type bounds struct {
+	min, max uint
+	names    map[string]uint
+}
+
+// The bounds for each field.
+var (
+	seconds = bounds{0, 59, nil}
+	minutes = bounds{0, 59, nil}
+	hours   = bounds{0, 23, nil}
+	dom     = bounds{1, 31, nil}
+	months  = bounds{1, 12, map[string]uint{
+		"jan": 1,
+		"feb": 2,
+		"mar": 3,
+		"apr": 4,
+		"may": 5,
+		"jun": 6,
+		"jul": 7,
+		"aug": 8,
+		"sep": 9,
+		"oct": 10,
+		"nov": 11,
+		"dec": 12,
+	}}
+	dow = bounds{0, 6, map[string]uint{
+		"sun": 0,
+		"mon": 1,
+		"tue": 2,
+		"wed": 3,
+		"thu": 4,
+		"fri": 5,
+		"sat": 6,
+	}}
+)
+
+const (
+	// Set the top bit if a star was included in the expression.
+	starBit = 1 << 63
+)
+
+// Next returns the next time this schedule is activated, greater than the given
+// time.  If no time can be found to satisfy the schedule, return the zero time.
+func (s *SpecSchedule) Next(t time.Time) time.Time {
+	// General approach
+	//
+	// For Month, Day, Hour, Minute, Second:
+	// Check if the time value matches.  If yes, continue to the next field.
+	// If the field doesn't match the schedule, then increment the field until it matches.
+	// While incrementing the field, a wrap-around brings it back to the beginning
+	// of the field list (since it is necessary to re-verify previous field
+	// values)
+
+	// Convert the given time into the schedule's timezone, if one is specified.
+	// Save the original timezone so we can convert back after we find a time.
+	// Note that schedules without a time zone specified (time.Local) are treated
+	// as local to the time provided.
+	origLocation := t.Location()
+	loc := s.Location
+	if loc == time.Local {
+		loc = t.Location()
+	}
+	if s.Location != time.Local {
+		t = t.In(s.Location)
+	}
+
+	// Start at the earliest possible time (the upcoming second).
+	t = t.Add(1*time.Second - time.Duration(t.Nanosecond())*time.Nanosecond)
+
+	// This flag indicates whether a field has been incremented.
+	added := false
+
+	// If no time is found within five years, return zero.
+	yearLimit := t.Year() + 5
+
+WRAP:
+	if t.Year() > yearLimit {
+		return time.Time{}
+	}
+
+	// Find the first applicable month.
+	// If it's this month, then do nothing.
+	for 1<<uint(t.Month())&s.Month == 0 {
+		// If we have to add a month, reset the other parts to 0.
+		if !added {
+			added = true
+			// Otherwise, set the date at the beginning (since the current time is irrelevant).
+			t = time.Date(t.Year(), t.Month(), 1, 0, 0, 0, 0, loc)
+		}
+		t = t.AddDate(0, 1, 0)
+
+		// Wrapped around.
+		if t.Month() == time.January {
+			goto WRAP
+		}
+	}
+
+	// Now get a day in that month.
+	//
+	// NOTE: This causes issues for daylight savings regimes where midnight does
+	// not exist.  For example: Sao Paulo has DST that transforms midnight on
+	// 11/3 into 1am. Handle that by noticing when the Hour ends up != 0.
+	for !dayMatches(s, t) {
+		if !added {
+			added = true
+			t = time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, loc)
+		}
+		t = t.AddDate(0, 0, 1)
+		// Notice if the hour is no longer midnight due to DST.
+		// Add an hour if it's 23, subtract an hour if it's 1.
+		if t.Hour() != 0 {
+			if t.Hour() > 12 {
+				t = t.Add(time.Duration(24-t.Hour()) * time.Hour)
+			} else {
+				t = t.Add(time.Duration(-t.Hour()) * time.Hour)
+			}
+		}
+
+		if t.Day() == 1 {
+			goto WRAP
+		}
+	}
+
+	for 1<<uint(t.Hour())&s.Hour == 0 {
+		if !added {
+			added = true
+			t = time.Date(t.Year(), t.Month(), t.Day(), t.Hour(), 0, 0, 0, loc)
+		}
+		t = t.Add(1 * time.Hour)
+
+		if t.Hour() == 0 {
+			goto WRAP
+		}
+	}
+
+	for 1<<uint(t.Minute())&s.Minute == 0 {
+		if !added {
+			added = true
+			t = t.Truncate(time.Minute)
+		}
+		t = t.Add(1 * time.Minute)
+
+		if t.Minute() == 0 {
+			goto WRAP
+		}
+	}
+
+	for 1<<uint(t.Second())&s.Second == 0 {
+		if !added {
+			added = true
+			t = t.Truncate(time.Second)
+		}
+		t = t.Add(1 * time.Second)
+
+		if t.Second() == 0 {
+			goto WRAP
+		}
+	}
+
+	return t.In(origLocation)
+}
+
+// dayMatches returns true if the schedule's day-of-week and day-of-month
+// restrictions are satisfied by the given time.
+func dayMatches(s *SpecSchedule, t time.Time) bool {
+	var (
+		domMatch bool = 1<<uint(t.Day())&s.Dom > 0
+		dowMatch bool = 1<<uint(t.Weekday())&s.Dow > 0
+	)
+	if s.Dom&starBit > 0 || s.Dow&starBit > 0 {
+		return domMatch && dowMatch
+	}
+	return domMatch || dowMatch
+}
--- a/backend/lib/cron/spec_test.go
+++ b/backend/lib/cron/spec_test.go
@@ -0,0 +1,300 @@
+package cron
+
+import (
+	"strings"
+	"testing"
+	"time"
+)
+
+func TestActivation(t *testing.T) {
+	tests := []struct {
+		time, spec string
+		expected   bool
+	}{
+		// Every fifteen minutes.
+		{"Mon Jul 9 15:00 2012", "0/15 * * * *", true},
+		{"Mon Jul 9 15:45 2012", "0/15 * * * *", true},
+		{"Mon Jul 9 15:40 2012", "0/15 * * * *", false},
+
+		// Every fifteen minutes, starting at 5 minutes.
+		{"Mon Jul 9 15:05 2012", "5/15 * * * *", true},
+		{"Mon Jul 9 15:20 2012", "5/15 * * * *", true},
+		{"Mon Jul 9 15:50 2012", "5/15 * * * *", true},
+
+		// Named months
+		{"Sun Jul 15 15:00 2012", "0/15 * * Jul *", true},
+		{"Sun Jul 15 15:00 2012", "0/15 * * Jun *", false},
+
+		// Everything set.
+		{"Sun Jul 15 08:30 2012", "30 08 ? Jul Sun", true},
+		{"Sun Jul 15 08:30 2012", "30 08 15 Jul ?", true},
+		{"Mon Jul 16 08:30 2012", "30 08 ? Jul Sun", false},
+		{"Mon Jul 16 08:30 2012", "30 08 15 Jul ?", false},
+
+		// Predefined schedules
+		{"Mon Jul 9 15:00 2012", "@hourly", true},
+		{"Mon Jul 9 15:04 2012", "@hourly", false},
+		{"Mon Jul 9 15:00 2012", "@daily", false},
+		{"Mon Jul 9 00:00 2012", "@daily", true},
+		{"Mon Jul 9 00:00 2012", "@weekly", false},
+		{"Sun Jul 8 00:00 2012", "@weekly", true},
+		{"Sun Jul 8 01:00 2012", "@weekly", false},
+		{"Sun Jul 8 00:00 2012", "@monthly", false},
+		{"Sun Jul 1 00:00 2012", "@monthly", true},
+
+		// Test interaction of DOW and DOM.
+		// If both are restricted, then only one needs to match.
+		{"Sun Jul 15 00:00 2012", "* * 1,15 * Sun", true},
+		{"Fri Jun 15 00:00 2012", "* * 1,15 * Sun", true},
+		{"Wed Aug 1 00:00 2012", "* * 1,15 * Sun", true},
+		{"Sun Jul 15 00:00 2012", "* * */10 * Sun", true}, // verifies #70
+
+		// However, if one has a star, then both need to match.
+		{"Sun Jul 15 00:00 2012", "* * * * Mon", false},
+		{"Mon Jul 9 00:00 2012", "* * 1,15 * *", false},
+		{"Sun Jul 15 00:00 2012", "* * 1,15 * *", true},
+		{"Sun Jul 15 00:00 2012", "* * */2 * Sun", true},
+	}
+
+	for _, test := range tests {
+		sched, err := ParseStandard(test.spec)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+		actual := sched.Next(getTime(test.time).Add(-1 * time.Second))
+		expected := getTime(test.time)
+		if test.expected && expected != actual || !test.expected && expected == actual {
+			t.Errorf("Fail evaluating %s on %s: (expected) %s != %s (actual)",
+				test.spec, test.time, expected, actual)
+		}
+	}
+}
+
+func TestNext(t *testing.T) {
+	runs := []struct {
+		time, spec string
+		expected   string
+	}{
+		// Simple cases
+		{"Mon Jul 9 14:45 2012", "0 0/15 * * * *", "Mon Jul 9 15:00 2012"},
+		{"Mon Jul 9 14:59 2012", "0 0/15 * * * *", "Mon Jul 9 15:00 2012"},
+		{"Mon Jul 9 14:59:59 2012", "0 0/15 * * * *", "Mon Jul 9 15:00 2012"},
+
+		// Wrap around hours
+		{"Mon Jul 9 15:45 2012", "0 20-35/15 * * * *", "Mon Jul 9 16:20 2012"},
+
+		// Wrap around days
+		{"Mon Jul 9 23:46 2012", "0 */15 * * * *", "Tue Jul 10 00:00 2012"},
+		{"Mon Jul 9 23:45 2012", "0 20-35/15 * * * *", "Tue Jul 10 00:20 2012"},
+		{"Mon Jul 9 23:35:51 2012", "15/35 20-35/15 * * * *", "Tue Jul 10 00:20:15 2012"},
+		{"Mon Jul 9 23:35:51 2012", "15/35 20-35/15 1/2 * * *", "Tue Jul 10 01:20:15 2012"},
+		{"Mon Jul 9 23:35:51 2012", "15/35 20-35/15 10-12 * * *", "Tue Jul 10 10:20:15 2012"},
+
+		{"Mon Jul 9 23:35:51 2012", "15/35 20-35/15 1/2 */2 * *", "Thu Jul 11 01:20:15 2012"},
+		{"Mon Jul 9 23:35:51 2012", "15/35 20-35/15 * 9-20 * *", "Wed Jul 10 00:20:15 2012"},
+		{"Mon Jul 9 23:35:51 2012", "15/35 20-35/15 * 9-20 Jul *", "Wed Jul 10 00:20:15 2012"},
+
+		// Wrap around months
+		{"Mon Jul 9 23:35 2012", "0 0 0 9 Apr-Oct ?", "Thu Aug 9 00:00 2012"},
+		{"Mon Jul 9 23:35 2012", "0 0 0 */5 Apr,Aug,Oct Mon", "Tue Aug 1 00:00 2012"},
+		{"Mon Jul 9 23:35 2012", "0 0 0 */5 Oct Mon", "Mon Oct 1 00:00 2012"},
+
+		// Wrap around years
+		{"Mon Jul 9 23:35 2012", "0 0 0 * Feb Mon", "Mon Feb 4 00:00 2013"},
+		{"Mon Jul 9 23:35 2012", "0 0 0 * Feb Mon/2", "Fri Feb 1 00:00 2013"},
+
+		// Wrap around minute, hour, day, month, and year
+		{"Mon Dec 31 23:59:45 2012", "0 * * * * *", "Tue Jan 1 00:00:00 2013"},
+
+		// Leap year
+		{"Mon Jul 9 23:35 2012", "0 0 0 29 Feb ?", "Mon Feb 29 00:00 2016"},
+
+		// Daylight savings time 2am EST (-5) -> 3am EDT (-4)
+		{"2012-03-11T00:00:00-0500", "TZ=America/New_York 0 30 2 11 Mar ?", "2013-03-11T02:30:00-0400"},
+
+		// hourly job
+		{"2012-03-11T00:00:00-0500", "TZ=America/New_York 0 0 * * * ?", "2012-03-11T01:00:00-0500"},
+		{"2012-03-11T01:00:00-0500", "TZ=America/New_York 0 0 * * * ?", "2012-03-11T03:00:00-0400"},
+		{"2012-03-11T03:00:00-0400", "TZ=America/New_York 0 0 * * * ?", "2012-03-11T04:00:00-0400"},
+		{"2012-03-11T04:00:00-0400", "TZ=America/New_York 0 0 * * * ?", "2012-03-11T05:00:00-0400"},
+
+		// hourly job using CRON_TZ
+		{"2012-03-11T00:00:00-0500", "CRON_TZ=America/New_York 0 0 * * * ?", "2012-03-11T01:00:00-0500"},
+		{"2012-03-11T01:00:00-0500", "CRON_TZ=America/New_York 0 0 * * * ?", "2012-03-11T03:00:00-0400"},
+		{"2012-03-11T03:00:00-0400", "CRON_TZ=America/New_York 0 0 * * * ?", "2012-03-11T04:00:00-0400"},
+		{"2012-03-11T04:00:00-0400", "CRON_TZ=America/New_York 0 0 * * * ?", "2012-03-11T05:00:00-0400"},
+
+		// 1am nightly job
+		{"2012-03-11T00:00:00-0500", "TZ=America/New_York 0 0 1 * * ?", "2012-03-11T01:00:00-0500"},
+		{"2012-03-11T01:00:00-0500", "TZ=America/New_York 0 0 1 * * ?", "2012-03-12T01:00:00-0400"},
+
+		// 2am nightly job (skipped)
+		{"2012-03-11T00:00:00-0500", "TZ=America/New_York 0 0 2 * * ?", "2012-03-12T02:00:00-0400"},
+
+		// Daylight savings time 2am EDT (-4) => 1am EST (-5)
+		{"2012-11-04T00:00:00-0400", "TZ=America/New_York 0 30 2 04 Nov ?", "2012-11-04T02:30:00-0500"},
+		{"2012-11-04T01:45:00-0400", "TZ=America/New_York 0 30 1 04 Nov ?", "2012-11-04T01:30:00-0500"},
+
+		// hourly job
+		{"2012-11-04T00:00:00-0400", "TZ=America/New_York 0 0 * * * ?", "2012-11-04T01:00:00-0400"},
+		{"2012-11-04T01:00:00-0400", "TZ=America/New_York 0 0 * * * ?", "2012-11-04T01:00:00-0500"},
+		{"2012-11-04T01:00:00-0500", "TZ=America/New_York 0 0 * * * ?", "2012-11-04T02:00:00-0500"},
+
+		// 1am nightly job (runs twice)
+		{"2012-11-04T00:00:00-0400", "TZ=America/New_York 0 0 1 * * ?", "2012-11-04T01:00:00-0400"},
+		{"2012-11-04T01:00:00-0400", "TZ=America/New_York 0 0 1 * * ?", "2012-11-04T01:00:00-0500"},
+		{"2012-11-04T01:00:00-0500", "TZ=America/New_York 0 0 1 * * ?", "2012-11-05T01:00:00-0500"},
+
+		// 2am nightly job
+		{"2012-11-04T00:00:00-0400", "TZ=America/New_York 0 0 2 * * ?", "2012-11-04T02:00:00-0500"},
+		{"2012-11-04T02:00:00-0500", "TZ=America/New_York 0 0 2 * * ?", "2012-11-05T02:00:00-0500"},
+
+		// 3am nightly job
+		{"2012-11-04T00:00:00-0400", "TZ=America/New_York 0 0 3 * * ?", "2012-11-04T03:00:00-0500"},
+		{"2012-11-04T03:00:00-0500", "TZ=America/New_York 0 0 3 * * ?", "2012-11-05T03:00:00-0500"},
+
+		// hourly job
+		{"TZ=America/New_York 2012-11-04T00:00:00-0400", "0 0 * * * ?", "2012-11-04T01:00:00-0400"},
+		{"TZ=America/New_York 2012-11-04T01:00:00-0400", "0 0 * * * ?", "2012-11-04T01:00:00-0500"},
+		{"TZ=America/New_York 2012-11-04T01:00:00-0500", "0 0 * * * ?", "2012-11-04T02:00:00-0500"},
+
+		// 1am nightly job (runs twice)
+		{"TZ=America/New_York 2012-11-04T00:00:00-0400", "0 0 1 * * ?", "2012-11-04T01:00:00-0400"},
+		{"TZ=America/New_York 2012-11-04T01:00:00-0400", "0 0 1 * * ?", "2012-11-04T01:00:00-0500"},
+		{"TZ=America/New_York 2012-11-04T01:00:00-0500", "0 0 1 * * ?", "2012-11-05T01:00:00-0500"},
+
+		// 2am nightly job
+		{"TZ=America/New_York 2012-11-04T00:00:00-0400", "0 0 2 * * ?", "2012-11-04T02:00:00-0500"},
+		{"TZ=America/New_York 2012-11-04T02:00:00-0500", "0 0 2 * * ?", "2012-11-05T02:00:00-0500"},
+
+		// 3am nightly job
+		{"TZ=America/New_York 2012-11-04T00:00:00-0400", "0 0 3 * * ?", "2012-11-04T03:00:00-0500"},
+		{"TZ=America/New_York 2012-11-04T03:00:00-0500", "0 0 3 * * ?", "2012-11-05T03:00:00-0500"},
+
+		// Unsatisfiable
+		{"Mon Jul 9 23:35 2012", "0 0 0 30 Feb ?", ""},
+		{"Mon Jul 9 23:35 2012", "0 0 0 31 Apr ?", ""},
+
+		// Monthly job
+		{"TZ=America/New_York 2012-11-04T00:00:00-0400", "0 0 3 3 * ?", "2012-12-03T03:00:00-0500"},
+
+		// Test the scenario of DST resulting in midnight not being a valid time.
+		// https://github.com/robfig/cron/issues/157
+		{"2018-10-17T05:00:00-0400", "TZ=America/Sao_Paulo 0 0 9 10 * ?", "2018-11-10T06:00:00-0500"},
+		{"2018-02-14T05:00:00-0500", "TZ=America/Sao_Paulo 0 0 9 22 * ?", "2018-02-22T07:00:00-0500"},
+	}
+
+	for _, c := range runs {
+		sched, err := secondParser.Parse(c.spec)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+		actual := sched.Next(getTime(c.time))
+		expected := getTime(c.expected)
+		if !actual.Equal(expected) {
+			t.Errorf("%s, \"%s\": (expected) %v != %v (actual)", c.time, c.spec, expected, actual)
+		}
+	}
+}
+
+func TestErrors(t *testing.T) {
+	invalidSpecs := []string{
+		"xyz",
+		"60 0 * * *",
+		"0 60 * * *",
+		"0 0 * * XYZ",
+	}
+	for _, spec := range invalidSpecs {
+		_, err := ParseStandard(spec)
+		if err == nil {
+			t.Error("expected an error parsing: ", spec)
+		}
+	}
+}
+
+func getTime(value string) time.Time {
+	if value == "" {
+		return time.Time{}
+	}
+
+	var location = time.Local
+	if strings.HasPrefix(value, "TZ=") {
+		parts := strings.Fields(value)
+		loc, err := time.LoadLocation(parts[0][len("TZ="):])
+		if err != nil {
+			panic("could not parse location:" + err.Error())
+		}
+		location = loc
+		value = parts[1]
+	}
+
+	var layouts = []string{
+		"Mon Jan 2 15:04 2006",
+		"Mon Jan 2 15:04:05 2006",
+	}
+	for _, layout := range layouts {
+		if t, err := time.ParseInLocation(layout, value, location); err == nil {
+			return t
+		}
+	}
+	if t, err := time.ParseInLocation("2006-01-02T15:04:05-0700", value, location); err == nil {
+		return t
+	}
+	panic("could not parse time value " + value)
+}
+
+func TestNextWithTz(t *testing.T) {
+	runs := []struct {
+		time, spec string
+		expected   string
+	}{
+		// Failing tests
+		{"2016-01-03T13:09:03+0530", "14 14 * * *", "2016-01-03T14:14:00+0530"},
+		{"2016-01-03T04:09:03+0530", "14 14 * * ?", "2016-01-03T14:14:00+0530"},
+
+		// Passing tests
+		{"2016-01-03T14:09:03+0530", "14 14 * * *", "2016-01-03T14:14:00+0530"},
+		{"2016-01-03T14:00:00+0530", "14 14 * * ?", "2016-01-03T14:14:00+0530"},
+	}
+	for _, c := range runs {
+		sched, err := ParseStandard(c.spec)
+		if err != nil {
+			t.Error(err)
+			continue
+		}
+		actual := sched.Next(getTimeTZ(c.time))
+		expected := getTimeTZ(c.expected)
+		if !actual.Equal(expected) {
+			t.Errorf("%s, \"%s\": (expected) %v != %v (actual)", c.time, c.spec, expected, actual)
+		}
+	}
+}
+
+func getTimeTZ(value string) time.Time {
+	if value == "" {
+		return time.Time{}
+	}
+	t, err := time.Parse("Mon Jan 2 15:04 2006", value)
+	if err != nil {
+		t, err = time.Parse("Mon Jan 2 15:04:05 2006", value)
+		if err != nil {
+			t, err = time.Parse("2006-01-02T15:04:05-0700", value)
+			if err != nil {
+				panic(err)
+			}
+		}
+	}
+
+	return t
+}
+
+// https://github.com/robfig/cron/issues/144
+func TestSlash0NoHang(t *testing.T) {
+	schedule := "TZ=America/New_York 15/0 * * * *"
+	_, err := ParseStandard(schedule)
+	if err == nil {
+		t.Error("expected an error on 0 increment")
+	}
+}
--- a/backend/main.go
+++ b/backend/main.go
@@ -0,0 +1,143 @@
+package main
+
+import (
+	"crawlab/config"
+	"crawlab/database"
+	"crawlab/middlewares"
+	"crawlab/routes"
+	"crawlab/services"
+	"github.com/apex/log"
+	"github.com/gin-gonic/gin"
+	"github.com/spf13/viper"
+	"runtime/debug"
+)
+
+func main() {
+	app := gin.Default()
+
+	// 初始化配置
+	if err := config.InitConfig(""); err != nil {
+		panic(err)
+	}
+	log.Info("初始化配置成功")
+
+	// 初始化日志设置
+	logLevel := viper.GetString("log.level")
+	if logLevel != "" {
+		log.SetLevelFromString(logLevel)
+	}
+	log.Info("初始化日志设置成功")
+
+	// 初始化Mongodb数据库
+	if err := database.InitMongo(); err != nil {
+		debug.PrintStack()
+		panic(err)
+	}
+	log.Info("初始化Mongodb数据库成功")
+
+	// 初始化Redis数据库
+	if err := database.InitRedis(); err != nil {
+		debug.PrintStack()
+		panic(err)
+	}
+	log.Info("初始化Redis数据库成功")
+
+	if services.IsMaster() {
+		// 初始化定时任务
+		if err := services.InitScheduler(); err != nil {
+			debug.PrintStack()
+			panic(err)
+		}
+		log.Info("初始化定时任务成功")
+	}
+
+	// 初始化任务执行器
+	if err := services.InitTaskExecutor(); err != nil {
+		debug.PrintStack()
+		panic(err)
+	}
+	log.Info("初始化任务执行器成功")
+
+	// 初始化节点服务
+	if err := services.InitNodeService(); err != nil {
+		panic(err)
+	}
+	log.Info("初始化节点配置成功")
+
+	// 初始化爬虫服务
+	if err := services.InitSpiderService(); err != nil {
+		debug.PrintStack()
+		panic(err)
+	}
+	log.Info("初始化爬虫服务成功")
+
+	// 初始化用户服务
+	if err := services.InitUserService(); err != nil {
+		debug.PrintStack()
+		panic(err)
+	}
+	log.Info("初始化用户服务成功")
+
+	// 以下为主节点服务
+	if services.IsMaster() {
+		// 中间件
+		app.Use(middlewares.CORSMiddleware())
+		app.Use(middlewares.AuthorizationMiddleware())
+
+		// 路由
+		// 节点
+		app.GET("/nodes", routes.GetNodeList)               // 节点列表
+		app.GET("/nodes/:id", routes.GetNode)               // 节点详情
+		app.POST("/nodes/:id", routes.PostNode)             // 修改节点
+		app.GET("/nodes/:id/tasks", routes.GetNodeTaskList) // 节点任务列表
+		app.GET("/nodes/:id/system", routes.GetSystemInfo)  // 节点任务列表
+		// 爬虫
+		app.GET("/spiders", routes.GetSpiderList)              // 爬虫列表
+		app.GET("/spiders/:id", routes.GetSpider)              // 爬虫详情
+		app.PUT("/spiders", routes.PutSpider)                  // 上传爬虫
+		app.POST("/spiders", routes.PublishAllSpiders)         // 发布所有爬虫
+		app.POST("/spiders/:id", routes.PostSpider)            // 修改爬虫
+		app.POST("/spiders/:id/publish", routes.PublishSpider) // 发布爬虫
+		app.DELETE("/spiders/:id", routes.DeleteSpider)        // 删除爬虫
+		app.GET("/spiders/:id/tasks", routes.GetSpiderTasks)   // 爬虫任务列表
+		app.GET("/spiders/:id/file", routes.GetSpiderFile)     // 爬虫文件读取
+		app.POST("/spiders/:id/file", routes.PostSpiderFile)   // 爬虫目录写入
+		app.GET("/spiders/:id/dir", routes.GetSpiderDir)       // 爬虫目录
+		app.GET("/spiders/:id/stats", routes.GetSpiderStats)   // 爬虫统计数据
+		// 任务
+		app.GET("/tasks", routes.GetTaskList)                                 // 任务列表
+		app.GET("/tasks/:id", routes.GetTask)                                 // 任务详情
+		app.PUT("/tasks", routes.PutTask)                                     // 派发任务
+		app.DELETE("/tasks/:id", routes.DeleteTask)                           // 删除任务
+		app.POST("/tasks/:id/cancel", routes.CancelTask)                      // 取消任务
+		app.GET("/tasks/:id/log", routes.GetTaskLog)                          // 任务日志
+		app.GET("/tasks/:id/results", routes.GetTaskResults)                  // 任务结果
+		app.GET("/tasks/:id/results/download", routes.DownloadTaskResultsCsv) // 下载任务结果
+		// 定时任务
+		app.GET("/schedules", routes.GetScheduleList)       // 定时任务列表
+		app.GET("/schedules/:id", routes.GetSchedule)       // 定时任务详情
+		app.PUT("/schedules", routes.PutSchedule)           // 创建定时任务
+		app.POST("/schedules/:id", routes.PostSchedule)     // 修改定时任务
+		app.DELETE("/schedules/:id", routes.DeleteSchedule) // 删除定时任务
+		// 统计数据
+		app.GET("/stats/home", routes.GetHomeStats) // 首页统计数据
+		// 用户
+		app.GET("/users", routes.GetUserList)       // 用户列表
+		app.GET("/users/:id", routes.GetUser)       // 用户详情
+		app.PUT("/users", routes.PutUser)           // 添加用户
+		app.POST("/users/:id", routes.PostUser)     // 更改用户
+		app.DELETE("/users/:id", routes.DeleteUser) // 删除用户
+		app.POST("/login", routes.Login)            // 用户登录
+		app.GET("/me", routes.GetMe)                // 获取自己账户
+	}
+
+	// 路由ping
+	app.GET("/ping", routes.Ping)
+
+	// 运行服务器
+	host := viper.GetString("server.host")
+	port := viper.GetString("server.port")
+	if err := app.Run(host + ":" + port); err != nil {
+		panic(err)
+	}
+}
--- a/backend/middlewares/auth.go
+++ b/backend/middlewares/auth.go
@@ -0,0 +1,53 @@
+package middlewares
+
+import (
+	"crawlab/constants"
+	"crawlab/routes"
+	"crawlab/services"
+	"github.com/gin-gonic/gin"
+	"net/http"
+	"strings"
+)
+
+func AuthorizationMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		// 如果为登录或注册，不用校验
+		if c.Request.URL.Path == "/login" ||
+			(c.Request.URL.Path == "/users" && c.Request.Method == "PUT") ||
+			strings.HasSuffix(c.Request.URL.Path, "download") {
+			c.Next()
+			return
+		}
+
+		// 获取token string
+		tokenStr := c.GetHeader("Authorization")
+
+		// 校验token
+		user, err := services.CheckToken(tokenStr)
+
+		// 校验失败，返回错误响应
+		if err != nil {
+			c.AbortWithStatusJSON(http.StatusUnauthorized, routes.Response{
+				Status:  "ok",
+				Message: "unauthorized",
+				Error:   "unauthorized",
+			})
+			return
+		}
+
+		// 如果为普通权限，校验请求地址是否符合要求
+		if user.Role == constants.RoleNormal {
+			if strings.HasPrefix(strings.ToLower(c.Request.URL.Path), "/users") {
+				c.AbortWithStatusJSON(http.StatusUnauthorized, routes.Response{
+					Status:  "ok",
+					Message: "unauthorized",
+					Error:   "unauthorized",
+				})
+				return
+			}
+		}
+
+		// 校验成功
+		c.Next()
+	}
+}
--- a/backend/middlewares/cors.go
+++ b/backend/middlewares/cors.go
@@ -0,0 +1,19 @@
+package middlewares
+
+import "github.com/gin-gonic/gin"
+
+func CORSMiddleware() gin.HandlerFunc {
+	return func(c *gin.Context) {
+		c.Writer.Header().Set("Access-Control-Allow-Origin", "*")
+		c.Writer.Header().Set("Access-Control-Allow-Credentials", "true")
+		c.Writer.Header().Set("Access-Control-Allow-Headers", "Content-Type, Content-Length, Accept-Encoding, X-CSRF-Token, Authorization, accept, origin, Cache-Control, X-Requested-With")
+		c.Writer.Header().Set("Access-Control-Allow-Methods", "DELETE, POST, OPTIONS, GET, PUT")
+
+		if c.Request.Method == "OPTIONS" {
+			c.AbortWithStatus(204)
+			return
+		}
+
+		c.Next()
+	}
+}
--- a/backend/model/base.go
+++ b/backend/model/base.go
@@ -0,0 +1,12 @@
+package model
+
+type Base struct {
+}
+
+func (b *Base) Save() error {
+	return nil
+}
+
+func (b *Base) Delete() error {
+	return nil
+}
--- a/backend/model/file.go
+++ b/backend/model/file.go
@@ -0,0 +1,8 @@
+package model
+
+type File struct {
+	Name  string `json:"name"`
+	Path  string `json:"path"`
+	IsDir bool   `json:"is_dir"`
+	Size  int64  `json:"size"`
+}
--- a/backend/model/node.go
+++ b/backend/model/node.go
@@ -0,0 +1,153 @@
+package model
+
+import (
+	"crawlab/database"
+	"github.com/apex/log"
+	"github.com/globalsign/mgo"
+	"github.com/globalsign/mgo/bson"
+	"runtime/debug"
+	"time"
+)
+
+type Node struct {
+	Id          bson.ObjectId `json:"_id" bson:"_id"`
+	Name        string        `json:"name" bson:"name"`
+	Status      string        `json:"status" bson:"status"`
+	Ip          string        `json:"ip" bson:"ip"`
+	Port        string        `json:"port" bson:"port"`
+	Mac         string        `json:"mac" bson:"mac"`
+	Description string        `json:"description" bson:"description"`
+
+	// 前端展示
+	IsMaster bool `json:"is_master"`
+
+	UpdateTs     time.Time `json:"update_ts" bson:"update_ts"`
+	CreateTs     time.Time `json:"create_ts" bson:"create_ts"`
+	UpdateTsUnix int64       `json:"update_ts_unix" bson:"update_ts_unix"`
+}
+
+func (n *Node) Save() error {
+	s, c := database.GetCol("nodes")
+	defer s.Close()
+	n.UpdateTs = time.Now()
+	if err := c.UpdateId(n.Id, n); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (n *Node) Add() error {
+	s, c := database.GetCol("nodes")
+	defer s.Close()
+	n.Id = bson.NewObjectId()
+	n.UpdateTs = time.Now()
+	n.UpdateTsUnix = time.Now().Unix()
+	n.CreateTs = time.Now()
+	if err := c.Insert(&n); err != nil {
+		debug.PrintStack()
+		return err
+	}
+	return nil
+}
+
+func (n *Node) Delete() error {
+	s, c := database.GetCol("nodes")
+	defer s.Close()
+	if err := c.RemoveId(n.Id); err != nil {
+		debug.PrintStack()
+		return err
+	}
+	return nil
+}
+
+func (n *Node) GetTasks() ([]Task, error) {
+	tasks, err := GetTaskList(bson.M{"node_id": n.Id}, 0, 10, "-create_ts")
+	//tasks, err := GetTaskList(nil, 0, 10, "-create_ts")
+	if err != nil {
+		debug.PrintStack()
+		return []Task{}, err
+	}
+
+	return tasks, nil
+}
+
+func GetNodeList(filter interface{}) ([]Node, error) {
+	s, c := database.GetCol("nodes")
+	defer s.Close()
+
+	var results []Node
+	if err := c.Find(filter).All(&results); err != nil {
+		debug.PrintStack()
+		return results, err
+	}
+	return results, nil
+}
+
+func GetNode(id bson.ObjectId) (Node, error) {
+	s, c := database.GetCol("nodes")
+	defer s.Close()
+
+	var node Node
+	if err := c.FindId(id).One(&node); err != nil {
+		if err != mgo.ErrNotFound {
+			log.Errorf(err.Error())
+			debug.PrintStack()
+		}
+		return node, err
+	}
+	return node, nil
+}
+
+func GetNodeByMac(mac string) (Node, error) {
+	s, c := database.GetCol("nodes")
+	defer s.Close()
+
+	var node Node
+	if err := c.Find(bson.M{"mac": mac}).One(&node); err != nil {
+		if err != mgo.ErrNotFound {
+			log.Errorf(err.Error())
+			debug.PrintStack()
+		}
+		return node, err
+	}
+	return node, nil
+}
+
+func UpdateNode(id bson.ObjectId, item Node) error {
+	s, c := database.GetCol("nodes")
+	defer s.Close()
+
+	var node Node
+	if err := c.FindId(id).One(&node); err != nil {
+		return err
+	}
+
+	if err := item.Save(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetNodeTaskList(id bson.ObjectId) ([]Task, error) {
+	node, err := GetNode(id)
+	if err != nil {
+		return []Task{}, err
+	}
+	tasks, err := node.GetTasks()
+	if err != nil {
+		return []Task{}, err
+	}
+	return tasks, nil
+}
+
+func GetNodeCount(query interface{}) (int, error) {
+	s, c := database.GetCol("nodes")
+	defer s.Close()
+
+	count, err := c.Find(query).Count()
+	if err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
--- a/backend/model/schedule.go
+++ b/backend/model/schedule.go
@@ -0,0 +1,143 @@
+package model
+
+import (
+	"crawlab/constants"
+	"crawlab/database"
+	"crawlab/lib/cron"
+	"github.com/apex/log"
+	"github.com/globalsign/mgo/bson"
+	"runtime/debug"
+	"time"
+)
+
+type Schedule struct {
+	Id          bson.ObjectId `json:"_id" bson:"_id"`
+	Name        string        `json:"name" bson:"name"`
+	Description string        `json:"description" bson:"description"`
+	SpiderId    bson.ObjectId `json:"spider_id" bson:"spider_id"`
+	NodeId      bson.ObjectId `json:"node_id" bson:"node_id"`
+	Cron        string        `json:"cron" bson:"cron"`
+	EntryId     cron.EntryID  `json:"entry_id" bson:"entry_id"`
+
+	// 前端展示
+	SpiderName string `json:"spider_name" bson:"spider_name"`
+	NodeName   string `json:"node_name" bson:"node_name"`
+
+	CreateTs time.Time `json:"create_ts" bson:"create_ts"`
+	UpdateTs time.Time `json:"update_ts" bson:"update_ts"`
+}
+
+func (sch *Schedule) Save() error {
+	s, c := database.GetCol("schedules")
+	defer s.Close()
+	sch.UpdateTs = time.Now()
+	if err := c.UpdateId(sch.Id, sch); err != nil {
+		return err
+	}
+	return nil
+}
+
+func GetScheduleList(filter interface{}) ([]Schedule, error) {
+	s, c := database.GetCol("schedules")
+	defer s.Close()
+
+	var schedules []Schedule
+	if err := c.Find(filter).All(&schedules); err != nil {
+		return schedules, err
+	}
+
+	for i, schedule := range schedules {
+		// 获取节点名称
+		if schedule.NodeId == bson.ObjectIdHex(constants.ObjectIdNull) {
+			// 选择所有节点
+			schedules[i].NodeName = "All Nodes"
+		} else {
+			// 选择单一节点
+			node, err := GetNode(schedule.NodeId)
+			if err != nil {
+				log.Errorf(err.Error())
+				continue
+			}
+			schedules[i].NodeName = node.Name
+		}
+
+		// 获取爬虫名称
+		spider, err := GetSpider(schedule.SpiderId)
+		if err != nil {
+			log.Errorf(err.Error())
+			continue
+		}
+		schedules[i].SpiderName = spider.Name
+	}
+	return schedules, nil
+}
+
+func GetSchedule(id bson.ObjectId) (Schedule, error) {
+	s, c := database.GetCol("schedules")
+	defer s.Close()
+
+	var result Schedule
+	if err := c.FindId(id).One(&result); err != nil {
+		return result, err
+	}
+	return result, nil
+}
+
+func UpdateSchedule(id bson.ObjectId, item Schedule) error {
+	s, c := database.GetCol("schedules")
+	defer s.Close()
+
+	var result Schedule
+	if err := c.FindId(id).One(&result); err != nil {
+		return err
+	}
+
+	if err := item.Save(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func AddSchedule(item Schedule) error {
+	s, c := database.GetCol("schedules")
+	defer s.Close()
+
+	item.Id = bson.NewObjectId()
+	item.CreateTs = time.Now()
+	item.UpdateTs = time.Now()
+
+	if err := c.Insert(&item); err != nil {
+		debug.PrintStack()
+		log.Errorf(err.Error())
+		return err
+	}
+	return nil
+}
+
+func RemoveSchedule(id bson.ObjectId) error {
+	s, c := database.GetCol("schedules")
+	defer s.Close()
+
+	var result Schedule
+	if err := c.FindId(id).One(&result); err != nil {
+		return err
+	}
+
+	if err := c.RemoveId(id); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func GetScheduleCount() (int, error) {
+	s, c := database.GetCol("schedules")
+	defer s.Close()
+
+	count, err := c.Count()
+	if err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
--- a/backend/model/spider.go
+++ b/backend/model/spider.go
@@ -0,0 +1,181 @@
+package model
+
+import (
+	"crawlab/database"
+	"github.com/apex/log"
+	"github.com/globalsign/mgo"
+	"github.com/globalsign/mgo/bson"
+	"runtime/debug"
+	"time"
+)
+
+type Env struct {
+	Name  string `json:"name" bson:"name"`
+	Value string `json:"value" bson:"value"`
+}
+
+type Spider struct {
+	Id          bson.ObjectId `json:"_id" bson:"_id"`                   // 爬虫ID
+	Name        string        `json:"name" bson:"name"`                 // 爬虫名称（唯一）
+	DisplayName string        `json:"display_name" bson:"display_name"` // 爬虫显示名称
+	Type        string        `json:"type"`                             // 爬虫类别
+	FileId      bson.ObjectId `json:"file_id" bson:"file_id"`           // GridFS文件ID
+	Col         string        `json:"col"`                              // 结果储存位置
+	Site        string        `json:"site"`                             // 爬虫网站
+	Envs        []Env         `json:"envs" bson:"envs"`                 // 环境变量
+
+	// 自定义爬虫
+	Src string `json:"src" bson:"src"` // 源码位置
+	Cmd string `json:"cmd" bson:"cmd"` // 执行命令
+
+	// 前端展示
+	LastRunTs time.Time `json:"last_run_ts"` // 最后一次执行时间
+
+	// TODO: 可配置爬虫
+	//Fields                 []interface{} `json:"fields"`
+	//DetailFields           []interface{} `json:"detail_fields"`
+	//CrawlType              string        `json:"crawl_type"`
+	//StartUrl               string        `json:"start_url"`
+	//UrlPattern             string        `json:"url_pattern"`
+	//ItemSelector           string        `json:"item_selector"`
+	//ItemSelectorType       string        `json:"item_selector_type"`
+	//PaginationSelector     string        `json:"pagination_selector"`
+	//PaginationSelectorType string        `json:"pagination_selector_type"`
+
+	CreateTs time.Time `json:"create_ts" bson:"create_ts"`
+	UpdateTs time.Time `json:"update_ts" bson:"update_ts"`
+}
+
+func (spider *Spider) Save() error {
+	s, c := database.GetCol("spiders")
+	defer s.Close()
+
+	spider.UpdateTs = time.Now()
+
+	if err := c.UpdateId(spider.Id, spider); err != nil {
+		debug.PrintStack()
+		return err
+	}
+	return nil
+}
+
+func (spider *Spider) Add() error {
+	s, c := database.GetCol("spiders")
+	defer s.Close()
+
+	spider.Id = bson.NewObjectId()
+	spider.CreateTs = time.Now()
+	spider.UpdateTs = time.Now()
+
+	if err := c.Insert(&spider); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (spider *Spider) GetTasks() ([]Task, error) {
+	tasks, err := GetTaskList(bson.M{"spider_id": spider.Id}, 0, 10, "-create_ts")
+	if err != nil {
+		return tasks, err
+	}
+	return tasks, nil
+}
+
+func (spider *Spider) GetLastTask() (Task, error) {
+	tasks, err := GetTaskList(bson.M{"spider_id": spider.Id}, 0, 1, "-create_ts")
+	if err != nil {
+		return Task{}, err
+	}
+	if tasks == nil {
+		return Task{}, nil
+	}
+	return tasks[0], nil
+}
+
+
+
+func GetSpiderList(filter interface{}, skip int, limit int) ([]Spider, error) {
+	s, c := database.GetCol("spiders")
+	defer s.Close()
+
+	// 获取爬虫列表
+	var spiders []Spider
+	if err := c.Find(filter).Skip(skip).Limit(limit).All(&spiders); err != nil {
+		debug.PrintStack()
+		return spiders, err
+	}
+
+	// 遍历爬虫列表
+	for i, spider := range spiders {
+		// 获取最后一次任务
+		task, err := spider.GetLastTask()
+		if err != nil {
+			log.Errorf(err.Error())
+			debug.PrintStack()
+			continue
+		}
+
+		// 赋值
+		spiders[i].LastRunTs = task.CreateTs
+	}
+
+	return spiders, nil
+}
+
+func GetSpider(id bson.ObjectId) (Spider, error) {
+	s, c := database.GetCol("spiders")
+	defer s.Close()
+
+	var result Spider
+	if err := c.FindId(id).One(&result); err != nil {
+		if err != mgo.ErrNotFound {
+			debug.PrintStack()
+		}
+		return result, err
+	}
+	return result, nil
+}
+
+func UpdateSpider(id bson.ObjectId, item Spider) error {
+	s, c := database.GetCol("spiders")
+	defer s.Close()
+
+	var result Spider
+	if err := c.FindId(id).One(&result); err != nil {
+		debug.PrintStack()
+		return err
+	}
+
+	if err := item.Save(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func RemoveSpider(id bson.ObjectId) error {
+	s, c := database.GetCol("spiders")
+	defer s.Close()
+
+	var result Spider
+	if err := c.FindId(id).One(&result); err != nil {
+		return err
+	}
+
+	if err := c.RemoveId(id); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func GetSpiderCount() (int, error) {
+	s, c := database.GetCol("spiders")
+	defer s.Close()
+
+	count, err := c.Count()
+	if err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
--- a/backend/model/system.go
+++ b/backend/model/system.go
@@ -0,0 +1,15 @@
+package model
+
+type SystemInfo struct {
+	ARCH        string       `json:"arch"`
+	OS          string       `json:"os"`
+	Hostname    string       `json:"host_name"`
+	NumCpu      int          `json:"num_cpu"`
+	Executables []Executable `json:"executables"`
+}
+
+type Executable struct {
+	Path        string `json:"path"`
+	FileName    string `json:"file_name"`
+	DisplayName string `json:"display_name"`
+}
--- a/backend/model/task.go
+++ b/backend/model/task.go
@@ -0,0 +1,329 @@
+package model
+
+import (
+	"crawlab/constants"
+	"crawlab/database"
+	"github.com/apex/log"
+	"github.com/globalsign/mgo"
+	"github.com/globalsign/mgo/bson"
+	"runtime/debug"
+	"time"
+)
+
+type Task struct {
+	Id              string        `json:"_id" bson:"_id"`
+	SpiderId        bson.ObjectId `json:"spider_id" bson:"spider_id"`
+	StartTs         time.Time     `json:"start_ts" bson:"start_ts"`
+	FinishTs        time.Time     `json:"finish_ts" bson:"finish_ts"`
+	Status          string        `json:"status" bson:"status"`
+	NodeId          bson.ObjectId `json:"node_id" bson:"node_id"`
+	LogPath         string        `json:"log_path" bson:"log_path"`
+	Cmd             string        `json:"cmd" bson:"cmd"`
+	Error           string        `json:"error" bson:"error"`
+	ResultCount     int           `json:"result_count" bson:"result_count"`
+	WaitDuration    float64       `json:"wait_duration" bson:"wait_duration"`
+	RuntimeDuration float64       `json:"runtime_duration" bson:"runtime_duration"`
+	TotalDuration   float64       `json:"total_duration" bson:"total_duration"`
+
+	// 前端数据
+	SpiderName string `json:"spider_name"`
+	NodeName   string `json:"node_name"`
+
+	CreateTs time.Time `json:"create_ts" bson:"create_ts"`
+	UpdateTs time.Time `json:"update_ts" bson:"update_ts"`
+}
+
+type TaskDailyItem struct {
+	Date               string  `json:"date" bson:"_id"`
+	TaskCount          int     `json:"task_count" bson:"task_count"`
+	AvgRuntimeDuration float64 `json:"avg_runtime_duration" bson:"avg_runtime_duration"`
+}
+
+func (t *Task) GetSpider() (Spider, error) {
+	spider, err := GetSpider(t.SpiderId)
+	if err != nil {
+		return spider, err
+	}
+	return spider, nil
+}
+
+func (t *Task) GetNode() (Node, error) {
+	node, err := GetNode(t.NodeId)
+	if err != nil {
+		return node, err
+	}
+	return node, nil
+}
+
+func (t *Task) Save() error {
+	s, c := database.GetCol("tasks")
+	defer s.Close()
+	t.UpdateTs = time.Now()
+	if err := c.UpdateId(t.Id, t); err != nil {
+		debug.PrintStack()
+		return err
+	}
+	return nil
+}
+
+func (t *Task) Delete() error {
+	s, c := database.GetCol("tasks")
+	defer s.Close()
+	if err := c.RemoveId(t.Id); err != nil {
+		return err
+	}
+	return nil
+}
+
+func (t *Task) GetResults(pageNum int, pageSize int) (results []interface{}, total int, err error) {
+	spider, err := t.GetSpider()
+	if err != nil {
+		log.Errorf(err.Error())
+		return
+	}
+
+	if spider.Col == "" {
+		return
+	}
+
+	s, c := database.GetCol(spider.Col)
+	defer s.Close()
+
+	query := bson.M{
+		"task_id": t.Id,
+	}
+	if err = c.Find(query).Skip((pageNum - 1) * pageSize).Limit(pageSize).Sort("-create_ts").All(&results); err != nil {
+		return
+	}
+
+	if total, err = c.Find(query).Count(); err != nil {
+		return
+	}
+
+	return
+}
+
+func GetTaskList(filter interface{}, skip int, limit int, sortKey string) ([]Task, error) {
+	s, c := database.GetCol("tasks")
+	defer s.Close()
+
+	var tasks []Task
+	if err := c.Find(filter).Skip(skip).Limit(limit).Sort(sortKey).All(&tasks); err != nil {
+		debug.PrintStack()
+		return tasks, err
+	}
+
+	for i, task := range tasks {
+		// 获取爬虫名称
+		spider, err := task.GetSpider()
+		if err == mgo.ErrNotFound {
+			// do nothing
+		} else if err != nil {
+			return tasks, err
+		} else {
+			tasks[i].SpiderName = spider.DisplayName
+		}
+
+		// 获取节点名称
+		node, err := task.GetNode()
+		if err == mgo.ErrNotFound {
+			// do nothing
+		} else if err != nil {
+			return tasks, err
+		} else {
+			tasks[i].NodeName = node.Name
+		}
+	}
+	return tasks, nil
+}
+
+func GetTaskListTotal(filter interface{}) (int, error) {
+	s, c := database.GetCol("tasks")
+	defer s.Close()
+
+	var result int
+	result, err := c.Find(filter).Count()
+	if err != nil {
+		return result, err
+	}
+	return result, nil
+}
+
+func GetTask(id string) (Task, error) {
+	s, c := database.GetCol("tasks")
+	defer s.Close()
+
+	var task Task
+	if err := c.FindId(id).One(&task); err != nil {
+		debug.PrintStack()
+		return task, err
+	}
+	return task, nil
+}
+
+func AddTask(item Task) error {
+	s, c := database.GetCol("tasks")
+	defer s.Close()
+
+	item.CreateTs = time.Now()
+	item.UpdateTs = time.Now()
+
+	if err := c.Insert(&item); err != nil {
+		return err
+	}
+	return nil
+}
+
+func RemoveTask(id string) error {
+	s, c := database.GetCol("tasks")
+	defer s.Close()
+
+	var result Task
+	if err := c.FindId(id).One(&result); err != nil {
+		return err
+	}
+
+	if err := c.RemoveId(id); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func GetTaskCount(query interface{}) (int, error) {
+	s, c := database.GetCol("tasks")
+	defer s.Close()
+
+	count, err := c.Find(query).Count()
+	if err != nil {
+		return 0, err
+	}
+
+	return count, nil
+}
+
+func GetDailyTaskStats(query bson.M) ([]TaskDailyItem, error) {
+	s, c := database.GetCol("tasks")
+	defer s.Close()
+
+	// 起始日期
+	startDate := time.Now().Add(- 30 * 24 * time.Hour)
+	endDate := time.Now()
+
+	// query
+	query["create_ts"] = bson.M{
+		"$gte": startDate,
+		"$lt":  endDate,
+	}
+
+	// match
+	op1 := bson.M{
+		"$match": query,
+	}
+
+	// project
+	op2 := bson.M{
+		"$project": bson.M{
+			"date": bson.M{
+				"$dateToString": bson.M{
+					"format":   "%Y%m%d",
+					"date":     "$create_ts",
+					"timezone": "Asia/Shanghai",
+				},
+			},
+			"success_count": bson.M{
+				"$cond": []interface{}{
+					bson.M{
+						"$eq": []string{
+							"$status",
+							constants.StatusFinished,
+						},
+					},
+					1,
+					0,
+				},
+			},
+			"runtime_duration": "$runtime_duration",
+		},
+	}
+
+	// group
+	op3 := bson.M{
+		"$group": bson.M{
+			"_id":              "$date",
+			"task_count":       bson.M{"$sum": 1},
+			"runtime_duration": bson.M{"$sum": "$runtime_duration"},
+		},
+	}
+
+	op4 := bson.M{
+		"$project": bson.M{
+			"task_count": "$task_count",
+			"date":       "$date",
+			"avg_runtime_duration": bson.M{
+				"$divide": []string{"$runtime_duration", "$task_count"},
+			},
+		},
+	}
+
+	// run aggregation
+	var items []TaskDailyItem
+	if err := c.Pipe([]bson.M{op1, op2, op3, op4}).All(&items); err != nil {
+		return items, err
+	}
+
+	// 缓存每日数据
+	dict := make(map[string]TaskDailyItem)
+	for _, item := range items {
+		dict[item.Date] = item
+	}
+
+	// 遍历日期
+	var dailyItems []TaskDailyItem
+	for date := startDate; endDate.Sub(date) > 0; date = date.Add(24 * time.Hour) {
+		dateStr := date.Format("20060102")
+		dailyItems = append(dailyItems, TaskDailyItem{
+			Date:               dateStr,
+			TaskCount:          dict[dateStr].TaskCount,
+			AvgRuntimeDuration: dict[dateStr].AvgRuntimeDuration,
+		})
+	}
+
+	return dailyItems, nil
+}
+
+func UpdateTaskResultCount(id string) (err error) {
+	// 获取任务
+	task, err := GetTask(id)
+	if err != nil {
+		log.Errorf(err.Error())
+		return err
+	}
+
+	// 获取爬虫
+	spider, err := GetSpider(task.SpiderId)
+	if err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return err
+	}
+
+	// 获取结果数量
+	s, c := database.GetCol(spider.Col)
+	defer s.Close()
+	resultCount, err := c.Find(bson.M{"task_id": task.Id}).Count()
+	if err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return err
+	}
+
+	// 保存结果数量
+	task.ResultCount = resultCount
+	if err := task.Save(); err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return err
+	}
+	return nil
+}
--- a/backend/model/user.go
+++ b/backend/model/user.go
@@ -0,0 +1,157 @@
+package model
+
+import (
+	"crawlab/database"
+	"crawlab/utils"
+	"github.com/apex/log"
+	"github.com/globalsign/mgo"
+	"github.com/globalsign/mgo/bson"
+	"github.com/pkg/errors"
+	"runtime/debug"
+	"time"
+)
+
+type User struct {
+	Id       bson.ObjectId `json:"_id" bson:"_id"`
+	Username string        `json:"username" bson:"username"`
+	Password string        `json:"password" bson:"password"`
+	Role     string        `json:"role" bson:"role"`
+
+	CreateTs time.Time `json:"create_ts" bson:"create_ts"`
+	UpdateTs time.Time `json:"update_ts" bson:"update_ts"`
+}
+
+func (user *User) Save() error {
+	s, c := database.GetCol("users")
+	defer s.Close()
+
+	user.UpdateTs = time.Now()
+
+	if err := c.UpdateId(user.Id, user); err != nil {
+		debug.PrintStack()
+		return err
+	}
+	return nil
+}
+
+func (user *User) Add() error {
+	s, c := database.GetCol("users")
+	defer s.Close()
+
+	// 如果存在用户名相同的用户，抛错
+	user2, err := GetUserByUsername(user.Username)
+	if err != nil {
+		if err == mgo.ErrNotFound {
+			// pass
+		} else {
+			log.Errorf(err.Error())
+			debug.PrintStack()
+			return err
+		}
+	} else {
+		if user2.Username == user.Username {
+			return errors.New("username already exists")
+		}
+	}
+
+	user.Id = bson.NewObjectId()
+	user.UpdateTs = time.Now()
+	user.CreateTs = time.Now()
+	if err := c.Insert(user); err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return err
+	}
+
+	return nil
+}
+
+func GetUser(id bson.ObjectId) (User, error) {
+	s, c := database.GetCol("users")
+	defer s.Close()
+	var user User
+	if err := c.Find(bson.M{"_id": id}).One(&user); err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return user, err
+	}
+	return user, nil
+}
+
+func GetUserByUsername(username string) (User, error) {
+	s, c := database.GetCol("users")
+	defer s.Close()
+
+	var user User
+	if err := c.Find(bson.M{"username": username}).One(&user); err != nil {
+		if err != mgo.ErrNotFound {
+			log.Errorf(err.Error())
+			debug.PrintStack()
+			return user, err
+		}
+	}
+
+	return user, nil
+}
+
+func GetUserList(filter interface{}, skip int, limit int, sortKey string) ([]User, error) {
+	s, c := database.GetCol("users")
+	defer s.Close()
+
+	var users []User
+	if err := c.Find(filter).Skip(skip).Limit(limit).Sort(sortKey).All(&users); err != nil {
+		debug.PrintStack()
+		return users, err
+	}
+	return users, nil
+}
+
+func GetUserListTotal(filter interface{}) (int, error) {
+	s, c := database.GetCol("users")
+	defer s.Close()
+
+	var result int
+	result, err := c.Find(filter).Count()
+	if err != nil {
+		return result, err
+	}
+	return result, nil
+}
+
+func UpdateUser(id bson.ObjectId, item User) error {
+	s, c := database.GetCol("users")
+	defer s.Close()
+
+	var result User
+	if err := c.FindId(id).One(&result); err != nil {
+		debug.PrintStack()
+		return err
+	}
+
+	if item.Password == "" {
+		item.Password = result.Password
+	} else {
+		item.Password = utils.EncryptPassword(item.Password)
+	}
+
+	if err := item.Save(); err != nil {
+		return err
+	}
+	return nil
+}
+
+func RemoveUser(id bson.ObjectId) error {
+	s, c := database.GetCol("users")
+	defer s.Close()
+
+	var result User
+	if err := c.FindId(id).One(&result); err != nil {
+		return err
+	}
+
+	if err := c.RemoveId(id); err != nil {
+		return err
+	}
+
+	return nil
+}
--- a/backend/routes/base.go
+++ b/backend/routes/base.go
@@ -0,0 +1,16 @@
+package routes
+
+type Response struct {
+	Status  string      `json:"status"`
+	Message string      `json:"message"`
+	Data    interface{} `json:"data"`
+	Error   string      `json:"error"`
+}
+
+type ListResponse struct {
+	Status  string      `json:"status"`
+	Message string      `json:"message"`
+	Total   int         `json:"total"`
+	Data    interface{} `json:"data"`
+	Error   string      `json:"error"`
+}
--- a/backend/routes/file.go
+++ b/backend/routes/file.go
@@ -0,0 +1,20 @@
+package routes
+
+import (
+	"github.com/gin-gonic/gin"
+	"io/ioutil"
+	"net/http"
+)
+
+func GetFile(c *gin.Context) {
+	path := c.Query("path")
+	fileBytes, err := ioutil.ReadFile(path)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+	}
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    string(fileBytes),
+	})
+}
--- a/backend/routes/node.go
+++ b/backend/routes/node.go
@@ -0,0 +1,110 @@
+package routes
+
+import (
+	"crawlab/model"
+	"crawlab/services"
+	"github.com/gin-gonic/gin"
+	"github.com/globalsign/mgo/bson"
+	"net/http"
+)
+
+func GetNodeList(c *gin.Context) {
+	nodes, err := model.GetNodeList(nil)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	for i, node := range nodes {
+		nodes[i].IsMaster = services.IsMasterNode(node.Id.Hex())
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    nodes,
+	})
+}
+
+func GetNode(c *gin.Context) {
+	id := c.Param("id")
+
+	result, err := model.GetNode(bson.ObjectIdHex(id))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    result,
+	})
+}
+
+func Ping(c *gin.Context) {
+	data, err := services.GetNodeData()
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    data,
+	})
+}
+
+func PostNode(c *gin.Context) {
+	id := c.Param("id")
+
+	item, err := model.GetNode(bson.ObjectIdHex(id))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	var newItem model.Node
+	if err := c.ShouldBindJSON(&newItem); err != nil {
+		HandleError(http.StatusBadRequest, c, err)
+		return
+	}
+	newItem.Id = item.Id
+
+	if err := model.UpdateNode(bson.ObjectIdHex(id), newItem); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func GetNodeTaskList(c *gin.Context) {
+	id := c.Param("id")
+
+	tasks, err := model.GetNodeTaskList(bson.ObjectIdHex(id))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    tasks,
+	})
+}
+
+func GetSystemInfo(c *gin.Context) {
+	id := c.Param("id")
+
+	sysInfo, _ := services.GetSystemInfo(id)
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    sysInfo,
+	})
+}
--- a/backend/routes/schedule.go
+++ b/backend/routes/schedule.go
@@ -0,0 +1,125 @@
+package routes
+
+import (
+	"crawlab/constants"
+	"crawlab/model"
+	"crawlab/services"
+	"github.com/gin-gonic/gin"
+	"github.com/globalsign/mgo/bson"
+	"net/http"
+)
+
+func GetScheduleList(c *gin.Context) {
+	results, err := model.GetScheduleList(nil)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    results,
+	})
+}
+
+func GetSchedule(c *gin.Context) {
+	id := c.Param("id")
+
+	result, err := model.GetSchedule(bson.ObjectIdHex(id))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    result,
+	})
+}
+
+func PostSchedule(c *gin.Context) {
+	id := c.Param("id")
+
+	// 绑定数据模型
+	var newItem model.Schedule
+	if err := c.ShouldBindJSON(&newItem); err != nil {
+		HandleError(http.StatusBadRequest, c, err)
+		return
+	}
+	newItem.Id = bson.ObjectIdHex(id)
+
+	// 如果node_id为空，则置为空ObjectId
+	if newItem.NodeId == "" {
+		newItem.NodeId = bson.ObjectIdHex(constants.ObjectIdNull)
+	}
+
+	// 更新数据库
+	if err := model.UpdateSchedule(bson.ObjectIdHex(id), newItem); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 更新定时任务
+	if err := services.Sched.Update(); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func PutSchedule(c *gin.Context) {
+	var item model.Schedule
+
+	// 绑定数据模型
+	if err := c.ShouldBindJSON(&item); err != nil {
+		HandleError(http.StatusBadRequest, c, err)
+		return
+	}
+
+	// 如果node_id为空，则置为空ObjectId
+	if item.NodeId == "" {
+		item.NodeId = bson.ObjectIdHex(constants.ObjectIdNull)
+	}
+
+	// 更新数据库
+	if err := model.AddSchedule(item); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 更新定时任务
+	if err := services.Sched.Update(); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func DeleteSchedule(c *gin.Context) {
+	id := c.Param("id")
+
+	// 删除定时任务
+	if err := model.RemoveSchedule(bson.ObjectIdHex(id)); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 更新定时任务
+	if err := services.Sched.Update(); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
--- a/backend/routes/spider.go
+++ b/backend/routes/spider.go
@@ -0,0 +1,470 @@
+package routes
+
+import (
+	"crawlab/constants"
+	"crawlab/database"
+	"crawlab/model"
+	"crawlab/services"
+	"crawlab/utils"
+	"github.com/apex/log"
+	"github.com/gin-gonic/gin"
+	"github.com/globalsign/mgo"
+	"github.com/globalsign/mgo/bson"
+	"github.com/pkg/errors"
+	uuid "github.com/satori/go.uuid"
+	"github.com/spf13/viper"
+	"io/ioutil"
+	"net/http"
+	"os"
+	"path/filepath"
+	"runtime/debug"
+	"strconv"
+	"strings"
+	"time"
+)
+
+func GetSpiderList(c *gin.Context) {
+	results, err := model.GetSpiderList(nil, 0, 0)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    results,
+	})
+}
+
+func GetSpider(c *gin.Context) {
+	id := c.Param("id")
+
+	if !bson.IsObjectIdHex(id) {
+		HandleErrorF(http.StatusBadRequest, c, "invalid id")
+	}
+
+	result, err := model.GetSpider(bson.ObjectIdHex(id))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    result,
+	})
+}
+
+func PostSpider(c *gin.Context) {
+	id := c.Param("id")
+
+	if !bson.IsObjectIdHex(id) {
+		HandleErrorF(http.StatusBadRequest, c, "invalid id")
+	}
+
+	var item model.Spider
+	if err := c.ShouldBindJSON(&item); err != nil {
+		HandleError(http.StatusBadRequest, c, err)
+		return
+	}
+
+	if err := model.UpdateSpider(bson.ObjectIdHex(id), item); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func PublishAllSpiders(c *gin.Context) {
+	if err := services.PublishAllSpiders(); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func PublishSpider(c *gin.Context) {
+	id := c.Param("id")
+
+	if !bson.IsObjectIdHex(id) {
+		HandleErrorF(http.StatusBadRequest, c, "invalid id")
+	}
+
+	spider, err := model.GetSpider(bson.ObjectIdHex(id))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	if err := services.PublishSpider(spider); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func PutSpider(c *gin.Context) {
+	// 从body中获取文件
+	file, err := c.FormFile("file")
+	if err != nil {
+		debug.PrintStack()
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 如果不为zip文件，返回错误
+	if !strings.HasSuffix(file.Filename, ".zip") {
+		debug.PrintStack()
+		HandleError(http.StatusBadRequest, c, errors.New("Not a valid zip file"))
+		return
+	}
+
+	// 保存到本地临时文件
+	randomId := uuid.NewV4()
+	tmpFilePath := filepath.Join(viper.GetString("other.tmppath"), randomId.String()+".zip")
+	if err := c.SaveUploadedFile(file, tmpFilePath); err != nil {
+		debug.PrintStack()
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 读取临时文件
+	tmpFile, err := os.OpenFile(tmpFilePath, os.O_RDONLY, 0777)
+	if err != nil {
+		debug.PrintStack()
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+	if err = tmpFile.Close(); err != nil {
+		debug.PrintStack()
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 目标目录
+	dstPath := filepath.Join(
+		viper.GetString("spider.path"),
+		strings.Replace(file.Filename, ".zip", "", 1),
+	)
+
+	// 如果目标目录已存在，删除目标目录
+	if utils.Exists(dstPath) {
+		if err := os.RemoveAll(dstPath); err != nil {
+			debug.PrintStack()
+			HandleError(http.StatusInternalServerError, c, err)
+		}
+	}
+
+	// 将临时文件解压到爬虫目录
+	if err := utils.DeCompress(tmpFile, dstPath); err != nil {
+		debug.PrintStack()
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 删除临时文件
+	if err = os.Remove(tmpFilePath); err != nil {
+		debug.PrintStack()
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 更新爬虫
+	services.UpdateSpiders()
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func DeleteSpider(c *gin.Context) {
+	id := c.Param("id")
+
+	if !bson.IsObjectIdHex(id) {
+		HandleErrorF(http.StatusBadRequest, c, "invalid id")
+		return
+	}
+
+	// 获取该爬虫
+	spider, err := model.GetSpider(bson.ObjectIdHex(id))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 删除爬虫文件目录
+	if err := os.RemoveAll(spider.Src); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 从数据库中删除该爬虫
+	if err := model.RemoveSpider(bson.ObjectIdHex(id)); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func GetSpiderTasks(c *gin.Context) {
+	id := c.Param("id")
+
+	spider, err := model.GetSpider(bson.ObjectIdHex(id))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	tasks, err := spider.GetTasks()
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    tasks,
+	})
+}
+
+func GetSpiderDir(c *gin.Context) {
+	// 爬虫ID
+	id := c.Param("id")
+
+	// 目录相对路径
+	path := c.Query("path")
+
+	// 获取爬虫
+	spider, err := model.GetSpider(bson.ObjectIdHex(id))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 获取目录下文件列表
+	f, err := ioutil.ReadDir(filepath.Join(spider.Src, path))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 遍历文件列表
+	var fileList []model.File
+	for _, file := range f {
+		fileList = append(fileList, model.File{
+			Name:  file.Name(),
+			IsDir: file.IsDir(),
+			Size:  file.Size(),
+			Path:  filepath.Join(path, file.Name()),
+		})
+	}
+
+	// 返回结果
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    fileList,
+	})
+}
+
+func GetSpiderFile(c *gin.Context) {
+	// 爬虫ID
+	id := c.Param("id")
+
+	// 文件相对路径
+	path := c.Query("path")
+
+	// 获取爬虫
+	spider, err := model.GetSpider(bson.ObjectIdHex(id))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 读取文件
+	fileBytes, err := ioutil.ReadFile(filepath.Join(spider.Src, path))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+	}
+
+	// 返回结果
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    string(fileBytes),
+	})
+}
+
+type SpiderFileReqBody struct {
+	Path    string `json:"path"`
+	Content string `json:"content"`
+}
+
+func PostSpiderFile(c *gin.Context) {
+	// 爬虫ID
+	id := c.Param("id")
+
+	// 文件相对路径
+	var reqBody SpiderFileReqBody
+	if err := c.ShouldBindJSON(&reqBody); err != nil {
+		HandleError(http.StatusBadRequest, c, err)
+		return
+	}
+
+	// 获取爬虫
+	spider, err := model.GetSpider(bson.ObjectIdHex(id))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 写文件
+	if err := ioutil.WriteFile(filepath.Join(spider.Src, reqBody.Path), []byte(reqBody.Content), os.ModePerm); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 返回结果
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func GetSpiderStats(c *gin.Context) {
+	type Overview struct {
+		TaskCount            int     `json:"task_count" bson:"task_count"`
+		ResultCount          int     `json:"result_count" bson:"result_count"`
+		SuccessCount         int     `json:"success_count" bson:"success_count"`
+		SuccessRate          float64 `json:"success_rate"`
+		TotalWaitDuration    float64 `json:"wait_duration" bson:"wait_duration"`
+		TotalRuntimeDuration float64 `json:"runtime_duration" bson:"runtime_duration"`
+		AvgWaitDuration      float64 `json:"avg_wait_duration"`
+		AvgRuntimeDuration   float64 `json:"avg_runtime_duration"`
+	}
+
+	type Data struct {
+		Overview Overview              `json:"overview"`
+		Daily    []model.TaskDailyItem `json:"daily"`
+	}
+
+	id := c.Param("id")
+
+	spider, err := model.GetSpider(bson.ObjectIdHex(id))
+	if err != nil {
+		log.Errorf(err.Error())
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	s, col := database.GetCol("tasks")
+	defer s.Close()
+
+	// 起始日期
+	startDate := time.Now().Add(-time.Hour * 24 * 30)
+	endDate := time.Now()
+
+	// match
+	op1 := bson.M{
+		"$match": bson.M{
+			"spider_id": spider.Id,
+			"create_ts": bson.M{
+				"$gte": startDate,
+				"$lt":  endDate,
+			},
+		},
+	}
+
+	// project
+	op2 := bson.M{
+		"$project": bson.M{
+			"success_count": bson.M{
+				"$cond": []interface{}{
+					bson.M{
+						"$eq": []string{
+							"$status",
+							constants.StatusFinished,
+						},
+					},
+					1,
+					0,
+				},
+			},
+			"result_count":     "$result_count",
+			"wait_duration":    "$wait_duration",
+			"runtime_duration": "$runtime_duration",
+		},
+	}
+
+	// group
+	op3 := bson.M{
+		"$group": bson.M{
+			"_id":              nil,
+			"task_count":       bson.M{"$sum": 1},
+			"success_count":    bson.M{"$sum": "$success_count"},
+			"result_count":     bson.M{"$sum": "$result_count"},
+			"wait_duration":    bson.M{"$sum": "$wait_duration"},
+			"runtime_duration": bson.M{"$sum": "$runtime_duration"},
+		},
+	}
+
+	// run aggregation pipeline
+	var overview Overview
+	if err := col.Pipe([]bson.M{op1, op2, op3}).One(&overview); err != nil {
+		if err == mgo.ErrNotFound {
+			c.JSON(http.StatusOK, Response{
+				Status:  "ok",
+				Message: "success",
+				Data: Data{
+					Overview: overview,
+					Daily:    []model.TaskDailyItem{},
+				},
+			})
+			return
+		}
+		log.Errorf(err.Error())
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 后续处理
+	successCount, _ := strconv.ParseFloat(strconv.Itoa(overview.SuccessCount), 64)
+	taskCount, _ := strconv.ParseFloat(strconv.Itoa(overview.TaskCount), 64)
+	overview.SuccessRate = successCount / taskCount
+	overview.AvgWaitDuration = overview.TotalWaitDuration / taskCount
+	overview.AvgRuntimeDuration = overview.TotalRuntimeDuration / taskCount
+
+	items, err := model.GetDailyTaskStats(bson.M{"spider_id": spider.Id})
+	if err != nil {
+		log.Errorf(err.Error())
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data: Data{
+			Overview: overview,
+			Daily:    items,
+		},
+	})
+}
--- a/backend/routes/stats.go
+++ b/backend/routes/stats.go
@@ -0,0 +1,72 @@
+package routes
+
+import (
+	"crawlab/constants"
+	"crawlab/model"
+	"github.com/gin-gonic/gin"
+	"github.com/globalsign/mgo/bson"
+	"net/http"
+)
+
+func GetHomeStats(c *gin.Context) {
+	type DataOverview struct {
+		TaskCount       int `json:"task_count"`
+		SpiderCount     int `json:"spider_count"`
+		ActiveNodeCount int `json:"active_node_count"`
+		ScheduleCount   int `json:"schedule_count"`
+	}
+
+	type Data struct {
+		Overview DataOverview          `json:"overview"`
+		Daily    []model.TaskDailyItem `json:"daily"`
+	}
+
+	// 任务总数
+	taskCount, err := model.GetTaskCount(nil)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 在线节点总数
+	activeNodeCount, err := model.GetNodeCount(bson.M{"status": constants.StatusOnline})
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 爬虫总数
+	spiderCount, err := model.GetSpiderCount()
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 定时任务数
+	scheduleCount, err := model.GetScheduleCount()
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 每日任务数
+	items, err := model.GetDailyTaskStats(bson.M{})
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data: Data{
+			Overview: DataOverview{
+				ActiveNodeCount: activeNodeCount,
+				TaskCount:       taskCount,
+				SpiderCount:     spiderCount,
+				ScheduleCount:   scheduleCount,
+			},
+			Daily: items,
+		},
+	})
+}
--- a/backend/routes/task.go
+++ b/backend/routes/task.go
@@ -0,0 +1,267 @@
+package routes
+
+import (
+	"bytes"
+	"crawlab/constants"
+	"crawlab/model"
+	"crawlab/services"
+	"crawlab/utils"
+	"encoding/csv"
+	"github.com/gin-gonic/gin"
+	"github.com/globalsign/mgo/bson"
+	uuid "github.com/satori/go.uuid"
+	"net/http"
+)
+
+type TaskListRequestData struct {
+	PageNum  int    `form:"page_num"`
+	PageSize int    `form:"page_size"`
+	NodeId   string `form:"node_id"`
+	SpiderId string `form:"spider_id"`
+}
+
+type TaskResultsRequestData struct {
+	PageNum  int `form:"page_num"`
+	PageSize int `form:"page_size"`
+}
+
+func GetTaskList(c *gin.Context) {
+	// 绑定数据
+	data := TaskListRequestData{}
+	if err := c.ShouldBindQuery(&data); err != nil {
+		HandleError(http.StatusBadRequest, c, err)
+		return
+	}
+	if data.PageNum == 0 {
+		data.PageNum = 1
+	}
+	if data.PageSize == 0 {
+		data.PageNum = 10
+	}
+
+	// 过滤条件
+	query := bson.M{}
+	if data.NodeId != "" {
+		query["node_id"] = bson.ObjectIdHex(data.NodeId)
+	}
+	if data.SpiderId != "" {
+		query["spider_id"] = bson.ObjectIdHex(data.SpiderId)
+	}
+
+	// 获取任务列表
+	tasks, err := model.GetTaskList(query, (data.PageNum-1)*data.PageSize, data.PageSize, "-create_ts")
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 获取总任务数
+	total, err := model.GetTaskListTotal(query)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, ListResponse{
+		Status:  "ok",
+		Message: "success",
+		Total:   total,
+		Data:    tasks,
+	})
+}
+
+func GetTask(c *gin.Context) {
+	id := c.Param("id")
+
+	result, err := model.GetTask(id)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    result,
+	})
+}
+
+func PutTask(c *gin.Context) {
+	// 生成任务ID
+	id := uuid.NewV4()
+
+	// 绑定数据
+	var t model.Task
+	if err := c.ShouldBindJSON(&t); err != nil {
+		HandleError(http.StatusBadRequest, c, err)
+		return
+	}
+	t.Id = id.String()
+	t.Status = constants.StatusPending
+
+	// 如果没有传入node_id，则置为null
+	if t.NodeId.Hex() == "" {
+		t.NodeId = bson.ObjectIdHex(constants.ObjectIdNull)
+	}
+
+	// 将任务存入数据库
+	if err := model.AddTask(t); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 加入任务队列
+	if err := services.AssignTask(t); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func DeleteTask(c *gin.Context) {
+	id := c.Param("id")
+
+	if err := model.RemoveTask(id); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func GetTaskLog(c *gin.Context) {
+	id := c.Param("id")
+
+	logStr, err := services.GetTaskLog(id)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    logStr,
+	})
+}
+
+func GetTaskResults(c *gin.Context) {
+	id := c.Param("id")
+
+	// 绑定数据
+	data := TaskResultsRequestData{}
+	if err := c.ShouldBindQuery(&data); err != nil {
+		HandleError(http.StatusBadRequest, c, err)
+		return
+	}
+
+	// 获取任务
+	task, err := model.GetTask(id)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 获取结果
+	results, total, err := task.GetResults(data.PageNum, data.PageSize)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, ListResponse{
+		Status:  "ok",
+		Message: "success",
+		Data:    results,
+		Total:   total,
+	})
+}
+
+func DownloadTaskResultsCsv(c *gin.Context) {
+	id := c.Param("id")
+
+	// 获取任务
+	task, err := model.GetTask(id)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 获取结果
+	results, _, err := task.GetResults(1, constants.Infinite)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 字段列表
+	var columns []string
+	if len(results) == 0 {
+		columns = []string{}
+	} else {
+		item := results[0].(bson.M)
+		for key := range item {
+			columns = append(columns, key)
+		}
+	}
+
+	// 缓冲
+	bytesBuffer := &bytes.Buffer{}
+
+	// 写入UTF-8 BOM，避免使用Microsoft Excel打开乱码
+	bytesBuffer.Write([]byte("\xEF\xBB\xBF"))
+
+	writer := csv.NewWriter(bytesBuffer)
+
+	// 写入表头
+	if err := writer.Write(columns); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 写入内容
+	for _, result := range results {
+		// 将result转换为[]string
+		item := result.(bson.M)
+		var values []string
+		for _, col := range columns {
+			value := utils.InterfaceToString(item[col])
+			values = append(values, value)
+		}
+
+		// 写入数据
+		if err := writer.Write(values); err != nil {
+			HandleError(http.StatusInternalServerError, c, err)
+			return
+		}
+	}
+
+	// 此时才会将缓冲区数据写入
+	writer.Flush()
+
+	// 设置下载的文件名
+	c.Writer.Header().Set("Content-Disposition", "attachment;filename=data.csv")
+
+	// 设置文件类型以及输出数据
+	c.Data(http.StatusOK, "text/csv", bytesBuffer.Bytes())
+}
+
+func CancelTask(c *gin.Context) {
+	id := c.Param("id")
+
+	if err := services.CancelTask(id); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
--- a/backend/routes/user.go
+++ b/backend/routes/user.go
@@ -0,0 +1,204 @@
+package routes
+
+import (
+	"crawlab/constants"
+	"crawlab/model"
+	"crawlab/services"
+	"crawlab/utils"
+	"github.com/gin-gonic/gin"
+	"github.com/globalsign/mgo/bson"
+	"github.com/pkg/errors"
+	"net/http"
+	"strings"
+)
+
+type UserListRequestData struct {
+	PageNum  int `form:"page_num"`
+	PageSize int `form:"page_size"`
+}
+
+type UserRequestData struct {
+	Username string `json:"username"`
+	Password string `json:"password"`
+}
+
+func GetUser(c *gin.Context) {
+	id := c.Param("id")
+
+	user, err := model.GetUser(bson.ObjectIdHex(id))
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    user,
+	})
+}
+
+func GetUserList(c *gin.Context) {
+	// 绑定数据
+	data := UserListRequestData{}
+	if err := c.ShouldBindQuery(&data); err != nil {
+		HandleError(http.StatusBadRequest, c, err)
+		return
+	}
+	if data.PageNum == 0 {
+		data.PageNum = 1
+	}
+	if data.PageSize == 0 {
+		data.PageNum = 10
+	}
+
+	// 获取用户列表
+	users, err := model.GetUserList(nil, (data.PageNum-1)*data.PageSize, data.PageSize, "-create_ts")
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 获取总用户数
+	total, err := model.GetUserListTotal(nil)
+	if err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	// 去除密码
+	for i := range users {
+		users[i].Password = ""
+	}
+
+	c.JSON(http.StatusOK, ListResponse{
+		Status:  "ok",
+		Message: "success",
+		Data:    users,
+		Total:   total,
+	})
+}
+
+func PutUser(c *gin.Context) {
+	// 绑定请求数据
+	var reqData UserRequestData
+	if err := c.ShouldBindJSON(&reqData); err != nil {
+		HandleError(http.StatusBadRequest, c, err)
+		return
+	}
+
+	// 添加用户
+	user := model.User{
+		Username: strings.ToLower(reqData.Username),
+		Password: utils.EncryptPassword(reqData.Password),
+		Role:     constants.RoleNormal,
+	}
+	if err := user.Add(); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func PostUser(c *gin.Context) {
+	id := c.Param("id")
+
+	if !bson.IsObjectIdHex(id) {
+		HandleErrorF(http.StatusBadRequest, c, "invalid id")
+	}
+
+	var item model.User
+	if err := c.ShouldBindJSON(&item); err != nil {
+		HandleError(http.StatusBadRequest, c, err)
+		return
+	}
+
+	if err := model.UpdateUser(bson.ObjectIdHex(id), item); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func DeleteUser(c *gin.Context) {
+	id := c.Param("id")
+
+	if !bson.IsObjectIdHex(id) {
+		HandleErrorF(http.StatusBadRequest, c, "invalid id")
+		return
+	}
+
+	// 从数据库中删除该爬虫
+	if err := model.RemoveUser(bson.ObjectIdHex(id)); err != nil {
+		HandleError(http.StatusInternalServerError, c, err)
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+	})
+}
+
+func Login(c *gin.Context) {
+	// 绑定请求数据
+	var reqData UserRequestData
+	if err := c.ShouldBindJSON(&reqData); err != nil {
+		HandleError(http.StatusUnauthorized, c, errors.New("not authorized"))
+		return
+	}
+
+	// 获取用户
+	user, err := model.GetUserByUsername(strings.ToLower(reqData.Username))
+	if err != nil {
+		HandleError(http.StatusUnauthorized, c, errors.New("not authorized"))
+		return
+	}
+
+	// 校验密码
+	encPassword := utils.EncryptPassword(reqData.Password)
+	if user.Password != encPassword {
+		HandleError(http.StatusUnauthorized, c, errors.New("not authorized"))
+		return
+	}
+
+	// 获取token
+	tokenStr, err := services.GetToken(user.Username)
+	if err != nil {
+		HandleError(http.StatusUnauthorized, c, errors.New("not authorized"))
+		return
+	}
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    tokenStr,
+	})
+}
+
+func GetMe(c *gin.Context) {
+	// 获取token string
+	tokenStr := c.GetHeader("Authorization")
+
+	// 校验token
+	user, err := services.CheckToken(tokenStr)
+	if err != nil {
+		HandleError(http.StatusUnauthorized, c, errors.New("not authorized"))
+		return
+	}
+	user.Password = ""
+
+	c.JSON(http.StatusOK, Response{
+		Status:  "ok",
+		Message: "success",
+		Data:    user,
+	})
+}
--- a/backend/routes/utils.go
+++ b/backend/routes/utils.go
@@ -0,0 +1,24 @@
+package routes
+
+import (
+	"github.com/gin-gonic/gin"
+	"runtime/debug"
+)
+
+func HandleError(statusCode int, c *gin.Context, err error) {
+	debug.PrintStack()
+	c.JSON(statusCode, Response{
+		Status:  "ok",
+		Message: "error",
+		Error:   err.Error(),
+	})
+}
+
+func HandleErrorF(statusCode int, c *gin.Context, err string) {
+	debug.PrintStack()
+	c.JSON(statusCode, Response{
+		Status:  "ok",
+		Message: "error",
+		Error:   err,
+	})
+}
--- a/backend/services/log.go
+++ b/backend/services/log.go
@@ -0,0 +1,57 @@
+package services
+
+import (
+	"crawlab/constants"
+	"crawlab/database"
+	"crawlab/model"
+	"crawlab/utils"
+	"encoding/json"
+	"github.com/apex/log"
+	"io/ioutil"
+	"runtime/debug"
+)
+
+// 任务日志频道映射
+var TaskLogChanMap = utils.NewChanMap()
+
+// 获取本地日志
+func GetLocalLog(logPath string) (fileBytes []byte, err error) {
+	fileBytes, err = ioutil.ReadFile(logPath)
+	if err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return fileBytes, err
+	}
+	return fileBytes, nil
+}
+
+// 获取远端日志
+func GetRemoteLog(task model.Task) (logStr string, err error) {
+	// 序列化消息
+	msg := NodeMessage{
+		Type:    constants.MsgTypeGetLog,
+		LogPath: task.LogPath,
+		TaskId:  task.Id,
+	}
+	msgBytes, err := json.Marshal(&msg)
+	if err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return "", err
+	}
+
+	// 发布获取日志消息
+	channel := "nodes:" + task.NodeId.Hex()
+	if err := database.Publish(channel, string(msgBytes)); err != nil {
+		log.Errorf(err.Error())
+		return "", err
+	}
+
+	// 生成频道，等待获取log
+	ch := TaskLogChanMap.ChanBlocked(task.Id)
+
+	// 此处阻塞，等待结果
+	logStr = <-ch
+
+	return logStr, nil
+}
--- a/backend/services/node.go
+++ b/backend/services/node.go
@@ -0,0 +1,451 @@
+package services
+
+import (
+	"crawlab/constants"
+	"crawlab/database"
+	"crawlab/lib/cron"
+	"crawlab/model"
+	"encoding/json"
+	"fmt"
+	"github.com/apex/log"
+	"github.com/globalsign/mgo/bson"
+	"github.com/spf13/viper"
+	"net"
+	"runtime/debug"
+	"time"
+)
+
+type Data struct {
+	Mac          string    `json:"mac"`
+	Ip           string    `json:"ip"`
+	Master       bool      `json:"master"`
+	UpdateTs     time.Time `json:"update_ts"`
+	UpdateTsUnix int64     `json:"update_ts_unix"`
+}
+
+type NodeMessage struct {
+	// 通信类别
+	Type string `json:"type"`
+
+	// 任务相关
+	TaskId string `json:"task_id"` // 任务ID
+
+	// 节点相关
+	NodeId string `json:"node_id"` // 节点ID
+
+	// 日志相关
+	LogPath string `json:"log_path"` // 日志路径
+	Log     string `json:"log"`      // 日志
+
+	// 系统信息
+	SysInfo model.SystemInfo `json:"sys_info"`
+
+	// 错误相关
+	Error string `json:"error"`
+}
+
+const (
+	Yes = "Y"
+	No  = "N"
+)
+
+// 获取本机的IP地址
+// TODO: 考虑多个IP地址的情况
+func GetIp() (string, error) {
+	addrList, err := net.InterfaceAddrs()
+	if err != nil {
+		return "", err
+	}
+	for _, value := range addrList {
+		if ipNet, ok := value.(*net.IPNet); ok && !ipNet.IP.IsLoopback() {
+			if ipNet.IP.To4() != nil {
+				return ipNet.IP.String(), nil
+			}
+		}
+	}
+	return "", nil
+}
+
+// 获取本机的MAC地址
+func GetMac() (string, error) {
+	interfaces, err := net.Interfaces()
+	if err != nil {
+		debug.PrintStack()
+		return "", err
+	}
+	for _, inter := range interfaces {
+		if inter.HardwareAddr != nil {
+			mac := inter.HardwareAddr.String()
+			return mac, nil
+		}
+	}
+	return "", nil
+}
+
+// 获取本机节点
+func GetCurrentNode() (model.Node, error) {
+	// 获取本机MAC地址
+	mac, err := GetMac()
+	if err != nil {
+		debug.PrintStack()
+		return model.Node{}, err
+	}
+
+	// 从数据库中获取当前节点
+	var node model.Node
+	errNum := 0
+	for {
+		// 如果错误次数超过10次
+		if errNum >= 10 {
+			panic("cannot get current node")
+		}
+
+		// 尝试获取节点
+		node, err = model.GetNodeByMac(mac)
+
+		// 如果获取失败
+		if err != nil {
+			// 如果为主节点，表示为第一次注册，插入节点信息
+			if IsMaster() {
+				// 获取本机IP地址
+				ip, err := GetIp()
+				if err != nil {
+					debug.PrintStack()
+					return model.Node{}, err
+				}
+				// 生成节点
+				node = model.Node{
+					Id:       bson.NewObjectId(),
+					Ip:       ip,
+					Name:     mac,
+					Mac:      mac,
+					IsMaster: true,
+				}
+				if err := node.Add(); err != nil {
+					return node, err
+				}
+				return node, nil
+			}
+			// 增加错误次数
+			errNum++
+
+			// 5秒后重试
+			time.Sleep(5 * time.Second)
+			continue
+		}
+
+		// 跳出循环
+		break
+	}
+
+	return node, nil
+}
+
+// 当前节点是否为主节点
+func IsMaster() bool {
+	return viper.GetString("server.master") == Yes
+}
+
+// 该ID的节点是否为主节点
+func IsMasterNode(id string) bool {
+	curNode, _ := GetCurrentNode()
+	node, _ := model.GetNode(bson.ObjectIdHex(id))
+	return curNode.Id == node.Id
+}
+
+// 获取节点数据
+func GetNodeData() (Data, error) {
+	mac, err := GetMac()
+	if err != nil {
+		return Data{}, err
+	}
+
+	value, err := database.RedisClient.HGet("nodes", mac)
+	data := Data{}
+	if err := json.Unmarshal([]byte(value), &data); err != nil {
+		return data, err
+	}
+	return data, err
+}
+
+// 更新所有节点状态
+func UpdateNodeStatus() {
+	// 从Redis获取节点keys
+	list, err := database.RedisClient.HKeys("nodes")
+	if err != nil {
+		log.Errorf(err.Error())
+		return
+	}
+
+	// 遍历节点keys
+	for _, mac := range list {
+		// 获取节点数据
+		value, err := database.RedisClient.HGet("nodes", mac)
+		if err != nil {
+			log.Errorf(err.Error())
+			return
+		}
+
+		// 解析节点列表数据
+		var data Data
+		if err := json.Unmarshal([]byte(value), &data); err != nil {
+			log.Errorf(err.Error())
+			return
+		}
+
+		// 如果记录的更新时间超过60秒，该节点被认为离线
+		if time.Now().Unix()-data.UpdateTsUnix > 60 {
+			// 在Redis中删除该节点
+			if err := database.RedisClient.HDel("nodes", data.Mac); err != nil {
+				log.Errorf(err.Error())
+				return
+			}
+
+			// 在MongoDB中该节点设置状态为离线
+			s, c := database.GetCol("nodes")
+			defer s.Close()
+			var node model.Node
+			if err := c.Find(bson.M{"mac": mac}).One(&node); err != nil {
+				log.Errorf(err.Error())
+				debug.PrintStack()
+				return
+			}
+			node.Status = constants.StatusOffline
+			if err := node.Save(); err != nil {
+				log.Errorf(err.Error())
+				return
+			}
+			continue
+		}
+
+		// 更新节点信息到数据库
+		s, c := database.GetCol("nodes")
+		defer s.Close()
+		var node model.Node
+		if err := c.Find(bson.M{"mac": mac}).One(&node); err != nil {
+			// 数据库不存在该节点
+			node = model.Node{
+				Name:   data.Mac,
+				Ip:     data.Ip,
+				Port:   "8000",
+				Mac:    data.Mac,
+				Status: constants.StatusOnline,
+			}
+			if err := node.Add(); err != nil {
+				log.Errorf(err.Error())
+				return
+			}
+		} else {
+			// 数据库存在该节点
+			node.Status = constants.StatusOnline
+			if err := node.Save(); err != nil {
+				log.Errorf(err.Error())
+				return
+			}
+		}
+	}
+
+	// 遍历数据库中的节点列表
+	nodes, err := model.GetNodeList(nil)
+	for _, node := range nodes {
+		hasNode := false
+		for _, mac := range list {
+			if mac == node.Mac {
+				hasNode = true
+				break
+			}
+		}
+		if !hasNode {
+			node.Status = constants.StatusOffline
+			if err := node.Save(); err != nil {
+				log.Errorf(err.Error())
+				return
+			}
+			continue
+		}
+	}
+}
+
+// 更新节点数据
+func UpdateNodeData() {
+	// 获取MAC地址
+	mac, err := GetMac()
+	if err != nil {
+		log.Errorf(err.Error())
+		return
+	}
+
+	// 获取IP地址
+	ip, err := GetIp()
+	if err != nil {
+		log.Errorf(err.Error())
+		return
+	}
+
+	// 构造节点数据
+	data := Data{
+		Mac:          mac,
+		Ip:           ip,
+		Master:       IsMaster(),
+		UpdateTs:     time.Now(),
+		UpdateTsUnix: time.Now().Unix(),
+	}
+
+	// 注册节点到Redis
+	dataBytes, err := json.Marshal(&data)
+	if err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+	if err := database.RedisClient.HSet("nodes", mac, string(dataBytes)); err != nil {
+		log.Errorf(err.Error())
+		return
+	}
+}
+
+func MasterNodeCallback(channel string, msgStr string) {
+	// 反序列化
+	var msg NodeMessage
+	if err := json.Unmarshal([]byte(msgStr), &msg); err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+
+	if msg.Type == constants.MsgTypeGetLog {
+		// 获取日志
+		fmt.Println(msg)
+		time.Sleep(10 * time.Millisecond)
+		ch := TaskLogChanMap.ChanBlocked(msg.TaskId)
+		ch <- msg.Log
+	} else if msg.Type == constants.MsgTypeGetSystemInfo {
+		// 获取系统信息
+		fmt.Println(msg)
+		time.Sleep(10 * time.Millisecond)
+		ch := SystemInfoChanMap.ChanBlocked(msg.NodeId)
+		sysInfoBytes, _ := json.Marshal(&msg.SysInfo)
+		ch <- string(sysInfoBytes)
+	}
+}
+
+func WorkerNodeCallback(channel string, msgStr string) {
+	// 反序列化
+	msg := NodeMessage{}
+	fmt.Println(msgStr)
+	if err := json.Unmarshal([]byte(msgStr), &msg); err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+
+	if msg.Type == constants.MsgTypeGetLog {
+		// 消息类型为获取日志
+
+		// 发出的消息
+		msgSd := NodeMessage{
+			Type:   constants.MsgTypeGetLog,
+			TaskId: msg.TaskId,
+		}
+
+		// 获取本地日志
+		logStr, err := GetLocalLog(msg.LogPath)
+		if err != nil {
+			log.Errorf(err.Error())
+			debug.PrintStack()
+			msgSd.Error = err.Error()
+		}
+		msgSd.Log = string(logStr)
+
+		// 序列化
+		msgSdBytes, err := json.Marshal(&msgSd)
+		if err != nil {
+			log.Errorf(err.Error())
+			debug.PrintStack()
+			return
+		}
+
+		// 发布消息给主节点
+		fmt.Println(msgSd)
+		if err := database.Publish("nodes:master", string(msgSdBytes)); err != nil {
+			log.Errorf(err.Error())
+			return
+		}
+	} else if msg.Type == constants.MsgTypeCancelTask {
+		// 取消任务
+		ch := TaskExecChanMap.ChanBlocked(msg.TaskId)
+		ch <- constants.TaskCancel
+	} else if msg.Type == constants.MsgTypeGetSystemInfo {
+		// 获取环境信息
+		sysInfo, err := GetLocalSystemInfo()
+		if err != nil {
+			log.Errorf(err.Error())
+			return
+		}
+		msgSd := NodeMessage{
+			Type:    constants.MsgTypeGetSystemInfo,
+			NodeId:  msg.NodeId,
+			SysInfo: sysInfo,
+		}
+		msgSdBytes, err := json.Marshal(&msgSd)
+		if err != nil {
+			log.Errorf(err.Error())
+			debug.PrintStack()
+			return
+		}
+		fmt.Println(msgSd)
+		if err := database.Publish("nodes:master", string(msgSdBytes)); err != nil {
+			log.Errorf(err.Error())
+			return
+		}
+	}
+}
+
+// 初始化节点服务
+func InitNodeService() error {
+	// 构造定时任务
+	c := cron.New(cron.WithSeconds())
+
+	// 每5秒更新一次本节点信息
+	spec := "0/5 * * * * *"
+	if _, err := c.AddFunc(spec, UpdateNodeData); err != nil {
+		debug.PrintStack()
+		return err
+	}
+
+	// 首次更新节点数据（注册到Redis）
+	UpdateNodeData()
+
+	// 消息订阅
+	var sub database.Subscriber
+	sub.Connect()
+
+	// 获取当前节点
+	node, err := GetCurrentNode()
+	if err != nil {
+		log.Errorf(err.Error())
+		return err
+	}
+
+	if IsMaster() {
+		// 如果为主节点，订阅主节点通信频道
+		channel := "nodes:master"
+		sub.Subscribe(channel, MasterNodeCallback)
+	} else {
+		// 若为工作节点，订阅单独指定通信频道
+		channel := "nodes:" + node.Id.Hex()
+		sub.Subscribe(channel, WorkerNodeCallback)
+	}
+
+	// 如果为主节点，每30秒刷新所有节点信息
+	if IsMaster() {
+		spec := "*/10 * * * * *"
+		if _, err := c.AddFunc(spec, UpdateNodeStatus); err != nil {
+			debug.PrintStack()
+			return err
+		}
+	}
+
+	c.Start()
+	return nil
+}
--- a/backend/services/schedule.go
+++ b/backend/services/schedule.go
@@ -0,0 +1,133 @@
+package services
+
+import (
+	"crawlab/constants"
+	"crawlab/lib/cron"
+	"crawlab/model"
+	"github.com/apex/log"
+	uuid "github.com/satori/go.uuid"
+	"runtime/debug"
+)
+
+var Sched *Scheduler
+
+type Scheduler struct {
+	cron *cron.Cron
+}
+
+func AddTask(s model.Schedule) func() {
+	return func() {
+		nodeId := s.NodeId
+
+		// 生成任务ID
+		id := uuid.NewV4()
+
+		// 生成任务模型
+		t := model.Task{
+			Id:       id.String(),
+			SpiderId: s.SpiderId,
+			NodeId:   nodeId,
+			Status:   constants.StatusPending,
+		}
+
+		// 将任务存入数据库
+		if err := model.AddTask(t); err != nil {
+			log.Errorf(err.Error())
+			debug.PrintStack()
+			return
+		}
+
+		// 加入任务队列
+		if err := AssignTask(t); err != nil {
+			log.Errorf(err.Error())
+			debug.PrintStack()
+			return
+		}
+	}
+}
+
+func UpdateSchedules() {
+	if err := Sched.Update(); err != nil {
+		log.Errorf(err.Error())
+		return
+	}
+}
+
+func (s *Scheduler) Start() error {
+	exec := cron.New(cron.WithSeconds())
+
+	// 启动cron服务
+	s.cron.Start()
+
+	// 更新任务列表
+	if err := s.Update(); err != nil {
+		return err
+	}
+
+	// 每30秒更新一次任务列表
+	spec := "*/30 * * * * *"
+	if _, err := exec.AddFunc(spec, UpdateSchedules); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Scheduler) AddJob(job model.Schedule) error {
+	spec := job.Cron
+
+	// 添加任务
+	eid, err := s.cron.AddFunc(spec, AddTask(job))
+	if err != nil {
+		return err
+	}
+
+	// 更新EntryID
+	job.EntryId = eid
+	if err := job.Save(); err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (s *Scheduler) RemoveAll() {
+	entries := s.cron.Entries()
+	for i := 0; i < len(entries); i++ {
+		s.cron.Remove(entries[i].ID)
+	}
+}
+
+func (s *Scheduler) Update() error {
+	// 删除所有定时任务
+	s.RemoveAll()
+
+	// 获取所有定时任务
+	sList, err := model.GetScheduleList(nil)
+	if err != nil {
+		return err
+	}
+
+	// 遍历任务列表
+	for i := 0; i < len(sList); i++ {
+		// 单个任务
+		job := sList[i]
+
+		// 添加到定时任务
+		if err := s.AddJob(job); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func InitScheduler() error {
+	Sched = &Scheduler{
+		cron: cron.New(cron.WithSeconds()),
+	}
+	if err := Sched.Start(); err != nil {
+		return err
+	}
+	return nil
+}
--- a/backend/services/spider.go
+++ b/backend/services/spider.go
@@ -0,0 +1,387 @@
+package services
+
+import (
+	"crawlab/constants"
+	"crawlab/database"
+	"crawlab/lib/cron"
+	"crawlab/model"
+	"crawlab/utils"
+	"encoding/json"
+	"github.com/apex/log"
+	"github.com/globalsign/mgo/bson"
+	"github.com/pkg/errors"
+	uuid "github.com/satori/go.uuid"
+	"github.com/spf13/viper"
+	"io"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"runtime/debug"
+	"strings"
+)
+
+type SpiderFileData struct {
+	FileName string
+	File     []byte
+}
+
+type SpiderUploadMessage struct {
+	FileId   string
+	FileName string
+}
+
+// 从项目目录中获取爬虫列表
+func GetSpidersFromDir() ([]model.Spider, error) {
+	// 爬虫项目目录路径
+	srcPath := viper.GetString("spider.path")
+
+	// 如果爬虫项目目录不存在，则创建一个
+	if !utils.Exists(srcPath) {
+		if err := os.MkdirAll(srcPath, 0666); err != nil {
+			debug.PrintStack()
+			return []model.Spider{}, err
+		}
+	}
+
+	// 获取爬虫项目目录下的所有子项
+	items, err := ioutil.ReadDir(srcPath)
+	if err != nil {
+		debug.PrintStack()
+		return []model.Spider{}, err
+	}
+
+	// 定义爬虫列表
+	spiders := make([]model.Spider, 0)
+
+	// 遍历所有子项
+	for _, item := range items {
+		// 忽略不为目录的子项
+		if !item.IsDir() {
+			continue
+		}
+
+		// 忽略隐藏目录
+		if strings.HasPrefix(item.Name(), ".") {
+			continue
+		}
+
+		// 构造爬虫
+		spider := model.Spider{
+			Name:        item.Name(),
+			DisplayName: item.Name(),
+			Type:        constants.Customized,
+			Src:         filepath.Join(srcPath, item.Name()),
+			FileId:      bson.ObjectIdHex(constants.ObjectIdNull),
+		}
+
+		// 将爬虫加入列表
+		spiders = append(spiders, spider)
+	}
+
+	return spiders, nil
+}
+
+// 将爬虫保存到数据库
+func SaveSpiders(spiders []model.Spider) error {
+	// 遍历爬虫列表
+	for _, spider := range spiders {
+		// 忽略非自定义爬虫
+		if spider.Type != constants.Customized {
+			continue
+		}
+
+		// 如果该爬虫不存在于数据库，则保存爬虫到数据库
+		s, c := database.GetCol("spiders")
+		defer s.Close()
+		var spider_ *model.Spider
+		if err := c.Find(bson.M{"src": spider.Src}).One(&spider_); err != nil {
+			// 不存在
+			if err := spider.Add(); err != nil {
+				debug.PrintStack()
+				return err
+			}
+		} else {
+			// 存在
+		}
+	}
+
+	return nil
+}
+
+// 更新爬虫
+func UpdateSpiders() {
+	// 从项目目录获取爬虫列表
+	spiders, err := GetSpidersFromDir()
+	if err != nil {
+		log.Errorf(err.Error())
+		return
+	}
+
+	// 储存爬虫
+	if err := SaveSpiders(spiders); err != nil {
+		log.Errorf(err.Error())
+		return
+	}
+}
+
+// 打包爬虫目录为zip文件
+func ZipSpider(spider model.Spider) (filePath string, err error) {
+	// 如果源文件夹不存在，抛错
+	if !utils.Exists(spider.Src) {
+		debug.PrintStack()
+		return "", errors.New("source path does not exist")
+	}
+
+	// 临时文件路径
+	randomId := uuid.NewV4()
+	if err != nil {
+		debug.PrintStack()
+		return "", err
+	}
+	filePath = filepath.Join(
+		viper.GetString("other.tmppath"),
+		randomId.String()+".zip",
+	)
+
+	// 将源文件夹打包为zip文件
+	d, err := os.Open(spider.Src)
+	if err != nil {
+		debug.PrintStack()
+		return filePath, err
+	}
+	var files []*os.File
+	files = append(files, d)
+	if err := utils.Compress(files, filePath); err != nil {
+		return filePath, err
+	}
+
+	return filePath, nil
+}
+
+// 上传zip文件到GridFS
+func UploadToGridFs(spider model.Spider, fileName string, filePath string) (fid bson.ObjectId, err error) {
+	fid = ""
+
+	// 读取zip文件
+	file, err := os.OpenFile(filePath, os.O_RDONLY, 0777)
+	fileBytes, err := ioutil.ReadAll(file)
+	if err != nil {
+		debug.PrintStack()
+		return
+	}
+	if err = file.Close(); err != nil {
+		debug.PrintStack()
+		return
+	}
+
+	// 删除zip文件
+	if err = os.Remove(filePath); err != nil {
+		debug.PrintStack()
+		return
+	}
+
+	// 获取MongoDB GridFS连接
+	s, gf := database.GetGridFs("files")
+	defer s.Close()
+
+	// 如果存在FileId删除GridFS上的老文件
+	if !utils.IsObjectIdNull(spider.FileId) {
+		if err = gf.RemoveId(spider.FileId); err != nil {
+			debug.PrintStack()
+		}
+	}
+
+	// 创建一个新GridFS文件
+	f, err := gf.Create(fileName)
+	if err != nil {
+		debug.PrintStack()
+		return
+	}
+
+	// 将文件写入到GridFS
+	if _, err = f.Write(fileBytes); err != nil {
+		debug.PrintStack()
+		return
+	}
+
+	// 关闭文件，提交写入
+	if err = f.Close(); err != nil {
+		return "", err
+	}
+
+	// 文件ID
+	fid = f.Id().(bson.ObjectId)
+
+	return fid, nil
+}
+
+// 发布所有爬虫
+func PublishAllSpiders() error {
+	// 获取爬虫列表
+	spiders, err := model.GetSpiderList(nil, 0, constants.Infinite)
+	if err != nil {
+		log.Errorf(err.Error())
+		return err
+	}
+
+	// 遍历爬虫列表
+	for _, spider := range spiders {
+		// 发布爬虫
+		if err := PublishSpider(spider); err != nil {
+			log.Errorf(err.Error())
+			return err
+		}
+	}
+
+	return nil
+}
+
+func PublishAllSpidersJob() {
+	if err := PublishAllSpiders(); err != nil {
+		log.Errorf(err.Error())
+	}
+}
+
+// 发布爬虫
+// 1. 将源文件夹打包为zip文件
+// 2. 上传zip文件到GridFS
+// 3. 发布消息给工作节点
+func PublishSpider(spider model.Spider) (err error) {
+	// 将源文件夹打包为zip文件
+	filePath, err := ZipSpider(spider)
+	if err != nil {
+		return err
+	}
+
+	// 上传zip文件到GridFS
+	fileName := filepath.Base(spider.Src) + ".zip"
+	fid, err := UploadToGridFs(spider, fileName, filePath)
+	if err != nil {
+		return err
+	}
+
+	// 保存FileId
+	spider.FileId = fid
+	if err := spider.Save(); err != nil {
+		return err
+	}
+
+	// 发布消息给工作节点
+	msg := SpiderUploadMessage{
+		FileId:   fid.Hex(),
+		FileName: fileName,
+	}
+	msgStr, err := json.Marshal(msg)
+	if err != nil {
+		return
+	}
+	channel := "files:upload"
+	if err = database.Publish(channel, string(msgStr)); err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+
+	return
+}
+
+// 上传爬虫回调
+func OnFileUpload(channel string, msgStr string) {
+	s, gf := database.GetGridFs("files")
+	defer s.Close()
+
+	// 反序列化消息
+	var msg SpiderUploadMessage
+	if err := json.Unmarshal([]byte(msgStr), &msg); err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+
+	// 从GridFS获取该文件
+	f, err := gf.OpenId(bson.ObjectIdHex(msg.FileId))
+	if err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+	defer f.Close()
+
+	// 生成唯一ID
+	randomId := uuid.NewV4()
+
+	// 创建临时文件
+	tmpFilePath := filepath.Join(viper.GetString("other.tmppath"), randomId.String()+".zip")
+	tmpFile, err := os.OpenFile(tmpFilePath, os.O_CREATE|os.O_WRONLY, os.ModePerm)
+	if err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+	defer tmpFile.Close()
+
+	// 将该文件写入临时文件
+	if _, err := io.Copy(tmpFile, f); err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+
+	// 解压缩临时文件到目标文件夹
+	dstPath := filepath.Join(
+		viper.GetString("spider.path"),
+		//strings.Replace(msg.FileName, ".zip", "", -1),
+	)
+	if err := utils.DeCompress(tmpFile, dstPath); err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+
+	// 关闭临时文件
+	if err := tmpFile.Close(); err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+
+	// 删除临时文件
+	if err := os.Remove(tmpFilePath); err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+}
+
+// 启动爬虫服务
+func InitSpiderService() error {
+	// 构造定时任务执行器
+	c := cron.New(cron.WithSeconds())
+
+	if IsMaster() {
+		// 主节点
+
+		// 每5秒更新一次爬虫信息
+		if _, err := c.AddFunc("*/5 * * * * *", UpdateSpiders); err != nil {
+			return err
+		}
+
+		// 每60秒同步爬虫给工作节点
+		if _, err := c.AddFunc("0 * * * * *", PublishAllSpidersJob); err != nil {
+			return err
+		}
+	} else {
+		// 非主节点
+
+		// 订阅文件上传
+		channel := "files:upload"
+		var sub database.Subscriber
+		sub.Connect()
+		sub.Subscribe(channel, OnFileUpload)
+	}
+
+	// 启动定时任务
+	c.Start()
+
+	return nil
+}
--- a/backend/services/system.go
+++ b/backend/services/system.go
@@ -0,0 +1,140 @@
+package services
+
+import (
+	"crawlab/constants"
+	"crawlab/database"
+	"crawlab/model"
+	"crawlab/utils"
+	"encoding/json"
+	"github.com/apex/log"
+	"io/ioutil"
+	"os"
+	"path/filepath"
+	"runtime"
+	"runtime/debug"
+	"strings"
+)
+
+var SystemInfoChanMap = utils.NewChanMap()
+
+var executableNameMap = map[string]string{
+	// python
+	"python":    "Python",
+	"python2":   "Python 2",
+	"python2.7": "Python 2.7",
+	"python3":   "Python 3",
+	"python3.5": "Python 3.5",
+	"python3.6": "Python 3.6",
+	"python3.7": "Python 3.7",
+	"python3.8": "Python 3.8",
+	// java
+	"java": "Java",
+	// go
+	"go": "Go",
+	// node
+	"node": "NodeJS",
+	// php
+	"php": "PHP",
+	// windows command
+	"cmd": "Windows Command Prompt",
+	// linux shell
+	"sh":   "Shell",
+	"bash": "bash",
+}
+
+func GetSystemEnv(key string) string {
+	return os.Getenv(key)
+}
+
+func GetPathValues() (paths []string) {
+	pathEnv := GetSystemEnv("PATH")
+	return strings.Split(pathEnv, ":")
+}
+
+func GetExecutables() (executables []model.Executable, err error) {
+	pathValues := GetPathValues()
+
+	cache := map[string]string{}
+
+	for _, path := range pathValues {
+		fileList, err := ioutil.ReadDir(path)
+		if err != nil {
+			log.Errorf(err.Error())
+			debug.PrintStack()
+			continue
+		}
+
+		for _, file := range fileList {
+			displayName := executableNameMap[file.Name()]
+			filePath := filepath.Join(path, file.Name())
+
+			if cache[filePath] == "" {
+				if displayName != "" {
+					executables = append(executables, model.Executable{
+						Path:        filePath,
+						FileName:    file.Name(),
+						DisplayName: displayName,
+					})
+				}
+				cache[filePath] = filePath
+			}
+		}
+	}
+	return executables, nil
+}
+
+func GetLocalSystemInfo() (sysInfo model.SystemInfo, err error) {
+	executables, err := GetExecutables()
+	if err != nil {
+		return sysInfo, err
+	}
+	hostname, err := os.Hostname()
+	if err != nil {
+		debug.PrintStack()
+		return sysInfo, err
+	}
+
+	return model.SystemInfo{
+		ARCH:        runtime.GOARCH,
+		OS:          runtime.GOOS,
+		NumCpu:      runtime.GOMAXPROCS(0),
+		Hostname:    hostname,
+		Executables: executables,
+	}, nil
+}
+
+func GetRemoteSystemInfo(id string) (sysInfo model.SystemInfo, err error) {
+	// 发送消息
+	msg := NodeMessage{
+		Type:   constants.MsgTypeGetSystemInfo,
+		NodeId: id,
+	}
+
+	// 序列化
+	msgBytes, _ := json.Marshal(&msg)
+	if err := database.Publish("nodes:"+id, string(msgBytes)); err != nil {
+		return model.SystemInfo{}, err
+	}
+
+	// 通道
+	ch := SystemInfoChanMap.ChanBlocked(id)
+
+	// 等待响应，阻塞
+	sysInfoStr := <-ch
+
+	// 反序列化
+	if err := json.Unmarshal([]byte(sysInfoStr), &sysInfo); err != nil {
+		return sysInfo, err
+	}
+
+	return sysInfo, nil
+}
+
+func GetSystemInfo(id string) (sysInfo model.SystemInfo, err error) {
+	if IsMasterNode(id) {
+		sysInfo, err = GetLocalSystemInfo()
+	} else {
+		sysInfo, err = GetRemoteSystemInfo(id)
+	}
+	return
+}
--- a/backend/services/task.go
+++ b/backend/services/task.go
@@ -0,0 +1,491 @@
+package services
+
+import (
+	"crawlab/constants"
+	"crawlab/database"
+	"crawlab/lib/cron"
+	"crawlab/model"
+	"crawlab/utils"
+	"encoding/json"
+	"errors"
+	"github.com/apex/log"
+	"github.com/spf13/viper"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"runtime"
+	"runtime/debug"
+	"strconv"
+	"time"
+)
+
+var Exec *Executor
+
+// 任务执行锁
+var LockList []bool
+
+// 任务消息
+type TaskMessage struct {
+	Id  string
+	Cmd string
+}
+
+// 序列化任务消息
+func (m *TaskMessage) ToString() (string, error) {
+	data, err := json.Marshal(&m)
+	if err != nil {
+		return "", err
+	}
+	return string(data), err
+}
+
+// 任务执行器
+type Executor struct {
+	Cron *cron.Cron
+}
+
+// 启动任务执行器
+func (ex *Executor) Start() error {
+	// 启动cron服务
+	ex.Cron.Start()
+
+	// 加入执行器到定时任务
+	spec := "0/1 * * * * *" // 每秒执行一次
+	for i := 0; i < viper.GetInt("task.workers"); i++ {
+		// WorkerID
+		id := i
+
+		// 初始化任务锁
+		LockList = append(LockList, false)
+
+		// 加入定时任务
+		_, err := ex.Cron.AddFunc(spec, GetExecuteTaskFunc(id))
+		if err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+var TaskExecChanMap = utils.NewChanMap()
+
+// 派发任务
+func AssignTask(task model.Task) error {
+	// 生成任务信息
+	msg := TaskMessage{
+		Id: task.Id,
+	}
+
+	// 序列化
+	msgStr, err := msg.ToString()
+	if err != nil {
+		return err
+	}
+
+	// 队列名称
+	var queue string
+	if utils.IsObjectIdNull(task.NodeId) {
+		queue = "tasks:public"
+	} else {
+		queue = "tasks:node:" + task.NodeId.Hex()
+	}
+
+	// 任务入队
+	if err := database.RedisClient.RPush(queue, msgStr); err != nil {
+		return err
+	}
+	return nil
+}
+
+// 执行shell命令
+func ExecuteShellCmd(cmdStr string, cwd string, t model.Task, s model.Spider) (err error) {
+	log.Infof("cwd: " + cwd)
+	log.Infof("cmd: " + cmdStr)
+
+	// 生成执行命令
+	var cmd *exec.Cmd
+	if runtime.GOOS == constants.Windows {
+		cmd = exec.Command("cmd", "/C", cmdStr)
+	} else {
+		cmd = exec.Command("sh", "-c", cmdStr)
+	}
+
+	// 工作目录
+	cmd.Dir = cwd
+
+	// 指定stdout, stderr日志位置
+	fLog, err := os.Create(t.LogPath)
+	if err != nil {
+		HandleTaskError(t, err)
+		return err
+	}
+	defer fLog.Close()
+	cmd.Stdout = fLog
+	cmd.Stderr = fLog
+
+	// 添加默认环境变量
+	cmd.Env = append(cmd.Env, "CRAWLAB_TASK_ID="+t.Id)
+	cmd.Env = append(cmd.Env, "CRAWLAB_COLLECTION="+s.Col)
+
+	// 添加任务环境变量
+	for _, env := range s.Envs {
+		cmd.Env = append(cmd.Env, env.Name + "=" + env.Value)
+	}
+
+	// 起一个goroutine来监控进程
+	ch := TaskExecChanMap.ChanBlocked(t.Id)
+	go func() {
+		// 传入信号，此处阻塞
+		signal := <-ch
+
+		if signal == constants.TaskCancel {
+			// 取消进程
+			if err := cmd.Process.Kill(); err != nil {
+				log.Errorf(err.Error())
+				debug.PrintStack()
+				return
+			}
+			t.Status = constants.StatusCancelled
+		}
+
+		// 保存任务
+		t.FinishTs = time.Now()
+		if err := t.Save(); err != nil {
+			log.Infof(err.Error())
+			debug.PrintStack()
+			return
+		}
+	}()
+
+	// 开始执行
+	if err := cmd.Run(); err != nil {
+		HandleTaskError(t, err)
+		return err
+	}
+	ch <- constants.TaskFinish
+
+	return nil
+}
+
+// 生成日志目录
+func MakeLogDir(t model.Task) (fileDir string, err error) {
+	// 日志目录
+	fileDir = filepath.Join(viper.GetString("log.path"), t.SpiderId.Hex())
+
+	// 如果日志目录不存在，生成该目录
+	if !utils.Exists(fileDir) {
+		if err := os.MkdirAll(fileDir, 0777); err != nil {
+			debug.PrintStack()
+			return "", err
+		}
+	}
+
+	return fileDir, nil
+}
+
+// 获取日志文件路径
+func GetLogFilePaths(fileDir string) (filePath string) {
+	// 时间戳
+	ts := time.Now()
+	tsStr := ts.Format("20060102150405")
+
+	// stdout日志文件
+	filePath = filepath.Join(fileDir, tsStr+".log")
+
+	return filePath
+}
+
+// 生成执行任务方法
+func GetExecuteTaskFunc(id int) func() {
+	return func() {
+		ExecuteTask(id)
+	}
+}
+
+func GetWorkerPrefix(id int) string {
+	return "[Worker " + strconv.Itoa(id) + "] "
+}
+
+// 统计任务结果数
+func SaveTaskResultCount(id string) func() {
+	return func() {
+		if err := model.UpdateTaskResultCount(id); err != nil {
+			log.Errorf(err.Error())
+			debug.PrintStack()
+			return
+		}
+	}
+}
+
+// 执行任务
+func ExecuteTask(id int) {
+	if LockList[id] {
+		log.Debugf(GetWorkerPrefix(id) + "正在执行任务...")
+		return
+	}
+
+	// 上锁
+	LockList[id] = true
+
+	// 解锁（延迟执行）
+	defer func() {
+		LockList[id] = false
+	}()
+
+	// 开始计时
+	tic := time.Now()
+
+	// 获取当前节点
+	node, err := GetCurrentNode()
+	if err != nil {
+		log.Errorf(GetWorkerPrefix(id) + err.Error())
+		return
+	}
+
+	// 公共队列
+	queuePub := "tasks:public"
+
+	// 节点队列
+	queueCur := "tasks:node:" + node.Id.Hex()
+
+	// 节点队列任务
+	var msg string
+	msg, err = database.RedisClient.LPop(queueCur)
+	if err != nil {
+		if msg == "" {
+			// 节点队列没有任务，获取公共队列任务
+			msg, err = database.RedisClient.LPop(queuePub)
+			if err != nil {
+				if msg == "" {
+					// 公共队列没有任务
+					log.Debugf(GetWorkerPrefix(id) + "没有任务...")
+					return
+				} else {
+					log.Errorf(GetWorkerPrefix(id) + err.Error())
+					debug.PrintStack()
+					return
+				}
+			}
+		} else {
+			log.Errorf(GetWorkerPrefix(id) + err.Error())
+			debug.PrintStack()
+			return
+		}
+	}
+
+	// 反序列化
+	tMsg := TaskMessage{}
+	if err := json.Unmarshal([]byte(msg), &tMsg); err != nil {
+		log.Errorf(GetWorkerPrefix(id) + err.Error())
+		debug.PrintStack()
+		return
+	}
+
+	// 获取任务
+	t, err := model.GetTask(tMsg.Id)
+	if err != nil {
+		log.Errorf(GetWorkerPrefix(id) + err.Error())
+		return
+	}
+
+	// 获取爬虫
+	spider, err := t.GetSpider()
+	if err != nil {
+		log.Errorf(GetWorkerPrefix(id) + err.Error())
+		return
+	}
+
+	// 创建日志目录
+	fileDir, err := MakeLogDir(t)
+	if err != nil {
+		log.Errorf(GetWorkerPrefix(id) + err.Error())
+		return
+	}
+
+	// 获取日志文件路径
+	t.LogPath = GetLogFilePaths(fileDir)
+
+	// 创建日志目录文件夹
+	fileStdoutDir := filepath.Dir(t.LogPath)
+	if !utils.Exists(fileStdoutDir) {
+		if err := os.MkdirAll(fileStdoutDir, os.ModePerm); err != nil {
+			log.Errorf(GetWorkerPrefix(id) + err.Error())
+			return
+		}
+	}
+
+	// 工作目录
+	cwd := filepath.Join(
+		viper.GetString("spider.path"),
+		spider.Name,
+	)
+
+	// 执行命令
+	cmd := spider.Cmd
+	if t.Cmd != "" {
+		cmd = t.Cmd
+	}
+
+	// 任务赋值
+	t.NodeId = node.Id                                   // 任务节点信息
+	t.StartTs = time.Now()                               // 任务开始时间
+	t.Status = constants.StatusRunning                   // 任务状态
+	t.WaitDuration = t.StartTs.Sub(t.CreateTs).Seconds() // 等待时长
+
+	// 开始执行任务
+	log.Infof(GetWorkerPrefix(id) + "开始执行任务(ID:" + t.Id + ")")
+
+	// 储存任务
+	if err := t.Save(); err != nil {
+		log.Errorf(err.Error())
+		HandleTaskError(t, err)
+		return
+	}
+
+	// 起一个cron执行器来统计任务结果数
+	cronExec := cron.New(cron.WithSeconds())
+	_, err = cronExec.AddFunc("*/5 * * * * *", SaveTaskResultCount(t.Id))
+	if err != nil {
+		log.Errorf(GetWorkerPrefix(id) + err.Error())
+		return
+	}
+	cronExec.Start()
+	defer cronExec.Stop()
+
+	// 执行Shell命令
+	if err := ExecuteShellCmd(cmd, cwd, t, spider); err != nil {
+		log.Errorf(GetWorkerPrefix(id) + err.Error())
+		return
+	}
+
+	// 更新任务结果数
+	if err := model.UpdateTaskResultCount(t.Id); err != nil {
+		log.Errorf(GetWorkerPrefix(id) + err.Error())
+		return
+	}
+
+	// 完成进程
+	t, err = model.GetTask(t.Id)
+	if err != nil {
+		log.Errorf(GetWorkerPrefix(id) + err.Error())
+		return
+	}
+	t.Status = constants.StatusFinished                     // 任务状态: 已完成
+	t.FinishTs = time.Now()                                 // 结束时间
+	t.RuntimeDuration = t.FinishTs.Sub(t.StartTs).Seconds() // 运行时长
+	t.TotalDuration = t.FinishTs.Sub(t.CreateTs).Seconds()  // 总时长
+
+	// 保存任务
+	if err := t.Save(); err != nil {
+		log.Errorf(GetWorkerPrefix(id) + err.Error())
+		return
+	}
+
+	// 结束计时
+	toc := time.Now()
+
+	// 统计时长
+	duration := toc.Sub(tic).Seconds()
+	durationStr := strconv.FormatFloat(duration, 'f', 6, 64)
+	log.Infof(GetWorkerPrefix(id) + "任务(ID:" + t.Id + ")" + "执行完毕. 消耗时间:" + durationStr + "秒")
+}
+
+func GetTaskLog(id string) (logStr string, err error) {
+	task, err := model.GetTask(id)
+	if err != nil {
+		return "", err
+	}
+
+	logStr = ""
+	if IsMasterNode(task.NodeId.Hex()) {
+		// 若为主节点，获取本机日志
+		logBytes, err := GetLocalLog(task.LogPath)
+		logStr = string(logBytes)
+		if err != nil {
+			log.Errorf(err.Error())
+			return "", err
+		}
+		logStr = string(logBytes)
+	} else {
+		// 若不为主节点，获取远端日志
+		logStr, err = GetRemoteLog(task)
+		if err != nil {
+			log.Errorf(err.Error())
+			return "", err
+		}
+	}
+
+	return logStr, nil
+}
+
+func CancelTask(id string) (err error) {
+	// 获取任务
+	task, err := model.GetTask(id)
+	if err != nil {
+		return err
+	}
+
+	// 如果任务状态不为pending或running，返回错误
+	if task.Status != constants.StatusPending && task.Status != constants.StatusRunning {
+		return errors.New("task is not cancellable")
+	}
+
+	// 获取当前节点（默认当前节点为主节点）
+	node, err := GetCurrentNode()
+	if err != nil {
+		return err
+	}
+
+	if node.Id == task.NodeId {
+		// 任务节点为主节点
+
+		// 获取任务执行频道
+		ch := TaskExecChanMap.ChanBlocked(id)
+
+		// 发出取消进程信号
+		ch <- constants.TaskCancel
+	} else {
+		// 任务节点为工作节点
+
+		// 序列化消息
+		msg := NodeMessage{
+			Type:   constants.MsgTypeCancelTask,
+			TaskId: id,
+		}
+		msgBytes, err := json.Marshal(&msg)
+		if err != nil {
+			return err
+		}
+
+		// 发布消息
+		if err := database.Publish("nodes:"+task.NodeId.Hex(), string(msgBytes)); err != nil {
+			return err
+		}
+	}
+
+	return nil
+}
+
+func HandleTaskError(t model.Task, err error) {
+	t.Status = constants.StatusError
+	t.Error = err.Error()
+	t.FinishTs = time.Now()
+	if err := t.Save(); err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+	debug.PrintStack()
+}
+
+func InitTaskExecutor() error {
+	c := cron.New(cron.WithSeconds())
+	Exec = &Executor{
+		Cron: c,
+	}
+	if err := Exec.Start(); err != nil {
+		return err
+	}
+	return nil
+}
--- a/backend/services/user.go
+++ b/backend/services/user.go
@@ -0,0 +1,87 @@
+package services
+
+import (
+	"crawlab/constants"
+	"crawlab/model"
+	"crawlab/utils"
+	"errors"
+	"github.com/apex/log"
+	"github.com/dgrijalva/jwt-go"
+	"github.com/globalsign/mgo/bson"
+	"github.com/spf13/viper"
+	"runtime/debug"
+	"time"
+)
+
+func InitUserService() error {
+	adminUser := model.User{
+		Username: "admin",
+		Password: utils.EncryptPassword("admin"),
+		Role:     constants.RoleAdmin,
+	}
+	if err := adminUser.Add(); err != nil {
+		// pass
+	}
+	return nil
+}
+
+func GetToken(username string) (tokenStr string, err error) {
+	user, err := model.GetUserByUsername(username)
+	if err != nil {
+		log.Errorf(err.Error())
+		debug.PrintStack()
+		return
+	}
+
+	token := jwt.NewWithClaims(jwt.SigningMethodHS256, jwt.MapClaims{
+		"id":       user.Id,
+		"username": user.Username,
+		"nbf":      time.Now().Unix(),
+	})
+
+	tokenStr, err = token.SignedString([]byte(viper.GetString("server.secret")))
+	if err != nil {
+		return
+	}
+	return
+}
+
+func SecretFunc() jwt.Keyfunc {
+	return func(token *jwt.Token) (interface{}, error) {
+		return []byte(viper.GetString("server.secret")), nil
+	}
+}
+
+func CheckToken(tokenStr string) (user model.User, err error) {
+	token, err := jwt.Parse(tokenStr, SecretFunc())
+	if err != nil {
+		return
+	}
+
+	claim, ok := token.Claims.(jwt.MapClaims)
+	if !ok {
+		err = errors.New("cannot convert claim to mapclaim")
+		return
+	}
+
+	//验证token，如果token被修改过则为false
+	if !token.Valid {
+		err = errors.New("token is invalid")
+		return
+	}
+
+	id := bson.ObjectIdHex(claim["id"].(string))
+	username := claim["username"].(string)
+	user, err = model.GetUser(id)
+	if err != nil {
+		err = errors.New("cannot get user")
+		return
+	}
+
+	if username != user.Username {
+		err = errors.New("username does not match")
+		return
+	}
+
+	return
+}
--- a/backend/test/test.http
+++ b/backend/test/test.http
@@ -0,0 +1,49 @@
+# For a quick start check out our HTTP Requests collection (Tools|HTTP Client|Open HTTP Requests Collection).
+#
+# Following HTTP Request Live Templates are available:
+# * 'gtrp' and 'gtr' create a GET request with or without query parameters;
+# * 'ptr' and 'ptrp' create a POST request with a simple or parameter-like body;
+# * 'mptr' and 'fptr' create a POST request to submit a form with a text or file field (multipart/form-data);
+PUT http://localhost:8000/schedules
+Content-Type: application/json
+#Content-Type: application/x-www-form-urlencoded
+
+{
+  "cron": "*/10 * * * * *",
+  "spider_id": "5d2ead494bdee04810bb7654"
+}
+
+### cron=*/10 * * * * *&spider_id=5d2ead494bdee04810bb7654
+
+DELETE http://localhost:8000/schedules/5d31b5334bdee082f6e69e7a
+
+###
+
+DELETE http://localhost:8000/spiders/5d31a6ed4bdee07b25d70c7b
+
+###
+
+
+###
+
+PUT http://localhost:8000/tasks
+Content-Type: application/json
+
+{
+  "spider_id": "5d32f20f4bdee0f4aae526de",
+  "node_id": "5d3343cc4bdee01cb772883e"
+}
+
+###
+
+POST http://localhost:8000/spiders/5d32ad224bdee0a60ee5639c/publish
+
+###
+
+POST http://localhost:8000/spiders
+
+###
+
+GET http://localhost:8000/tasks/bb79ec82-1e8f-41c4-858a-5cb682396409/log
+
+###
--- a/backend/utils/chan.go
+++ b/backend/utils/chan.go
@@ -0,0 +1,27 @@
+package utils
+
+type ChanMap struct {
+	m map[string]chan string
+}
+
+func NewChanMap() *ChanMap {
+	return &ChanMap{m: make(map[string]chan string)}
+}
+
+func (cm *ChanMap) Chan(key string) chan string {
+	if ch, ok := cm.m[key]; ok {
+		return ch
+	}
+	ch := make(chan string, 10)
+	cm.m[key] = ch
+	return ch
+}
+
+func (cm *ChanMap) ChanBlocked(key string) chan string {
+	if ch, ok := cm.m[key]; ok {
+		return ch
+	}
+	ch := make(chan string)
+	cm.m[key] = ch
+	return ch
+}
--- a/backend/utils/file.go
+++ b/backend/utils/file.go
@@ -0,0 +1,200 @@
+package utils
+
+import (
+	"archive/zip"
+	"github.com/apex/log"
+	"io"
+	"os"
+	"path/filepath"
+	"runtime/debug"
+)
+
+// 判断所给路径文件/文件夹是否存在
+func Exists(path string) bool {
+	_, err := os.Stat(path) //os.Stat获取文件信息
+	if err != nil {
+		if os.IsExist(err) {
+			return true
+		}
+		return false
+	}
+	return true
+}
+
+// 判断所给路径是否为文件夹
+func IsDir(path string) bool {
+	s, err := os.Stat(path)
+	if err != nil {
+		return false
+	}
+	return s.IsDir()
+}
+
+// 判断所给路径是否为文件
+func IsFile(path string) bool {
+	return !IsDir(path)
+}
+
+/**
+@tarFile：压缩文件路径
+@dest：解压文件夹
+*/
+func DeCompressByPath(tarFile, dest string) error {
+	srcFile, err := os.Open(tarFile)
+	if err != nil {
+		return err
+	}
+	defer srcFile.Close()
+	return DeCompress(srcFile, dest)
+}
+
+/**
+@zipFile：压缩文件
+@dstPath：解压之后文件保存路径
+*/
+func DeCompress(srcFile *os.File, dstPath string) error {
+	// 如果保存路径不存在，创建一个
+	if !Exists(dstPath) {
+		if err := os.MkdirAll(dstPath, os.ModePerm); err != nil {
+			debug.PrintStack()
+			return err
+		}
+	}
+
+	// 读取zip文件
+	zipFile, err := zip.OpenReader(srcFile.Name())
+	if err != nil {
+		log.Errorf("Unzip File Error：" + err.Error())
+		debug.PrintStack()
+		return err
+	}
+	defer zipFile.Close()
+
+	// 遍历zip内所有文件和目录
+	for _, innerFile := range zipFile.File {
+		// 获取该文件数据
+		info := innerFile.FileInfo()
+
+		// 如果是目录，则创建一个
+		if info.IsDir() {
+			err = os.MkdirAll(filepath.Join(dstPath, innerFile.Name), os.ModePerm)
+			if err != nil {
+				log.Errorf("Unzip File Error : " + err.Error())
+				debug.PrintStack()
+				return err
+			}
+			continue
+		}
+
+		// 如果文件目录不存在，则创建一个
+		dirPath := filepath.Dir(innerFile.Name)
+		if !Exists(dirPath) {
+			err = os.MkdirAll(filepath.Join(dstPath, dirPath), os.ModePerm)
+			if err != nil {
+				log.Errorf("Unzip File Error : " + err.Error())
+				debug.PrintStack()
+				return err
+			}
+		}
+
+		// 打开该文件
+		srcFile, err := innerFile.Open()
+		if err != nil {
+			log.Errorf("Unzip File Error : " + err.Error())
+			debug.PrintStack()
+			continue
+		}
+
+		// 创建新文件
+		newFile, err := os.Create(filepath.Join(dstPath, innerFile.Name))
+		if err != nil {
+			log.Errorf("Unzip File Error : " + err.Error())
+			debug.PrintStack()
+			continue
+		}
+		defer newFile.Close()
+
+		// 拷贝该文件到新文件中
+		if _, err := io.Copy(newFile, srcFile); err != nil {
+			debug.PrintStack()
+			return err
+		}
+
+		// 关闭该文件
+		if err := srcFile.Close(); err != nil {
+			debug.PrintStack()
+			return err
+		}
+
+		// 关闭新文件
+		if err := newFile.Close(); err != nil {
+			debug.PrintStack()
+			return err
+		}
+	}
+	return nil
+}
+
+//压缩文件
+//files 文件数组，可以是不同dir下的文件或者文件夹
+//dest 压缩文件存放地址
+func Compress(files []*os.File, dest string) error {
+	d, _ := os.Create(dest)
+	defer d.Close()
+	w := zip.NewWriter(d)
+	defer w.Close()
+	for _, file := range files {
+		err := _Compress(file, "", w)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func _Compress(file *os.File, prefix string, zw *zip.Writer) error {
+	info, err := file.Stat()
+	if err != nil {
+		debug.PrintStack()
+		return err
+	}
+	if info.IsDir() {
+		prefix = prefix + "/" + info.Name()
+		fileInfos, err := file.Readdir(-1)
+		if err != nil {
+			debug.PrintStack()
+			return err
+		}
+		for _, fi := range fileInfos {
+			f, err := os.Open(file.Name() + "/" + fi.Name())
+			if err != nil {
+				debug.PrintStack()
+				return err
+			}
+			err = _Compress(f, prefix, zw)
+			if err != nil {
+				debug.PrintStack()
+				return err
+			}
+		}
+	} else {
+		header, err := zip.FileInfoHeader(info)
+		header.Name = prefix + "/" + header.Name
+		if err != nil {
+			debug.PrintStack()
+			return err
+		}
+		writer, err := zw.CreateHeader(header)
+		if err != nil {
+			debug.PrintStack()
+			return err
+		}
+		_, err = io.Copy(writer, file)
+		file.Close()
+		if err != nil {
+			debug.PrintStack()
+			return err
+		}
+	}
+	return nil
+}
--- a/backend/utils/model.go
+++ b/backend/utils/model.go
@@ -0,0 +1,26 @@
+package utils
+
+import (
+	"crawlab/constants"
+	"github.com/globalsign/mgo/bson"
+	"strconv"
+	"time"
+)
+
+func IsObjectIdNull(id bson.ObjectId) bool {
+	return id.Hex() == constants.ObjectIdNull
+}
+
+func InterfaceToString(value interface{}) string {
+	switch value.(type) {
+	case bson.ObjectId:
+		return value.(bson.ObjectId).Hex()
+	case string:
+		return value.(string)
+	case int:
+		return strconv.Itoa(value.(int))
+	case time.Time:
+		return value.(time.Time).String()
+	}
+	return ""
+}
--- a/backend/utils/user.go
+++ b/backend/utils/user.go
@@ -0,0 +1,14 @@
+package utils
+
+import (
+	"crypto/md5"
+	"fmt"
+	"io"
+)
+
+func EncryptPassword(str string) string {
+	w := md5.New()
+	io.WriteString(w, str)
+	md5str := fmt.Sprintf("%x", w.Sum(nil))
+	return md5str
+}
--- a/backend/vendor/github.com/apex/log/.gitignore
+++ b/backend/vendor/github.com/apex/log/.gitignore
@@ -0,0 +1 @@
+.envrc
--- a/backend/vendor/github.com/apex/log/History.md
+++ b/backend/vendor/github.com/apex/log/History.md
@@ -0,0 +1,12 @@
+
+v1.1.1 / 2019-06-24
+===================
+
+  * add go.mod
+  * add rough pass at apexlogs handler
+
+v1.1.0 / 2018-10-11
+===================
+
+  * fix: cli handler to show non-string fields appropriately
+  * fix: cli using fatih/color to better support windows
--- a/backend/vendor/github.com/apex/log/LICENSE
+++ b/backend/vendor/github.com/apex/log/LICENSE
@@ -0,0 +1,22 @@
+(The MIT License)
+
+Copyright (c) 2015 TJ Holowaychuk tj@tjholowaychuk.com
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of this software and associated documentation files (the
+'Software'), to deal in the Software without restriction, including
+without limitation the rights to use, copy, modify, merge, publish,
+distribute, sublicense, and/or sell copies of the Software, and to
+permit persons to whom the Software is furnished to do so, subject to
+the following conditions:
+
+The above copyright notice and this permission notice shall be
+included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED 'AS IS', WITHOUT WARRANTY OF ANY KIND,
+EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
+MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
+IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY
+CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,
+TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
--- a/backend/vendor/github.com/apex/log/Makefile
+++ b/backend/vendor/github.com/apex/log/Makefile
@@ -0,0 +1,2 @@
+
+include github.com/tj/make/golang
--- a/backend/vendor/github.com/apex/log/Readme.md
+++ b/backend/vendor/github.com/apex/log/Readme.md
@@ -0,0 +1,29 @@
+
+![Structured logging for golang](assets/title.png)
+
+Package log implements a simple structured logging API inspired by Logrus, designed with centralization in mind. Read more on [Medium](https://medium.com/@tjholowaychuk/apex-log-e8d9627f4a9a#.rav8yhkud).
+
+## Handlers
+
+- __cli__ – human-friendly CLI output
+- __discard__ – discards all logs
+- __es__ – Elasticsearch handler
+- __graylog__ – Graylog handler
+- __json__ – JSON output handler
+- __kinesis__ – AWS Kinesis handler
+- __level__ – level filter handler
+- __logfmt__ – logfmt plain-text formatter
+- __memory__ – in-memory handler for tests
+- __multi__ – fan-out to multiple handlers
+- __papertrail__ – Papertrail handler
+- __text__ – human-friendly colored output
+- __delta__ – outputs the delta between log calls and spinner
+
+---
+
+[![Build Status](https://semaphoreci.com/api/v1/projects/d8a8b1c0-45b0-4b89-b066-99d788d0b94c/642077/badge.svg)](https://semaphoreci.com/tj/log)
+[![GoDoc](https://godoc.org/github.com/apex/log?status.svg)](https://godoc.org/github.com/apex/log)
+![](https://img.shields.io/badge/license-MIT-blue.svg)
+![](https://img.shields.io/badge/status-stable-green.svg)
+
+<a href="https://apex.sh"><img src="http://tjholowaychuk.com:6000/svg/sponsor"></a>
--- a/backend/vendor/github.com/apex/log/default.go
+++ b/backend/vendor/github.com/apex/log/default.go
@@ -0,0 +1,45 @@
+package log
+
+import (
+	"bytes"
+	"fmt"
+	"log"
+	"sort"
+)
+
+// field used for sorting.
+type field struct {
+	Name  string
+	Value interface{}
+}
+
+// by sorts fields by name.
+type byName []field
+
+func (a byName) Len() int           { return len(a) }
+func (a byName) Swap(i, j int)      { a[i], a[j] = a[j], a[i] }
+func (a byName) Less(i, j int) bool { return a[i].Name < a[j].Name }
+
+// handleStdLog outpouts to the stlib log.
+func handleStdLog(e *Entry) error {
+	level := levelNames[e.Level]
+
+	var fields []field
+
+	for k, v := range e.Fields {
+		fields = append(fields, field{k, v})
+	}
+
+	sort.Sort(byName(fields))
+
+	var b bytes.Buffer
+	fmt.Fprintf(&b, "%5s %-25s", level, e.Message)
+
+	for _, f := range fields {
+		fmt.Fprintf(&b, " %s=%v", f.Name, f.Value)
+	}
+
+	log.Println(b.String())
+
+	return nil
+}
--- a/backend/vendor/github.com/apex/log/doc.go
+++ b/backend/vendor/github.com/apex/log/doc.go
@@ -0,0 +1,10 @@
+/*
+Package log implements a simple structured logging API designed with few assumptions. Designed for
+centralized logging solutions such as Kinesis which require encoding and decoding before fanning-out
+to handlers.
+
+You may use this package with inline handlers, much like Logrus, however a centralized solution
+is recommended so that apps do not need to be re-deployed to add or remove logging service
+providers.
+*/
+package log
--- a/backend/vendor/github.com/apex/log/entry.go
+++ b/backend/vendor/github.com/apex/log/entry.go
@@ -0,0 +1,172 @@
+package log
+
+import (
+	"fmt"
+	"os"
+	"strings"
+	"time"
+)
+
+// assert interface compliance.
+var _ Interface = (*Entry)(nil)
+
+// Now returns the current time.
+var Now = time.Now
+
+// Entry represents a single log entry.
+type Entry struct {
+	Logger    *Logger   `json:"-"`
+	Fields    Fields    `json:"fields"`
+	Level     Level     `json:"level"`
+	Timestamp time.Time `json:"timestamp"`
+	Message   string    `json:"message"`
+	start     time.Time
+	fields    []Fields
+}
+
+// NewEntry returns a new entry for `log`.
+func NewEntry(log *Logger) *Entry {
+	return &Entry{
+		Logger: log,
+	}
+}
+
+// WithFields returns a new entry with `fields` set.
+func (e *Entry) WithFields(fields Fielder) *Entry {
+	f := []Fields{}
+	f = append(f, e.fields...)
+	f = append(f, fields.Fields())
+	return &Entry{
+		Logger: e.Logger,
+		fields: f,
+	}
+}
+
+// WithField returns a new entry with the `key` and `value` set.
+func (e *Entry) WithField(key string, value interface{}) *Entry {
+	return e.WithFields(Fields{key: value})
+}
+
+// WithError returns a new entry with the "error" set to `err`.
+//
+// The given error may implement .Fielder, if it does the method
+// will add all its `.Fields()` into the returned entry.
+func (e *Entry) WithError(err error) *Entry {
+	ctx := e.WithField("error", err.Error())
+
+	if s, ok := err.(stackTracer); ok {
+		frame := s.StackTrace()[0]
+
+		name := fmt.Sprintf("%n", frame)
+		file := fmt.Sprintf("%+s", frame)
+		line := fmt.Sprintf("%d", frame)
+
+		parts := strings.Split(file, "\n\t")
+		if len(parts) > 1 {
+			file = parts[1]
+		}
+
+		ctx = ctx.WithField("source", fmt.Sprintf("%s: %s:%s", name, file, line))
+	}
+
+	if f, ok := err.(Fielder); ok {
+		ctx = ctx.WithFields(f.Fields())
+	}
+
+	return ctx
+}
+
+// Debug level message.
+func (e *Entry) Debug(msg string) {
+	e.Logger.log(DebugLevel, e, msg)
+}
+
+// Info level message.
+func (e *Entry) Info(msg string) {
+	e.Logger.log(InfoLevel, e, msg)
+}
+
+// Warn level message.
+func (e *Entry) Warn(msg string) {
+	e.Logger.log(WarnLevel, e, msg)
+}
+
+// Error level message.
+func (e *Entry) Error(msg string) {
+	e.Logger.log(ErrorLevel, e, msg)
+}
+
+// Fatal level message, followed by an exit.
+func (e *Entry) Fatal(msg string) {
+	e.Logger.log(FatalLevel, e, msg)
+	os.Exit(1)
+}
+
+// Debugf level formatted message.
+func (e *Entry) Debugf(msg string, v ...interface{}) {
+	e.Debug(fmt.Sprintf(msg, v...))
+}
+
+// Infof level formatted message.
+func (e *Entry) Infof(msg string, v ...interface{}) {
+	e.Info(fmt.Sprintf(msg, v...))
+}
+
+// Warnf level formatted message.
+func (e *Entry) Warnf(msg string, v ...interface{}) {
+	e.Warn(fmt.Sprintf(msg, v...))
+}
+
+// Errorf level formatted message.
+func (e *Entry) Errorf(msg string, v ...interface{}) {
+	e.Error(fmt.Sprintf(msg, v...))
+}
+
+// Fatalf level formatted message, followed by an exit.
+func (e *Entry) Fatalf(msg string, v ...interface{}) {
+	e.Fatal(fmt.Sprintf(msg, v...))
+}
+
+// Trace returns a new entry with a Stop method to fire off
+// a corresponding completion log, useful with defer.
+func (e *Entry) Trace(msg string) *Entry {
+	e.Info(msg)
+	v := e.WithFields(e.Fields)
+	v.Message = msg
+	v.start = time.Now()
+	return v
+}
+
+// Stop should be used with Trace, to fire off the completion message. When
+// an `err` is passed the "error" field is set, and the log level is error.
+func (e *Entry) Stop(err *error) {
+	if err == nil || *err == nil {
+		e.WithField("duration", time.Since(e.start)).Info(e.Message)
+	} else {
+		e.WithField("duration", time.Since(e.start)).WithError(*err).Error(e.Message)
+	}
+}
+
+// mergedFields returns the fields list collapsed into a single map.
+func (e *Entry) mergedFields() Fields {
+	f := Fields{}
+
+	for _, fields := range e.fields {
+		for k, v := range fields {
+			f[k] = v
+		}
+	}
+
+	return f
+}
+
+// finalize returns a copy of the Entry with Fields merged.
+func (e *Entry) finalize(level Level, msg string) *Entry {
+	return &Entry{
+		Logger:    e.Logger,
+		Fields:    e.mergedFields(),
+		Level:     level,
+		Message:   msg,
+		Timestamp: Now(),
+	}
+}
--- a/backend/vendor/github.com/apex/log/go.mod
+++ b/backend/vendor/github.com/apex/log/go.mod
@@ -0,0 +1,25 @@
+module github.com/apex/log
+
+go 1.12
+
+require (
+	github.com/aphistic/golf v0.0.0-20180712155816-02c07f170c5a
+	github.com/aphistic/sweet v0.2.0 // indirect
+	github.com/aws/aws-sdk-go v1.20.6
+	github.com/aybabtme/rgbterm v0.0.0-20170906152045-cc83f3b3ce59
+	github.com/fatih/color v1.7.0
+	github.com/go-logfmt/logfmt v0.4.0
+	github.com/google/uuid v1.1.1 // indirect
+	github.com/jpillora/backoff v0.0.0-20180909062703-3050d21c67d7 // indirect
+	github.com/mattn/go-colorable v0.1.2
+	github.com/pkg/errors v0.8.1
+	github.com/rogpeppe/fastuuid v1.1.0
+	github.com/smartystreets/go-aws-auth v0.0.0-20180515143844-0c1422d1fdb9 // indirect
+	github.com/smartystreets/gunit v1.0.0 // indirect
+	github.com/stretchr/testify v1.3.0
+	github.com/tj/assert v0.0.0-20171129193455-018094318fb0
+	github.com/tj/go-elastic v0.0.0-20171221160941-36157cbbebc2
+	github.com/tj/go-kinesis v0.0.0-20171128231115-08b17f58cb1b
+	github.com/tj/go-spin v1.1.0
+	golang.org/x/net v0.0.0-20190620200207-3b0461eec859 // indirect
+)
--- a/backend/vendor/github.com/apex/log/go.sum
+++ b/backend/vendor/github.com/apex/log/go.sum
@@ -0,0 +1,90 @@
+github.com/aphistic/golf v0.0.0-20180712155816-02c07f170c5a h1:2KLQMJ8msqoPHIPDufkxVcoTtcmE5+1sL9950m4R9Pk=
+github.com/aphistic/golf v0.0.0-20180712155816-02c07f170c5a/go.mod h1:3NqKYiepwy8kCu4PNA+aP7WUV72eXWJeP9/r3/K9aLE=
+github.com/aphistic/sweet v0.2.0 h1:I4z+fAUqvKfvZV/CHi5dV0QuwbmIvYYFDjG0Ss5QpAs=
+github.com/aphistic/sweet v0.2.0/go.mod h1:fWDlIh/isSE9n6EPsRmC0det+whmX6dJid3stzu0Xys=
+github.com/aws/aws-sdk-go v1.20.6 h1:kmy4Gvdlyez1fV4kw5RYxZzWKVyuHZHgPWeU/YvRsV4=
+github.com/aws/aws-sdk-go v1.20.6/go.mod h1:KmX6BPdI08NWTb3/sm4ZGu5ShLoqVDhKgpiN924inxo=
+github.com/aybabtme/rgbterm v0.0.0-20170906152045-cc83f3b3ce59 h1:WWB576BN5zNSZc/M9d/10pqEx5VHNhaQ/yOVAkmj5Yo=
+github.com/aybabtme/rgbterm v0.0.0-20170906152045-cc83f3b3ce59/go.mod h1:q/89r3U2H7sSsE2t6Kca0lfwTK8JdoNGS/yzM/4iH5I=
+github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
+github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
+github.com/fatih/color v1.7.0 h1:DkWD4oS2D8LGGgTQ6IvwJJXSL5Vp2ffcQg58nFV38Ys=
+github.com/fatih/color v1.7.0/go.mod h1:Zm6kSWBoL9eyXnKyktHP6abPY2pDugNf5KwzbycvMj4=
+github.com/fsnotify/fsnotify v1.4.7 h1:IXs+QLmnXW2CcXuY+8Mzv/fWEsPGWxqefPtCP5CnV9I=
+github.com/fsnotify/fsnotify v1.4.7/go.mod h1:jwhsz4b93w/PPRr/qN1Yymfu8t87LnFCMoQvtojpjFo=
+github.com/go-logfmt/logfmt v0.4.0 h1:MP4Eh7ZCb31lleYCFuwm0oe4/YGak+5l1vA2NOE80nA=
+github.com/go-logfmt/logfmt v0.4.0/go.mod h1:3RMwSq7FuexP4Kalkev3ejPJsZTpXXBr9+V4qmtdjCk=
+github.com/golang/protobuf v1.2.0 h1:P3YflyNX/ehuJFLhxviNdFxQPkGK5cDcApsge1SqnvM=
+github.com/golang/protobuf v1.2.0/go.mod h1:6lQm79b+lXiMfvg/cZm0SGofjICqVBUtrP5yJMmIC1U=
+github.com/google/uuid v1.1.1 h1:Gkbcsh/GbpXz7lPftLA3P6TYMwjCLYm83jiFQZF/3gY=
+github.com/google/uuid v1.1.1/go.mod h1:TIyPZe4MgqvfeYDBFedMoGGpEw/LqOeaOT+nhxU+yHo=
+github.com/hpcloud/tail v1.0.0 h1:nfCOvKYfkgYP8hkirhJocXT2+zOD8yUNjXaWfTlyFKI=
+github.com/hpcloud/tail v1.0.0/go.mod h1:ab1qPbhIpdTxEkNHXyeSf5vhxWSCs/tWer42PpOxQnU=
+github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af h1:pmfjZENx5imkbgOkpRUYLnmbU7UEFbjtDA2hxJ1ichM=
+github.com/jmespath/go-jmespath v0.0.0-20180206201540-c2b33e8439af/go.mod h1:Nht3zPeWKUH0NzdCt2Blrr5ys8VGpn0CEB0cQHVjt7k=
+github.com/jpillora/backoff v0.0.0-20180909062703-3050d21c67d7 h1:K//n/AqR5HjG3qxbrBCL4vJPW0MVFSs9CPK1OOJdRME=
+github.com/jpillora/backoff v0.0.0-20180909062703-3050d21c67d7/go.mod h1:2iMrUgbbvHEiQClaW2NsSzMyGHqN+rDFqY705q49KG0=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515 h1:T+h1c/A9Gawja4Y9mFVWj2vyii2bbUNDw3kt9VxK2EY=
+github.com/kr/logfmt v0.0.0-20140226030751-b84e30acd515/go.mod h1:+0opPa2QZZtGFBFZlji/RkVcI2GknAs/DXo4wKdlNEc=
+github.com/mattn/go-colorable v0.1.1/go.mod h1:FuOcm+DKB9mbwrcAfNl7/TZVBZ6rcnceauSikq3lYCQ=
+github.com/mattn/go-colorable v0.1.2 h1:/bC9yWikZXAL9uJdulbSfyVNIR3n3trXl+v8+1sx8mU=
+github.com/mattn/go-colorable v0.1.2/go.mod h1:U0ppj6V5qS13XJ6of8GYAs25YV2eR4EVcfRqFIhoBtE=
+github.com/mattn/go-isatty v0.0.5/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mattn/go-isatty v0.0.8 h1:HLtExJ+uU2HOZ+wI0Tt5DtUDrx8yhUqDcp7fYERX4CE=
+github.com/mattn/go-isatty v0.0.8/go.mod h1:Iq45c/XA43vh69/j3iqttzPXn0bhXyGjM0Hdxcsrc5s=
+github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b h1:j7+1HpAFS1zy5+Q4qx1fWh90gTKwiN4QCGoY9TWyyO4=
+github.com/mgutz/ansi v0.0.0-20170206155736-9520e82c474b/go.mod h1:01TrycV0kFyexm33Z7vhZRXopbI8J3TDReVlkTgMUxE=
+github.com/onsi/ginkgo v1.6.0 h1:Ix8l273rp3QzYgXSR+c8d1fTG7UPgYkOSELPhiY/YGw=
+github.com/onsi/ginkgo v1.6.0/go.mod h1:lLunBs/Ym6LB5Z9jYTR76FiuTmxDTDusOGeTQH+WWjE=
+github.com/onsi/gomega v1.5.0 h1:izbySO9zDPmjJ8rDjLvkA2zJHIo+HkYXHnf7eN7SSyo=
+github.com/onsi/gomega v1.5.0/go.mod h1:ex+gbHU/CVuBBDIJjb2X0qEXbFg53c61hWP/1CpauHY=
+github.com/pkg/errors v0.8.1 h1:iURUrRGxPUNPdy5/HRSm+Yj6okJ6UtLINN0Q9M4+h3I=
+github.com/pkg/errors v0.8.1/go.mod h1:bwawxfHBFNV+L2hUp1rHADufV3IMtnDRdf1r5NINEl0=
+github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
+github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
+github.com/rogpeppe/fastuuid v1.1.0 h1:INyGLmTCMGFr6OVIb977ghJvABML2CMVjPoRfNDdYDo=
+github.com/rogpeppe/fastuuid v1.1.0/go.mod h1:jVj6XXZzXRy/MSR5jhDC/2q6DgLz+nrA6LYCDYWNEvQ=
+github.com/sergi/go-diff v1.0.0 h1:Kpca3qRNrduNnOQeazBd0ysaKrUJiIuISHxogkT9RPQ=
+github.com/sergi/go-diff v1.0.0/go.mod h1:0CfEIISq7TuYL3j771MWULgwwjU+GofnZX9QAmXWZgo=
+github.com/smartystreets/assertions v1.0.0 h1:UVQPSSmc3qtTi+zPPkCXvZX9VvW/xT/NsRvKfwY81a8=
+github.com/smartystreets/assertions v1.0.0/go.mod h1:kHHU4qYBaI3q23Pp3VPrmWhuIUrLW/7eUrw0BU5VaoM=
+github.com/smartystreets/go-aws-auth v0.0.0-20180515143844-0c1422d1fdb9 h1:hp2CYQUINdZMHdvTdXtPOY2ainKl4IoMcpAXEf2xj3Q=
+github.com/smartystreets/go-aws-auth v0.0.0-20180515143844-0c1422d1fdb9/go.mod h1:SnhjPscd9TpLiy1LpzGSKh3bXCfxxXuqd9xmQJy3slM=
+github.com/smartystreets/gunit v1.0.0 h1:RyPDUFcJbvtXlhJPk7v+wnxZRY2EUokhEYl2EJOPToI=
+github.com/smartystreets/gunit v1.0.0/go.mod h1:qwPWnhz6pn0NnRBP++URONOVyNkPyr4SauJk4cUOwJs=
+github.com/stretchr/objx v0.1.0/go.mod h1:HFkY916IF+rwdDfMAkV7OtwuqBVzrE8GR6GFx+wExME=
+github.com/stretchr/testify v1.3.0 h1:TivCn/peBQ7UY8ooIcPgZFpTNSz0Q2U6UrFlUfqbe0Q=
+github.com/stretchr/testify v1.3.0/go.mod h1:M5WIy9Dh21IEIfnGCwXGc5bZfKNJtfHm1UVUgZn+9EI=
+github.com/tj/assert v0.0.0-20171129193455-018094318fb0 h1:Rw8kxzWo1mr6FSaYXjQELRe88y2KdfynXdnK72rdjtA=
+github.com/tj/assert v0.0.0-20171129193455-018094318fb0/go.mod h1:mZ9/Rh9oLWpLLDRpvE+3b7gP/C2YyLFYxNmcLnPTMe0=
+github.com/tj/go-elastic v0.0.0-20171221160941-36157cbbebc2 h1:eGaGNxrtoZf/mBURsnNQKDR7u50Klgcf2eFDQEnc8Bc=
+github.com/tj/go-elastic v0.0.0-20171221160941-36157cbbebc2/go.mod h1:WjeM0Oo1eNAjXGDx2yma7uG2XoyRZTq1uv3M/o7imD0=
+github.com/tj/go-kinesis v0.0.0-20171128231115-08b17f58cb1b h1:m74UWYy+HBs+jMFR9mdZU6shPewugMyH5+GV6LNgW8w=
+github.com/tj/go-kinesis v0.0.0-20171128231115-08b17f58cb1b/go.mod h1:/yhzCV0xPfx6jb1bBgRFjl5lytqVqZXEaeqWP8lTEao=
+github.com/tj/go-spin v1.1.0 h1:lhdWZsvImxvZ3q1C5OIB7d72DuOwP4O2NdBg9PyzNds=
+github.com/tj/go-spin v1.1.0/go.mod h1:Mg1mzmePZm4dva8Qz60H2lHwmJ2loum4VIrLgVnKwh4=
+golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
+golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734 h1:p/H982KKEjUnLJkM3tt/LemDnOc1GiZL5FCVlORJ5zo=
+golang.org/x/crypto v0.0.0-20190426145343-a29dc8fdc734/go.mod h1:yigFU9vqHzYiE8UmvKecakEJjdnWj3jj499lnFckfCI=
+golang.org/x/net v0.0.0-20180906233101-161cd47e91fd/go.mod h1:mL1N/T3taQHkDXs73rZJwtUhF3w3ftmwwsq0BUmARs4=
+golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859 h1:R/3boaszxrf1GEUWTVDzSKVwLmSJpwZ1yqXm8j0v2QI=
+golang.org/x/net v0.0.0-20190620200207-3b0461eec859/go.mod h1:z5CRVTTTmAJ677TzLLGU+0bjPO0LkuOLi4/5GtJWs/s=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f h1:wMNYb4v58l5UBM7MYRLPG6ZhfOqbKu7X5eyFl8ZhKvA=
+golang.org/x/sync v0.0.0-20180314180146-1d60e4601c6f/go.mod h1:RxMgew5VJxzue5/jJTE5uejpjVlOe/izrB70Jof72aM=
+golang.org/x/sys v0.0.0-20180909124046-d0be0721c37e/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223 h1:DH4skfRX4EBpamg7iV4ZlCpblAHI6s6TDM39bFZumv8=
+golang.org/x/sys v0.0.0-20190222072716-a9d3bda3a223/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d h1:+R4KGOnez64A81RvjARKc4UT5/tI9ujCIVX+P5KiHuI=
+golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/text v0.3.0 h1:g61tztE5qeGQ89tm6NTjjM9VPIm088od1l6aSorWRWg=
+golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405 h1:yhCVgyC4o1eVCa2tZl7eS0r+SDo693bJlVdllGtEeKM=
+gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
+gopkg.in/fsnotify.v1 v1.4.7 h1:xOHLXZwVvI9hhs+cLKq5+I5onOuwQLhQwiu63xxlHs4=
+gopkg.in/fsnotify.v1 v1.4.7/go.mod h1:Tz8NjZHkW78fSQdbUxIjBTcgA1z1m8ZHf0WmKUhAMys=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7 h1:uRGJdciOHaEIrze2W8Q3AKkepLTh2hOroT7a+7czfdQ=
+gopkg.in/tomb.v1 v1.0.0-20141024135613-dd632973f1e7/go.mod h1:dt/ZhP58zS4L8KSrWDmTeBkI65Dw0HsyUHuEVlX15mw=
+gopkg.in/yaml.v2 v2.2.1 h1:mUhvW9EsL+naU5Q3cakzfE91YhliOondGd6ZrsDBHQE=
+gopkg.in/yaml.v2 v2.2.1/go.mod h1:hI93XBmqTisBFMUTm0b8Fm+jr3Dg1NNxqwp+5A1VGuI=
--- a/backend/vendor/github.com/apex/log/interface.go
+++ b/backend/vendor/github.com/apex/log/interface.go
@@ -0,0 +1,19 @@
+package log
+
+// Interface represents the API of both Logger and Entry.
+type Interface interface {
+	WithFields(fields Fielder) *Entry
+	WithField(key string, value interface{}) *Entry
+	WithError(err error) *Entry
+	Debug(msg string)
+	Info(msg string)
+	Warn(msg string)
+	Error(msg string)
+	Fatal(msg string)
+	Debugf(msg string, v ...interface{})
+	Infof(msg string, v ...interface{})
+	Warnf(msg string, v ...interface{})
+	Errorf(msg string, v ...interface{})
+	Fatalf(msg string, v ...interface{})
+	Trace(msg string) *Entry
+}
--- a/backend/vendor/github.com/apex/log/levels.go
+++ b/backend/vendor/github.com/apex/log/levels.go
@@ -0,0 +1,81 @@
+package log
+
+import (
+	"bytes"
+	"errors"
+	"strings"
+)
+
+// ErrInvalidLevel is returned if the severity level is invalid.
+var ErrInvalidLevel = errors.New("invalid level")
+
+// Level of severity.
+type Level int
+
+// Log levels.
+const (
+	InvalidLevel Level = iota - 1
+	DebugLevel
+	InfoLevel
+	WarnLevel
+	ErrorLevel
+	FatalLevel
+)
+
+var levelNames = [...]string{
+	DebugLevel: "debug",
+	InfoLevel:  "info",
+	WarnLevel:  "warn",
+	ErrorLevel: "error",
+	FatalLevel: "fatal",
+}
+
+var levelStrings = map[string]Level{
+	"debug":   DebugLevel,
+	"info":    InfoLevel,
+	"warn":    WarnLevel,
+	"warning": WarnLevel,
+	"error":   ErrorLevel,
+	"fatal":   FatalLevel,
+}
+
+// String implementation.
+func (l Level) String() string {
+	return levelNames[l]
+}
+
+// MarshalJSON implementation.
+func (l Level) MarshalJSON() ([]byte, error) {
+	return []byte(`"` + l.String() + `"`), nil
+}
+
+// UnmarshalJSON implementation.
+func (l *Level) UnmarshalJSON(b []byte) error {
+	v, err := ParseLevel(string(bytes.Trim(b, `"`)))
+	if err != nil {
+		return err
+	}
+
+	*l = v
+	return nil
+}
+
+// ParseLevel parses level string.
+func ParseLevel(s string) (Level, error) {
+	l, ok := levelStrings[strings.ToLower(s)]
+	if !ok {
+		return InvalidLevel, ErrInvalidLevel
+	}
+
+	return l, nil
+}
+
+// MustParseLevel parses level string or panics.
+func MustParseLevel(s string) Level {
+	l, err := ParseLevel(s)
+	if err != nil {
+		panic("invalid log level")
+	}
+
+	return l
+}
--- a/backend/vendor/github.com/apex/log/logger.go
+++ b/backend/vendor/github.com/apex/log/logger.go
@@ -0,0 +1,149 @@
+package log
+
+import (
+	stdlog "log"
+	"sort"
+)
+
+// assert interface compliance.
+var _ Interface = (*Logger)(nil)
+
+// Fielder is an interface for providing fields to custom types.
+type Fielder interface {
+	Fields() Fields
+}
+
+// Fields represents a map of entry level data used for structured logging.
+type Fields map[string]interface{}
+
+// Fields implements Fielder.
+func (f Fields) Fields() Fields {
+	return f
+}
+
+// Get field value by name.
+func (f Fields) Get(name string) interface{} {
+	return f[name]
+}
+
+// Names returns field names sorted.
+func (f Fields) Names() (v []string) {
+	for k := range f {
+		v = append(v, k)
+	}
+
+	sort.Strings(v)
+	return
+}
+
+// The HandlerFunc type is an adapter to allow the use of ordinary functions as
+// log handlers. If f is a function with the appropriate signature,
+// HandlerFunc(f) is a Handler object that calls f.
+type HandlerFunc func(*Entry) error
+
+// HandleLog calls f(e).
+func (f HandlerFunc) HandleLog(e *Entry) error {
+	return f(e)
+}
+
+// Handler is used to handle log events, outputting them to
+// stdio or sending them to remote services. See the "handlers"
+// directory for implementations.
+//
+// It is left up to Handlers to implement thread-safety.
+type Handler interface {
+	HandleLog(*Entry) error
+}
+
+// Logger represents a logger with configurable Level and Handler.
+type Logger struct {
+	Handler Handler
+	Level   Level
+}
+
+// WithFields returns a new entry with `fields` set.
+func (l *Logger) WithFields(fields Fielder) *Entry {
+	return NewEntry(l).WithFields(fields.Fields())
+}
+
+// WithField returns a new entry with the `key` and `value` set.
+//
+// Note that the `key` should not have spaces in it - use camel
+// case or underscores
+func (l *Logger) WithField(key string, value interface{}) *Entry {
+	return NewEntry(l).WithField(key, value)
+}
+
+// WithError returns a new entry with the "error" set to `err`.
+func (l *Logger) WithError(err error) *Entry {
+	return NewEntry(l).WithError(err)
+}
+
+// Debug level message.
+func (l *Logger) Debug(msg string) {
+	NewEntry(l).Debug(msg)
+}
+
+// Info level message.
+func (l *Logger) Info(msg string) {
+	NewEntry(l).Info(msg)
+}
+
+// Warn level message.
+func (l *Logger) Warn(msg string) {
+	NewEntry(l).Warn(msg)
+}
+
+// Error level message.
+func (l *Logger) Error(msg string) {
+	NewEntry(l).Error(msg)
+}
+
+// Fatal level message, followed by an exit.
+func (l *Logger) Fatal(msg string) {
+	NewEntry(l).Fatal(msg)
+}
+
+// Debugf level formatted message.
+func (l *Logger) Debugf(msg string, v ...interface{}) {
+	NewEntry(l).Debugf(msg, v...)
+}
+
+// Infof level formatted message.
+func (l *Logger) Infof(msg string, v ...interface{}) {
+	NewEntry(l).Infof(msg, v...)
+}
+
+// Warnf level formatted message.
+func (l *Logger) Warnf(msg string, v ...interface{}) {
+	NewEntry(l).Warnf(msg, v...)
+}
+
+// Errorf level formatted message.
+func (l *Logger) Errorf(msg string, v ...interface{}) {
+	NewEntry(l).Errorf(msg, v...)
+}
+
+// Fatalf level formatted message, followed by an exit.
+func (l *Logger) Fatalf(msg string, v ...interface{}) {
+	NewEntry(l).Fatalf(msg, v...)
+}
+
+// Trace returns a new entry with a Stop method to fire off
+// a corresponding completion log, useful with defer.
+func (l *Logger) Trace(msg string) *Entry {
+	return NewEntry(l).Trace(msg)
+}
+
+// log the message, invoking the handler. We clone the entry here
+// to bypass the overhead in Entry methods when the level is not
+// met.
+func (l *Logger) log(level Level, e *Entry, msg string) {
+	if level < l.Level {
+		return
+	}
+
+	if err := l.Handler.HandleLog(e.finalize(level, msg)); err != nil {
+		stdlog.Printf("error logging: %s", err)
+	}
+}
--- a/backend/vendor/github.com/apex/log/pkg.go
+++ b/backend/vendor/github.com/apex/log/pkg.go
@@ -0,0 +1,100 @@
+package log
+
+// singletons ftw?
+var Log Interface = &Logger{
+	Handler: HandlerFunc(handleStdLog),
+	Level:   InfoLevel,
+}
+
+// SetHandler sets the handler. This is not thread-safe.
+// The default handler outputs to the stdlib log.
+func SetHandler(h Handler) {
+	if logger, ok := Log.(*Logger); ok {
+		logger.Handler = h
+	}
+}
+
+// SetLevel sets the log level. This is not thread-safe.
+func SetLevel(l Level) {
+	if logger, ok := Log.(*Logger); ok {
+		logger.Level = l
+	}
+}
+
+// SetLevelFromString sets the log level from a string, panicing when invalid. This is not thread-safe.
+func SetLevelFromString(s string) {
+	if logger, ok := Log.(*Logger); ok {
+		logger.Level = MustParseLevel(s)
+	}
+}
+
+// WithFields returns a new entry with `fields` set.
+func WithFields(fields Fielder) *Entry {
+	return Log.WithFields(fields)
+}
+
+// WithField returns a new entry with the `key` and `value` set.
+func WithField(key string, value interface{}) *Entry {
+	return Log.WithField(key, value)
+}
+
+// WithError returns a new entry with the "error" set to `err`.
+func WithError(err error) *Entry {
+	return Log.WithError(err)
+}
+
+// Debug level message.
+func Debug(msg string) {
+	Log.Debug(msg)
+}
+
+// Info level message.
+func Info(msg string) {
+	Log.Info(msg)
+}
+
+// Warn level message.
+func Warn(msg string) {
+	Log.Warn(msg)
+}
+
+// Error level message.
+func Error(msg string) {
+	Log.Error(msg)
+}
+
+// Fatal level message, followed by an exit.
+func Fatal(msg string) {
+	Log.Fatal(msg)
+}
+
+// Debugf level formatted message.
+func Debugf(msg string, v ...interface{}) {
+	Log.Debugf(msg, v...)
+}
+
+// Infof level formatted message.
+func Infof(msg string, v ...interface{}) {
+	Log.Infof(msg, v...)
+}
+
+// Warnf level formatted message.
+func Warnf(msg string, v ...interface{}) {
+	Log.Warnf(msg, v...)
+}
+
+// Errorf level formatted message.
+func Errorf(msg string, v ...interface{}) {
+	Log.Errorf(msg, v...)
+}
+
+// Fatalf level formatted message, followed by an exit.
+func Fatalf(msg string, v ...interface{}) {
+	Log.Fatalf(msg, v...)
+}
+
+// Trace returns a new entry with a Stop method to fire off
+// a corresponding completion log, useful with defer.
+func Trace(msg string) *Entry {
+	return Log.Trace(msg)
+}
--- a/backend/vendor/github.com/apex/log/stack.go
+++ b/backend/vendor/github.com/apex/log/stack.go
@@ -0,0 +1,8 @@
+package log
+
+import "github.com/pkg/errors"
+
+// stackTracer interface.
+type stackTracer interface {
+	StackTrace() errors.StackTrace
+}
--- a/backend/vendor/github.com/dgrijalva/jwt-go/.gitignore
+++ b/backend/vendor/github.com/dgrijalva/jwt-go/.gitignore
@@ -0,0 +1,4 @@
+.DS_Store
+bin
+
+
--- a/backend/vendor/github.com/dgrijalva/jwt-go/.travis.yml
+++ b/backend/vendor/github.com/dgrijalva/jwt-go/.travis.yml
@@ -0,0 +1,13 @@
+language: go
+
+script:
+    - go vet ./...
+    - go test -v ./...
+
+go:
+  - 1.3
+  - 1.4
+  - 1.5
+  - 1.6
+  - 1.7
+  - tip
--- a/backend/vendor/github.com/dgrijalva/jwt-go/LICENSE
+++ b/backend/vendor/github.com/dgrijalva/jwt-go/LICENSE
@@ -0,0 +1,8 @@
+Copyright (c) 2012 Dave Grijalva
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
--- a/backend/vendor/github.com/dgrijalva/jwt-go/MIGRATION_GUIDE.md
+++ b/backend/vendor/github.com/dgrijalva/jwt-go/MIGRATION_GUIDE.md
@@ -0,0 +1,97 @@
+## Migration Guide from v2 -> v3
+
+Version 3 adds several new, frequently requested features.  To do so, it introduces a few breaking changes.  We've worked to keep these as minimal as possible.  This guide explains the breaking changes and how you can quickly update your code.
+
+### `Token.Claims` is now an interface type
+
+The most requested feature from the 2.0 verison of this library was the ability to provide a custom type to the JSON parser for claims. This was implemented by introducing a new interface, `Claims`, to replace `map[string]interface{}`.  We also included two concrete implementations of `Claims`: `MapClaims` and `StandardClaims`.
+
+`MapClaims` is an alias for `map[string]interface{}` with built in validation behavior.  It is the default claims type when using `Parse`.  The usage is unchanged except you must type cast the claims property.
+
+The old example for parsing a token looked like this..
+
+```go
+	if token, err := jwt.Parse(tokenString, keyLookupFunc); err == nil {
+		fmt.Printf("Token for user %v expires %v", token.Claims["user"], token.Claims["exp"])
+	}
+```
+
+is now directly mapped to...
+
+```go
+	if token, err := jwt.Parse(tokenString, keyLookupFunc); err == nil {
+		claims := token.Claims.(jwt.MapClaims)
+		fmt.Printf("Token for user %v expires %v", claims["user"], claims["exp"])
+	}
+```
+
+`StandardClaims` is designed to be embedded in your custom type.  You can supply a custom claims type with the new `ParseWithClaims` function.  Here's an example of using a custom claims type.
+
+```go
+	type MyCustomClaims struct {
+		User string
+		*StandardClaims
+	}
+	
+	if token, err := jwt.ParseWithClaims(tokenString, &MyCustomClaims{}, keyLookupFunc); err == nil {
+		claims := token.Claims.(*MyCustomClaims)
+		fmt.Printf("Token for user %v expires %v", claims.User, claims.StandardClaims.ExpiresAt)
+	}
+```
+
+### `ParseFromRequest` has been moved
+
+To keep this library focused on the tokens without becoming overburdened with complex request processing logic, `ParseFromRequest` and its new companion `ParseFromRequestWithClaims` have been moved to a subpackage, `request`.  The method signatues have also been augmented to receive a new argument: `Extractor`.
+
+`Extractors` do the work of picking the token string out of a request.  The interface is simple and composable.
+
+This simple parsing example:
+
+```go
+	if token, err := jwt.ParseFromRequest(tokenString, req, keyLookupFunc); err == nil {
+		fmt.Printf("Token for user %v expires %v", token.Claims["user"], token.Claims["exp"])
+	}
+```
+
+is directly mapped to:
+
+```go
+	if token, err := request.ParseFromRequest(req, request.OAuth2Extractor, keyLookupFunc); err == nil {
+		claims := token.Claims.(jwt.MapClaims)
+		fmt.Printf("Token for user %v expires %v", claims["user"], claims["exp"])
+	}
+```
+
+There are several concrete `Extractor` types provided for your convenience:
+
+* `HeaderExtractor` will search a list of headers until one contains content.
+* `ArgumentExtractor` will search a list of keys in request query and form arguments until one contains content.
+* `MultiExtractor` will try a list of `Extractors` in order until one returns content.
+* `AuthorizationHeaderExtractor` will look in the `Authorization` header for a `Bearer` token.
+* `OAuth2Extractor` searches the places an OAuth2 token would be specified (per the spec): `Authorization` header and `access_token` argument
+* `PostExtractionFilter` wraps an `Extractor`, allowing you to process the content before it's parsed.  A simple example is stripping the `Bearer ` text from a header
+
+
+### RSA signing methods no longer accept `[]byte` keys
+
+Due to a [critical vulnerability](https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/), we've decided the convenience of accepting `[]byte` instead of `rsa.PublicKey` or `rsa.PrivateKey` isn't worth the risk of misuse.
+
+To replace this behavior, we've added two helper methods: `ParseRSAPrivateKeyFromPEM(key []byte) (*rsa.PrivateKey, error)` and `ParseRSAPublicKeyFromPEM(key []byte) (*rsa.PublicKey, error)`.  These are just simple helpers for unpacking PEM encoded PKCS1 and PKCS8 keys. If your keys are encoded any other way, all you need to do is convert them to the `crypto/rsa` package's types.
+
+```go 
+	func keyLookupFunc(*Token) (interface{}, error) {
+		// Don't forget to validate the alg is what you expect:
+		if _, ok := token.Method.(*jwt.SigningMethodRSA); !ok {
+			return nil, fmt.Errorf("Unexpected signing method: %v", token.Header["alg"])
+		}
+		
+		// Look up key 
+		key, err := lookupPublicKey(token.Header["kid"])
+		if err != nil {
+			return nil, err
+		}
+		
+		// Unpack key from PEM encoded PKCS8
+		return jwt.ParseRSAPublicKeyFromPEM(key)
+	}
+```
--- a/backend/vendor/github.com/dgrijalva/jwt-go/README.md
+++ b/backend/vendor/github.com/dgrijalva/jwt-go/README.md
@@ -0,0 +1,100 @@
+# jwt-go
+
+[![Build Status](https://travis-ci.org/dgrijalva/jwt-go.svg?branch=master)](https://travis-ci.org/dgrijalva/jwt-go)
+[![GoDoc](https://godoc.org/github.com/dgrijalva/jwt-go?status.svg)](https://godoc.org/github.com/dgrijalva/jwt-go)
+
+A [go](http://www.golang.org) (or 'golang' for search engine friendliness) implementation of [JSON Web Tokens](http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html)
+
+**NEW VERSION COMING:** There have been a lot of improvements suggested since the version 3.0.0 released in 2016. I'm working now on cutting two different releases: 3.2.0 will contain any non-breaking changes or enhancements. 4.0.0 will follow shortly which will include breaking changes. See the 4.0.0 milestone to get an idea of what's coming. If you have other ideas, or would like to participate in 4.0.0, now's the time. If you depend on this library and don't want to be interrupted, I recommend you use your dependency mangement tool to pin to version 3. 
+
+**SECURITY NOTICE:** Some older versions of Go have a security issue in the cryotp/elliptic. Recommendation is to upgrade to at least 1.8.3. See issue #216 for more detail.
+
+**SECURITY NOTICE:** It's important that you [validate the `alg` presented is what you expect](https://auth0.com/blog/2015/03/31/critical-vulnerabilities-in-json-web-token-libraries/). This library attempts to make it easy to do the right thing by requiring key types match the expected alg, but you should take the extra step to verify it in your usage.  See the examples provided.
+
+## What the heck is a JWT?
+
+JWT.io has [a great introduction](https://jwt.io/introduction) to JSON Web Tokens.
+
+In short, it's a signed JSON object that does something useful (for example, authentication).  It's commonly used for `Bearer` tokens in Oauth 2.  A token is made of three parts, separated by `.`'s.  The first two parts are JSON objects, that have been [base64url](http://tools.ietf.org/html/rfc4648) encoded.  The last part is the signature, encoded the same way.
+
+The first part is called the header.  It contains the necessary information for verifying the last part, the signature.  For example, which encryption method was used for signing and what key was used.
+
+The part in the middle is the interesting bit.  It's called the Claims and contains the actual stuff you care about.  Refer to [the RFC](http://self-issued.info/docs/draft-jones-json-web-token.html) for information about reserved keys and the proper way to add your own.
+
+## What's in the box?
+
+This library supports the parsing and verification as well as the generation and signing of JWTs.  Current supported signing algorithms are HMAC SHA, RSA, RSA-PSS, and ECDSA, though hooks are present for adding your own.
+
+## Examples
+
+See [the project documentation](https://godoc.org/github.com/dgrijalva/jwt-go) for examples of usage:
+
+* [Simple example of parsing and validating a token](https://godoc.org/github.com/dgrijalva/jwt-go#example-Parse--Hmac)
+* [Simple example of building and signing a token](https://godoc.org/github.com/dgrijalva/jwt-go#example-New--Hmac)
+* [Directory of Examples](https://godoc.org/github.com/dgrijalva/jwt-go#pkg-examples)
+
+## Extensions
+
+This library publishes all the necessary components for adding your own signing methods.  Simply implement the `SigningMethod` interface and register a factory method using `RegisterSigningMethod`.  
+
+Here's an example of an extension that integrates with the Google App Engine signing tools: https://github.com/someone1/gcp-jwt-go
+
+## Compliance
+
+This library was last reviewed to comply with [RTF 7519](http://www.rfc-editor.org/info/rfc7519) dated May 2015 with a few notable differences:
+
+* In order to protect against accidental use of [Unsecured JWTs](http://self-issued.info/docs/draft-ietf-oauth-json-web-token.html#UnsecuredJWT), tokens using `alg=none` will only be accepted if the constant `jwt.UnsafeAllowNoneSignatureType` is provided as the key.
+
+## Project Status & Versioning
+
+This library is considered production ready.  Feedback and feature requests are appreciated.  The API should be considered stable.  There should be very few backwards-incompatible changes outside of major version updates (and only with good reason).
+
+This project uses [Semantic Versioning 2.0.0](http://semver.org).  Accepted pull requests will land on `master`.  Periodically, versions will be tagged from `master`.  You can find all the releases on [the project releases page](https://github.com/dgrijalva/jwt-go/releases).
+
+While we try to make it obvious when we make breaking changes, there isn't a great mechanism for pushing announcements out to users.  You may want to use this alternative package include: `gopkg.in/dgrijalva/jwt-go.v3`.  It will do the right thing WRT semantic versioning.
+
+**BREAKING CHANGES:*** 
+* Version 3.0.0 includes _a lot_ of changes from the 2.x line, including a few that break the API.  We've tried to break as few things as possible, so there should just be a few type signature changes.  A full list of breaking changes is available in `VERSION_HISTORY.md`.  See `MIGRATION_GUIDE.md` for more information on updating your code.
+
+## Usage Tips
+
+### Signing vs Encryption
+
+A token is simply a JSON object that is signed by its author. this tells you exactly two things about the data:
+
+* The author of the token was in the possession of the signing secret
+* The data has not been modified since it was signed
+
+It's important to know that JWT does not provide encryption, which means anyone who has access to the token can read its contents. If you need to protect (encrypt) the data, there is a companion spec, `JWE`, that provides this functionality. JWE is currently outside the scope of this library.
+
+### Choosing a Signing Method
+
+There are several signing methods available, and you should probably take the time to learn about the various options before choosing one.  The principal design decision is most likely going to be symmetric vs asymmetric.
+
+Symmetric signing methods, such as HSA, use only a single secret. This is probably the simplest signing method to use since any `[]byte` can be used as a valid secret. They are also slightly computationally faster to use, though this rarely is enough to matter. Symmetric signing methods work the best when both producers and consumers of tokens are trusted, or even the same system. Since the same secret is used to both sign and validate tokens, you can't easily distribute the key for validation.
+
+Asymmetric signing methods, such as RSA, use different keys for signing and verifying tokens. This makes it possible to produce tokens with a private key, and allow any consumer to access the public key for verification.
+
+### Signing Methods and Key Types
+
+Each signing method expects a different object type for its signing keys. See the package documentation for details. Here are the most common ones:
+
+* The [HMAC signing method](https://godoc.org/github.com/dgrijalva/jwt-go#SigningMethodHMAC) (`HS256`,`HS384`,`HS512`) expect `[]byte` values for signing and validation
+* The [RSA signing method](https://godoc.org/github.com/dgrijalva/jwt-go#SigningMethodRSA) (`RS256`,`RS384`,`RS512`) expect `*rsa.PrivateKey` for signing and `*rsa.PublicKey` for validation
+* The [ECDSA signing method](https://godoc.org/github.com/dgrijalva/jwt-go#SigningMethodECDSA) (`ES256`,`ES384`,`ES512`) expect `*ecdsa.PrivateKey` for signing and `*ecdsa.PublicKey` for validation
+
+### JWT and OAuth
+
+It's worth mentioning that OAuth and JWT are not the same thing. A JWT token is simply a signed JSON object. It can be used anywhere such a thing is useful. There is some confusion, though, as JWT is the most common type of bearer token used in OAuth2 authentication.
+
+Without going too far down the rabbit hole, here's a description of the interaction of these technologies:
+
+* OAuth is a protocol for allowing an identity provider to be separate from the service a user is logging in to. For example, whenever you use Facebook to log into a different service (Yelp, Spotify, etc), you are using OAuth.
+* OAuth defines several options for passing around authentication data. One popular method is called a "bearer token". A bearer token is simply a string that _should_ only be held by an authenticated user. Thus, simply presenting this token proves your identity. You can probably derive from here why a JWT might make a good bearer token.
+* Because bearer tokens are used for authentication, it's important they're kept secret. This is why transactions that use bearer tokens typically happen over SSL.
+
+## More
+
+Documentation can be found [on godoc.org](http://godoc.org/github.com/dgrijalva/jwt-go).
+
+The command line utility included in this project (cmd/jwt) provides a straightforward example of token creation and parsing as well as a useful tool for debugging your own integration. You'll also find several implementation examples in the documentation.
--- a/backend/vendor/github.com/dgrijalva/jwt-go/VERSION_HISTORY.md
+++ b/backend/vendor/github.com/dgrijalva/jwt-go/VERSION_HISTORY.md
@@ -0,0 +1,118 @@
+## `jwt-go` Version History
+
+#### 3.2.0
+
+* Added method `ParseUnverified` to allow users to split up the tasks of parsing and validation
+* HMAC signing method returns `ErrInvalidKeyType` instead of `ErrInvalidKey` where appropriate
+* Added options to `request.ParseFromRequest`, which allows for an arbitrary list of modifiers to parsing behavior. Initial set include `WithClaims` and `WithParser`. Existing usage of this function will continue to work as before.
+* Deprecated `ParseFromRequestWithClaims` to simplify API in the future.
+
+#### 3.1.0
+
+* Improvements to `jwt` command line tool
+* Added `SkipClaimsValidation` option to `Parser`
+* Documentation updates
+
+#### 3.0.0
+
+* **Compatibility Breaking Changes**: See MIGRATION_GUIDE.md for tips on updating your code
+	* Dropped support for `[]byte` keys when using RSA signing methods.  This convenience feature could contribute to security vulnerabilities involving mismatched key types with signing methods.
+	* `ParseFromRequest` has been moved to `request` subpackage and usage has changed
+	* The `Claims` property on `Token` is now type `Claims` instead of `map[string]interface{}`.  The default value is type `MapClaims`, which is an alias to `map[string]interface{}`.  This makes it possible to use a custom type when decoding claims.
+* Other Additions and Changes
+	* Added `Claims` interface type to allow users to decode the claims into a custom type
+	* Added `ParseWithClaims`, which takes a third argument of type `Claims`.  Use this function instead of `Parse` if you have a custom type you'd like to decode into.
+	* Dramatically improved the functionality and flexibility of `ParseFromRequest`, which is now in the `request` subpackage
+	* Added `ParseFromRequestWithClaims` which is the `FromRequest` equivalent of `ParseWithClaims`
+	* Added new interface type `Extractor`, which is used for extracting JWT strings from http requests.  Used with `ParseFromRequest` and `ParseFromRequestWithClaims`.
+	* Added several new, more specific, validation errors to error type bitmask
+	* Moved examples from README to executable example files
+	* Signing method registry is now thread safe
+	* Added new property to `ValidationError`, which contains the raw error returned by calls made by parse/verify (such as those returned by keyfunc or json parser)
+
+#### 2.7.0
+
+This will likely be the last backwards compatible release before 3.0.0, excluding essential bug fixes.
+
+* Added new option `-show` to the `jwt` command that will just output the decoded token without verifying
+* Error text for expired tokens includes how long it's been expired
+* Fixed incorrect error returned from `ParseRSAPublicKeyFromPEM`
+* Documentation updates
+
+#### 2.6.0
+
+* Exposed inner error within ValidationError
+* Fixed validation errors when using UseJSONNumber flag
+* Added several unit tests
+
+#### 2.5.0
+
+* Added support for signing method none.  You shouldn't use this.  The API tries to make this clear.
+* Updated/fixed some documentation
+* Added more helpful error message when trying to parse tokens that begin with `BEARER `
+
+#### 2.4.0
+
+* Added new type, Parser, to allow for configuration of various parsing parameters
+	* You can now specify a list of valid signing methods.  Anything outside this set will be rejected.
+	* You can now opt to use the `json.Number` type instead of `float64` when parsing token JSON
+* Added support for [Travis CI](https://travis-ci.org/dgrijalva/jwt-go)
+* Fixed some bugs with ECDSA parsing
+
+#### 2.3.0
+
+* Added support for ECDSA signing methods
+* Added support for RSA PSS signing methods (requires go v1.4)
+
+#### 2.2.0
+
+* Gracefully handle a `nil` `Keyfunc` being passed to `Parse`.  Result will now be the parsed token and an error, instead of a panic.
+
+#### 2.1.0
+
+Backwards compatible API change that was missed in 2.0.0.
+
+* The `SignedString` method on `Token` now takes `interface{}` instead of `[]byte`
+
+#### 2.0.0
+
+There were two major reasons for breaking backwards compatibility with this update.  The first was a refactor required to expand the width of the RSA and HMAC-SHA signing implementations.  There will likely be no required code changes to support this change.
+
+The second update, while unfortunately requiring a small change in integration, is required to open up this library to other signing methods.  Not all keys used for all signing methods have a single standard on-disk representation.  Requiring `[]byte` as the type for all keys proved too limiting.  Additionally, this implementation allows for pre-parsed tokens to be reused, which might matter in an application that parses a high volume of tokens with a small set of keys.  Backwards compatibilty has been maintained for passing `[]byte` to the RSA signing methods, but they will also accept `*rsa.PublicKey` and `*rsa.PrivateKey`.
+
+It is likely the only integration change required here will be to change `func(t *jwt.Token) ([]byte, error)` to `func(t *jwt.Token) (interface{}, error)` when calling `Parse`.
+
+* **Compatibility Breaking Changes**
+	* `SigningMethodHS256` is now `*SigningMethodHMAC` instead of `type struct`
+	* `SigningMethodRS256` is now `*SigningMethodRSA` instead of `type struct`
+	* `KeyFunc` now returns `interface{}` instead of `[]byte`
+	* `SigningMethod.Sign` now takes `interface{}` instead of `[]byte` for the key
+	* `SigningMethod.Verify` now takes `interface{}` instead of `[]byte` for the key
+* Renamed type `SigningMethodHS256` to `SigningMethodHMAC`.  Specific sizes are now just instances of this type.
+    * Added public package global `SigningMethodHS256`
+    * Added public package global `SigningMethodHS384`
+    * Added public package global `SigningMethodHS512`
+* Renamed type `SigningMethodRS256` to `SigningMethodRSA`.  Specific sizes are now just instances of this type.
+    * Added public package global `SigningMethodRS256`
+    * Added public package global `SigningMethodRS384`
+    * Added public package global `SigningMethodRS512`
+* Moved sample private key for HMAC tests from an inline value to a file on disk.  Value is unchanged.
+* Refactored the RSA implementation to be easier to read
+* Exposed helper methods `ParseRSAPrivateKeyFromPEM` and `ParseRSAPublicKeyFromPEM`
+
+#### 1.0.2
+
+* Fixed bug in parsing public keys from certificates
+* Added more tests around the parsing of keys for RS256
+* Code refactoring in RS256 implementation.  No functional changes
+
+#### 1.0.1
+
+* Fixed panic if RS256 signing method was passed an invalid key
+
+#### 1.0.0
+
+* First versioned release
+* API stabilized
+* Supports creating, signing, parsing, and validating JWT tokens
+* Supports RS256 and HS256 signing methods
--- a/backend/vendor/github.com/dgrijalva/jwt-go/claims.go
+++ b/backend/vendor/github.com/dgrijalva/jwt-go/claims.go
@@ -0,0 +1,134 @@
+package jwt
+
+import (
+	"crypto/subtle"
+	"fmt"
+	"time"
+)
+
+// For a type to be a Claims object, it must just have a Valid method that determines
+// if the token is invalid for any supported reason
+type Claims interface {
+	Valid() error
+}
+
+// Structured version of Claims Section, as referenced at
+// https://tools.ietf.org/html/rfc7519#section-4.1
+// See examples for how to use this with your own claim types
+type StandardClaims struct {
+	Audience  string `json:"aud,omitempty"`
+	ExpiresAt int64  `json:"exp,omitempty"`
+	Id        string `json:"jti,omitempty"`
+	IssuedAt  int64  `json:"iat,omitempty"`
+	Issuer    string `json:"iss,omitempty"`
+	NotBefore int64  `json:"nbf,omitempty"`
+	Subject   string `json:"sub,omitempty"`
+}
+
+// Validates time based claims "exp, iat, nbf".
+// There is no accounting for clock skew.
+// As well, if any of the above claims are not in the token, it will still
+// be considered a valid claim.
+func (c StandardClaims) Valid() error {
+	vErr := new(ValidationError)
+	now := TimeFunc().Unix()
+
+	// The claims below are optional, by default, so if they are set to the
+	// default value in Go, let's not fail the verification for them.
+	if c.VerifyExpiresAt(now, false) == false {
+		delta := time.Unix(now, 0).Sub(time.Unix(c.ExpiresAt, 0))
+		vErr.Inner = fmt.Errorf("token is expired by %v", delta)
+		vErr.Errors |= ValidationErrorExpired
+	}
+
+	if c.VerifyIssuedAt(now, false) == false {
+		vErr.Inner = fmt.Errorf("Token used before issued")
+		vErr.Errors |= ValidationErrorIssuedAt
+	}
+
+	if c.VerifyNotBefore(now, false) == false {
+		vErr.Inner = fmt.Errorf("token is not valid yet")
+		vErr.Errors |= ValidationErrorNotValidYet
+	}
+
+	if vErr.valid() {
+		return nil
+	}
+
+	return vErr
+}
+
+// Compares the aud claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (c *StandardClaims) VerifyAudience(cmp string, req bool) bool {
+	return verifyAud(c.Audience, cmp, req)
+}
+
+// Compares the exp claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (c *StandardClaims) VerifyExpiresAt(cmp int64, req bool) bool {
+	return verifyExp(c.ExpiresAt, cmp, req)
+}
+
+// Compares the iat claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (c *StandardClaims) VerifyIssuedAt(cmp int64, req bool) bool {
+	return verifyIat(c.IssuedAt, cmp, req)
+}
+
+// Compares the iss claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (c *StandardClaims) VerifyIssuer(cmp string, req bool) bool {
+	return verifyIss(c.Issuer, cmp, req)
+}
+
+// Compares the nbf claim against cmp.
+// If required is false, this method will return true if the value matches or is unset
+func (c *StandardClaims) VerifyNotBefore(cmp int64, req bool) bool {
+	return verifyNbf(c.NotBefore, cmp, req)
+}
+
+// ----- helpers
+
+func verifyAud(aud string, cmp string, required bool) bool {
+	if aud == "" {
+		return !required
+	}
+	if subtle.ConstantTimeCompare([]byte(aud), []byte(cmp)) != 0 {
+		return true
+	} else {
+		return false
+	}
+}
+
+func verifyExp(exp int64, now int64, required bool) bool {
+	if exp == 0 {
+		return !required
+	}
+	return now <= exp
+}
+
+func verifyIat(iat int64, now int64, required bool) bool {
+	if iat == 0 {
+		return !required
+	}
+	return now >= iat
+}
+
+func verifyIss(iss string, cmp string, required bool) bool {
+	if iss == "" {
+		return !required
+	}
+	if subtle.ConstantTimeCompare([]byte(iss), []byte(cmp)) != 0 {
+		return true
+	} else {
+		return false
+	}
+}
+
+func verifyNbf(nbf int64, now int64, required bool) bool {
+	if nbf == 0 {
+		return !required
+	}
+	return now >= nbf
+}
--- a/backend/vendor/github.com/dgrijalva/jwt-go/doc.go
+++ b/backend/vendor/github.com/dgrijalva/jwt-go/doc.go
@@ -0,0 +1,4 @@
+// Package jwt is a Go implementation of JSON Web Tokens: http://self-issued.info/docs/draft-jones-json-web-token.html
+//
+// See README.md for more info.
+package jwt
--- a/backend/vendor/github.com/dgrijalva/jwt-go/ecdsa.go
+++ b/backend/vendor/github.com/dgrijalva/jwt-go/ecdsa.go
@@ -0,0 +1,148 @@
+package jwt
+
+import (
+	"crypto"
+	"crypto/ecdsa"
+	"crypto/rand"
+	"errors"
+	"math/big"
+)
+
+var (
+	// Sadly this is missing from crypto/ecdsa compared to crypto/rsa
+	ErrECDSAVerification = errors.New("crypto/ecdsa: verification error")
+)
+
+// Implements the ECDSA family of signing methods signing methods
+// Expects *ecdsa.PrivateKey for signing and *ecdsa.PublicKey for verification
+type SigningMethodECDSA struct {
+	Name      string
+	Hash      crypto.Hash
+	KeySize   int
+	CurveBits int
+}
+
+// Specific instances for EC256 and company
+var (
+	SigningMethodES256 *SigningMethodECDSA
+	SigningMethodES384 *SigningMethodECDSA
+	SigningMethodES512 *SigningMethodECDSA
+)
+
+func init() {
+	// ES256
+	SigningMethodES256 = &SigningMethodECDSA{"ES256", crypto.SHA256, 32, 256}
+	RegisterSigningMethod(SigningMethodES256.Alg(), func() SigningMethod {
+		return SigningMethodES256
+	})
+
+	// ES384
+	SigningMethodES384 = &SigningMethodECDSA{"ES384", crypto.SHA384, 48, 384}
+	RegisterSigningMethod(SigningMethodES384.Alg(), func() SigningMethod {
+		return SigningMethodES384
+	})
+
+	// ES512
+	SigningMethodES512 = &SigningMethodECDSA{"ES512", crypto.SHA512, 66, 521}
+	RegisterSigningMethod(SigningMethodES512.Alg(), func() SigningMethod {
+		return SigningMethodES512
+	})
+}
+
+func (m *SigningMethodECDSA) Alg() string {
+	return m.Name
+}
+
+// Implements the Verify method from SigningMethod
+// For this verify method, key must be an ecdsa.PublicKey struct
+func (m *SigningMethodECDSA) Verify(signingString, signature string, key interface{}) error {
+	var err error
+
+	// Decode the signature
+	var sig []byte
+	if sig, err = DecodeSegment(signature); err != nil {
+		return err
+	}
+
+	// Get the key
+	var ecdsaKey *ecdsa.PublicKey
+	switch k := key.(type) {
+	case *ecdsa.PublicKey:
+		ecdsaKey = k
+	default:
+		return ErrInvalidKeyType
+	}
+
+	if len(sig) != 2*m.KeySize {
+		return ErrECDSAVerification
+	}
+
+	r := big.NewInt(0).SetBytes(sig[:m.KeySize])
+	s := big.NewInt(0).SetBytes(sig[m.KeySize:])
+
+	// Create hasher
+	if !m.Hash.Available() {
+		return ErrHashUnavailable
+	}
+	hasher := m.Hash.New()
+	hasher.Write([]byte(signingString))
+
+	// Verify the signature
+	if verifystatus := ecdsa.Verify(ecdsaKey, hasher.Sum(nil), r, s); verifystatus == true {
+		return nil
+	} else {
+		return ErrECDSAVerification
+	}
+}
+
+// Implements the Sign method from SigningMethod
+// For this signing method, key must be an ecdsa.PrivateKey struct
+func (m *SigningMethodECDSA) Sign(signingString string, key interface{}) (string, error) {
+	// Get the key
+	var ecdsaKey *ecdsa.PrivateKey
+	switch k := key.(type) {
+	case *ecdsa.PrivateKey:
+		ecdsaKey = k
+	default:
+		return "", ErrInvalidKeyType
+	}
+
+	// Create the hasher
+	if !m.Hash.Available() {
+		return "", ErrHashUnavailable
+	}
+
+	hasher := m.Hash.New()
+	hasher.Write([]byte(signingString))
+
+	// Sign the string and return r, s
+	if r, s, err := ecdsa.Sign(rand.Reader, ecdsaKey, hasher.Sum(nil)); err == nil {
+		curveBits := ecdsaKey.Curve.Params().BitSize
+
+		if m.CurveBits != curveBits {
+			return "", ErrInvalidKey
+		}
+
+		keyBytes := curveBits / 8
+		if curveBits%8 > 0 {
+			keyBytes += 1
+		}
+
+		// We serialize the outpus (r and s) into big-endian byte arrays and pad
+		// them with zeros on the left to make sure the sizes work out. Both arrays
+		// must be keyBytes long, and the output must be 2*keyBytes long.
+		rBytes := r.Bytes()
+		rBytesPadded := make([]byte, keyBytes)
+		copy(rBytesPadded[keyBytes-len(rBytes):], rBytes)
+
+		sBytes := s.Bytes()
+		sBytesPadded := make([]byte, keyBytes)
+		copy(sBytesPadded[keyBytes-len(sBytes):], sBytes)
+
+		out := append(rBytesPadded, sBytesPadded...)
+
+		return EncodeSegment(out), nil
+	} else {
+		return "", err
+	}
+}
--- a/backend/vendor/github.com/dgrijalva/jwt-go/ecdsa_utils.go
+++ b/backend/vendor/github.com/dgrijalva/jwt-go/ecdsa_utils.go
@@ -0,0 +1,67 @@
+package jwt
+
+import (
+	"crypto/ecdsa"
+	"crypto/x509"
+	"encoding/pem"
+	"errors"
+)
+
+var (
+	ErrNotECPublicKey  = errors.New("Key is not a valid ECDSA public key")
+	ErrNotECPrivateKey = errors.New("Key is not a valid ECDSA private key")
+)
+
+// Parse PEM encoded Elliptic Curve Private Key Structure
+func ParseECPrivateKeyFromPEM(key []byte) (*ecdsa.PrivateKey, error) {
+	var err error
+
+	// Parse PEM block
+	var block *pem.Block
+	if block, _ = pem.Decode(key); block == nil {
+		return nil, ErrKeyMustBePEMEncoded
+	}
+
+	// Parse the key
+	var parsedKey interface{}
+	if parsedKey, err = x509.ParseECPrivateKey(block.Bytes); err != nil {
+		return nil, err
+	}
+
+	var pkey *ecdsa.PrivateKey
+	var ok bool
+	if pkey, ok = parsedKey.(*ecdsa.PrivateKey); !ok {
+		return nil, ErrNotECPrivateKey
+	}
+
+	return pkey, nil
+}
+
+// Parse PEM encoded PKCS1 or PKCS8 public key
+func ParseECPublicKeyFromPEM(key []byte) (*ecdsa.PublicKey, error) {
+	var err error
+
+	// Parse PEM block
+	var block *pem.Block
+	if block, _ = pem.Decode(key); block == nil {
+		return nil, ErrKeyMustBePEMEncoded
+	}
+
+	// Parse the key
+	var parsedKey interface{}
+	if parsedKey, err = x509.ParsePKIXPublicKey(block.Bytes); err != nil {
+		if cert, err := x509.ParseCertificate(block.Bytes); err == nil {
+			parsedKey = cert.PublicKey
+		} else {
+			return nil, err
+		}
+	}
+
+	var pkey *ecdsa.PublicKey
+	var ok bool
+	if pkey, ok = parsedKey.(*ecdsa.PublicKey); !ok {
+		return nil, ErrNotECPublicKey
+	}
+
+	return pkey, nil
+}
--- a/backend/vendor/github.com/dgrijalva/jwt-go/errors.go
+++ b/backend/vendor/github.com/dgrijalva/jwt-go/errors.go
@@ -0,0 +1,59 @@
+package jwt
+
+import (
+	"errors"
+)
+
+// Error constants
+var (
+	ErrInvalidKey      = errors.New("key is invalid")
+	ErrInvalidKeyType  = errors.New("key is of invalid type")
+	ErrHashUnavailable = errors.New("the requested hash function is unavailable")
+)
+
+// The errors that might occur when parsing and validating a token
+const (
+	ValidationErrorMalformed        uint32 = 1 << iota // Token is malformed
+	ValidationErrorUnverifiable                        // Token could not be verified because of signing problems
+	ValidationErrorSignatureInvalid                    // Signature validation failed
+
+	// Standard Claim validation errors
+	ValidationErrorAudience      // AUD validation failed
+	ValidationErrorExpired       // EXP validation failed
+	ValidationErrorIssuedAt      // IAT validation failed
+	ValidationErrorIssuer        // ISS validation failed
+	ValidationErrorNotValidYet   // NBF validation failed
+	ValidationErrorId            // JTI validation failed
+	ValidationErrorClaimsInvalid // Generic claims validation error
+)
+
+// Helper for constructing a ValidationError with a string error message
+func NewValidationError(errorText string, errorFlags uint32) *ValidationError {
+	return &ValidationError{
+		text:   errorText,
+		Errors: errorFlags,
+	}
+}
+
+// The error from Parse if token is not valid
+type ValidationError struct {
+	Inner  error  // stores the error returned by external dependencies, i.e.: KeyFunc
+	Errors uint32 // bitfield.  see ValidationError... constants
+	text   string // errors that do not have a valid error just have text
+}
+
+// Validation error is an error type
+func (e ValidationError) Error() string {
+	if e.Inner != nil {
+		return e.Inner.Error()
+	} else if e.text != "" {
+		return e.text
+	} else {
+		return "token is invalid"
+	}
+}
+
+// No errors
+func (e *ValidationError) valid() bool {
+	return e.Errors == 0
+}
--- a/backend/vendor/github.com/dgrijalva/jwt-go/hmac.go
+++ b/backend/vendor/github.com/dgrijalva/jwt-go/hmac.go
@@ -0,0 +1,95 @@
+package jwt
+
+import (
+	"crypto"
+	"crypto/hmac"
+	"errors"
+)
+
+// Implements the HMAC-SHA family of signing methods signing methods
+// Expects key type of []byte for both signing and validation
+type SigningMethodHMAC struct {
+	Name string
+	Hash crypto.Hash
+}
+
+// Specific instances for HS256 and company
+var (
+	SigningMethodHS256  *SigningMethodHMAC
+	SigningMethodHS384  *SigningMethodHMAC
+	SigningMethodHS512  *SigningMethodHMAC
+	ErrSignatureInvalid = errors.New("signature is invalid")
+)
+
+func init() {
+	// HS256
+	SigningMethodHS256 = &SigningMethodHMAC{"HS256", crypto.SHA256}
+	RegisterSigningMethod(SigningMethodHS256.Alg(), func() SigningMethod {
+		return SigningMethodHS256
+	})
+
+	// HS384
+	SigningMethodHS384 = &SigningMethodHMAC{"HS384", crypto.SHA384}
+	RegisterSigningMethod(SigningMethodHS384.Alg(), func() SigningMethod {
+		return SigningMethodHS384
+	})
+
+	// HS512
+	SigningMethodHS512 = &SigningMethodHMAC{"HS512", crypto.SHA512}
+	RegisterSigningMethod(SigningMethodHS512.Alg(), func() SigningMethod {
+		return SigningMethodHS512
+	})
+}
+
+func (m *SigningMethodHMAC) Alg() string {
+	return m.Name
+}
+
+// Verify the signature of HSXXX tokens.  Returns nil if the signature is valid.
+func (m *SigningMethodHMAC) Verify(signingString, signature string, key interface{}) error {
+	// Verify the key is the right type
+	keyBytes, ok := key.([]byte)
+	if !ok {
+		return ErrInvalidKeyType
+	}
+
+	// Decode signature, for comparison
+	sig, err := DecodeSegment(signature)
+	if err != nil {
+		return err
+	}
+
+	// Can we use the specified hashing method?
+	if !m.Hash.Available() {
+		return ErrHashUnavailable
+	}
+
+	// This signing method is symmetric, so we validate the signature
+	// by reproducing the signature from the signing string and key, then
+	// comparing that against the provided signature.
+	hasher := hmac.New(m.Hash.New, keyBytes)
+	hasher.Write([]byte(signingString))
+	if !hmac.Equal(sig, hasher.Sum(nil)) {
+		return ErrSignatureInvalid
+	}
+
+	// No validation errors.  Signature is good.
+	return nil
+}
+
+// Implements the Sign method from SigningMethod for this signing method.
+// Key must be []byte
+func (m *SigningMethodHMAC) Sign(signingString string, key interface{}) (string, error) {
+	if keyBytes, ok := key.([]byte); ok {
+		if !m.Hash.Available() {
+			return "", ErrHashUnavailable
+		}
+
+		hasher := hmac.New(m.Hash.New, keyBytes)
+		hasher.Write([]byte(signingString))
+
+		return EncodeSegment(hasher.Sum(nil)), nil
+	}
+
+	return "", ErrInvalidKeyType
+}
--- a/Show More
+++ b/Show More