func main() {

	config := a.NewConfig("config.gcfg")
	echo := echo.New()
	s := slack.New(config.Slack.Token)

	var session *r.Session

	session, err := r.Connect(r.ConnectOpts{
		Address:  fmt.Sprint(config.Database.URL, ":", config.Database.Port),
		Database: config.Database.Name,
		MaxIdle:  10,
		MaxOpen:  10,
	})
	if err != nil {
		log.Fatalln(err.Error())
	}
	session.SetMaxOpenConns(5)

	r.DBCreate(config.Database.Name).Exec(session)
	if err != nil {
		log.Println(err)
	}

	_, err = r.DB(config.Database.Name).TableCreate("quotes").RunWrite(session)
	if err != nil {
		fmt.Print(err)
	}
	_, err = r.DB(config.Database.Name).TableCreate("activities").RunWrite(session)
	if err != nil {
		fmt.Print(err)
	}

	// Middleware
	echo.Use(mw.Logger())
	echo.Use(mw.Recover())

	appcontext := &a.AppContext{
		Slack:  s,
		Config: config,
		Storage: &storage.Storage{
			Name:    "quotes",
			URL:     "192.168.10.10",
			Session: session,
		},
	}

	go appcontext.Monitor()

	//Routes
	a.Route(echo, appcontext)

	addr := fmt.Sprintf(":%d", config.App.Port)
	log.Printf("Starting server on: %s", addr)
	echo.Run(addr)
}

func main() {

	// Load config file
	config := Config{}
	var data, err = ioutil.ReadFile("config.yml")
	err = yaml.Unmarshal([]byte(data), &config)
	if err != nil {
		log.Fatalf("error: %v", err)
	}

	// Establish connection to DB
	var session *r.Session
	session, err = r.Connect(r.ConnectOpts{
		Address: config.DatabaseURI,
	})
	if err != nil {
		log.Fatalln(err.Error())
	}

	bootstrapDB(session, config)

	defer session.Close()

	log.Println("Connected")

	// Instantiate DAOs
	userDAO := UserDAO{DAO{Session: session}}
	postDAO := PostDAO{DAO{Session: session}}
	sessionDAO := SessionDAO{DAO{Session: session}}

	// Instantiate Controllers
	apiController := APIController{
		Controller{Session: session},
		userDAO,
		postDAO,
		sessionDAO,
	}

	goji.Get("/", apiController.Index)
	goji.Post("/post", apiController.CreatePost)
	goji.Get("/post/:id", apiController.GetPost)

	goji.Serve()

}

func seedRethinkdbChecks(s *r.Session) error {
	r.DB("alerts").TableCreate("checks").RunWrite(s)

	data := []*Check{
		&Check{
			Id:          "elasticsearch-es_heap",
			Type:        "elasticsearch",
			Name:        "es_heap",
			Level:       1,
			Title:       "Elasticsearch Heap",
			Description: "total heap usage by an elasticsearch node",
		},
		&Check{
			Id:          "elasticsearch-es_cluster_status",
			Type:        "elasticsearch",
			Name:        "es_heap",
			Level:       1,
			Title:       "Elasticsearch Cluster Status",
			Description: "cluster status (green/yello/red)",
		},
		&Check{
			Id:          "redis-role",
			Type:        "redis",
			Name:        "redis_role",
			Level:       1,
			Title:       "Redis Role",
			Description: "role of redis server (master/slave)",
		},
	}

	s.Use("alerts")
	for _, check := range data {
		r.Table("checks").Insert(check).RunWrite(s)
	}
	r.Table("checks").IndexCreateFunc("type_name", func(row r.Term) interface{} {
		return []interface{}{row.Field("type"), row.Field("name")}
	}).RunWrite(s)
	return nil
}

func initDb() {
	var session *r.Session

	session, err := r.Connect(r.ConnectOpts{
		Address: "localhost:28015",
	})
	if err != nil {
		log.Fatalln(err.Error())
	}

	session.SetMaxOpenConns(5)

	r.TableDrop("cars").Run(session)

	resp, err := r.TableCreate("cars").RunWrite(session)
	if err != nil {
		log.Println(err)
	}

	fmt.Printf("%d table created\n", resp.TablesCreated)

	s = session
}

//killSession disconnects from the database
func killSession(session *r.Session) {
	session.Close()
}

	"testing"

	"github.com/StephanDollberg/go-json-rest-middleware-jwt"
	"github.com/ant0ine/go-json-rest/rest"
	"github.com/ant0ine/go-json-rest/rest/test"
	r "github.com/dancannon/gorethink"
	. "github.com/onsi/ginkgo"
	. "github.com/onsi/gomega"
)

const database = "travelPlanningTest"

var (
	Response         *httptest.ResponseRecorder
	Request          *http.Request
	testConn         *r.Session
	tst              *testing.T
	loginCredentials = map[string]string{"username": "admin", "password": "admin"}
)

func TestTravelPlanning(t *testing.T) {
	RegisterFailHandler(Fail)
	RunSpecs(t, "TravelPlanning Suite")
}

var _ = BeforeSuite(func() {
	testConn = NewDBSession(database)
})

var _ = AfterSuite(func() {
	_, err := r.DBDrop(database).RunWrite(testConn)

func (bmo *BMO) Compute(input *os.File) {

	var err error
	var cur *r.Cursor
	var session *r.Session

	// set up database connection pool
	session, err = r.Connect(r.ConnectOpts{
		Addresses:     bmo.nodes,
		Database:      bmo.database,
		DiscoverHosts: true,
	})
	session.SetMaxOpenConns(POOL_SIZE)
	if err != nil {
		log.Fatalln(err)
	}
	// ensure table is present
	var tableNames []string
	cur, err = r.DB(bmo.database).TableList().Run(session)
	if err != nil {
		log.Fatalln(err)
	}
	cur.All(&tableNames)
	set := make(map[string]bool)
	for _, v := range tableNames {
		set[v] = true
	}
	if !set[bmo.table] {
		log.Println("Creating table ", bmo.table)
		_, err = r.DB(bmo.database).TableCreate(bmo.table).RunWrite(session)
		if err != nil {
			log.Fatalln("Error creating table: ", err)
			os.Exit(1)
		}
	}

	// deliver the messages
	decoder := json.NewDecoder(input)
	ms := make([]Message, INSERT_BATCH_SIZE)
	var m *Message
	var i uint64
	var ignoreLast bool

	pool, _ := tunny.CreatePoolGeneric(POOL_SIZE).Open()
	defer pool.Close()

	table := r.Table(bmo.table)
	insertOptions := r.InsertOpts{Durability: "soft"}

	insert := func() {
		j := i
		if !ignoreLast {
			j += 1
		}
		_, err = table.Insert(ms[:j], insertOptions).RunWrite(session)
		if err != nil {
			log.Fatal(err)
			os.Exit(1)
		}
	}

	for {
		i = bmo.seq % INSERT_BATCH_SIZE
		m = &ms[i]
		err = decoder.Decode(&m)

		switch {
		case err == io.EOF:
			ignoreLast = true
			pool.SendWork(insert)
			return
		case err != nil:
			ignoreLast = true
			pool.SendWork(insert)
			log.Fatal("Can't parse json input, \"", err, "\". Object #", bmo.seq, ", after ", m)
			os.Exit(1)
		default:
			if i+1 == INSERT_BATCH_SIZE {
				ignoreLast = false
				pool.SendWork(insert)
			}
		}

		bmo.seq += 1
	}
}