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": "******", "password": "******"} ) 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 } }