func NewManager(addr string, database string, authKey string, version string, disableUsageInfo bool) (*Manager, error) { session, err := r.Connect(r.ConnectOpts{ Address: addr, Database: database, AuthKey: authKey, MaxIdle: 10, IdleTimeout: time.Second * 30, }) if err != nil { return nil, err } logger.Info("checking database") r.DbCreate(database).Run(session) m := &Manager{ address: addr, database: database, authKey: authKey, session: session, authenticator: &shipyard.Authenticator{}, store: store, StoreKey: storeKey, version: version, disableUsageInfo: disableUsageInfo, } m.initdb() m.init() return m, nil }
func (suite *UserStoreSuite) SetupSuite() { store, err := newTestUserStore() if err != nil { panic(err) } suite.store = store // create necessary DB, table, indices _, err = r.DbCreate("test").Run(suite.store.conn) if err != nil { panic(err) } _, err = r.Db("test").TableCreate("users").Run(suite.store.conn) if err != nil { panic(err) } _, err = r.Db("test").Table("users").IndexCreate("email").Run(suite.store.conn) if err != nil { panic(err) } suite.user = NewUser("*****@*****.**", "password") _, err = r.Db("test").Table("users").Insert(suite.user).RunWrite(suite.store.conn) if err != nil { panic(err) } }
func InitDB() *rethink.Session { session, err := rethink.Connect(map[string]interface{}{ "address": "localhost:8080", //os.Getenv("RETHINKDB_URL"), "database": "test", "maxIdle": 10, "idleTimeout": time.Second * 10, }) if err != nil { log.Println(err) } err = rethink.DbCreate("test").Exec(session) if err != nil { log.Println(err) } _, err = rethink.Db("test").TableCreate("articles").RunWrite(session) if err != nil { log.Println(err) } return session }
func main() { log.SetFlags(log.LstdFlags | log.Lshortfile) flag.Parse() // Connect to RethinkDB var err error session, err = r.Connect(r.ConnectOpts{ Address: *rethinkAddress, }) if err != nil { log.Fatal(err) } // Create the database and tables r.DbCreate(*rethinkName).Exec(session) r.Db(*rethinkName).TableCreate("invites").Exec(session) r.Db(*rethinkName).Table("invites").IndexCreate("email").Exec(session) r.Db(*rethinkName).Table("invites").IndexCreate("name").Exec(session) // Add a CORS middleware goji.Use(cors.New(cors.Options{ AllowCredentials: true, }).Handler) // Add routes to goji goji.Get("/", index) goji.Post("/check", check) goji.Post("/free", free) goji.Post("/create", create) // Start the server goji.Serve() }
func createDatabase(database string, debug bool) { // create database _, err := r.DbCreate(database).Run(session) if err != nil { if debug { log.Println(err.Error()) } } }
func dbinit() *r.Session { session, err := r.Connect(r.ConnectOpts{ Address: "localhost:28015", Database: "goShop", MaxIdle: 10, IdleTimeout: time.Second * 10, }) if err != nil { log.Println(err) } err = r.DbCreate("goShop").Exec(session) if err != nil { log.Println(err) } _, err = r.Db("goShop").TableCreate("staff").RunWrite(session) if err != nil { log.Println(err) } newAdmin := adminRegister{ Login: "******", Password: "******", } _, err = r.Db("goShop").Table("staff").Insert(newAdmin).RunWrite(session) if err != nil { log.Println(err) } _, err = r.Db("goShop").TableCreate("clients").RunWrite(session) if err != nil { log.Println(err) } _, err = r.Db("goShop").TableCreate("items").RunWrite(session) if err != nil { log.Println(err) } _, err = r.Db("goShop").TableCreate("orders").RunWrite(session) if err != nil { log.Println(err) } _, err = r.Db("goShop").TableCreate("options").RunWrite(session) if err != nil { log.Println(err) } return session }
func main() { flag.Parse() log = logrus.New() if *logFormatterType == "text" { log.Formatter = &logrus.TextFormatter{ ForceColors: *logForceColors, } } else if *logFormatterType == "json" { log.Formatter = &logrus.JSONFormatter{} } log.Level = logrus.DebugLevel if *enableHub || *enableSender { var err error session, err = r.Connect(r.ConnectOpts{ Address: *rethinkdbAddress, }) if err != nil { log.WithField("error", err.Error()).Fatal("Unable to connect to RethinkDB") } r.DbCreate(*rethinkdbDatabase).Exec(session) r.Db(*rethinkdbDatabase).TableCreate("templates").Exec(session) r.Db(*rethinkdbDatabase).Table("templates").IndexCreate("name").Exec(session) r.Db(*rethinkdbDatabase).Table("templates").IndexCreate("version").Exec(session) r.Db(*rethinkdbDatabase).TableCreate("hub_state").Exec(session) r.Db(*rethinkdbDatabase).Table("hub_state").IndexCreate("time").Exec(session) } up := strings.Split(*usernames, ",") pp := strings.Split(*passwords, ",") if len(up) != len(pp) { log.Fatal("length of usernames and passwords is different") } if *enableSender { go initTemplates() for i, username := range up { go initSender(username, pp[i]) } } if *enableHub { change := make(chan struct{}) go initChurner(change) go initHub(change) } select {} }
func InitDatabase(s *r.Session, databaseName string) error { exists, err := ListContains(s, r.DbList(), databaseName) if err != nil { return err } if !exists { err := r.DbCreate(databaseName).Exec(s) if err != nil { return err } } return nil }
func init() { var err error session, err = r.Connect(r.ConnectOpts{ Address: "localhost:28015", Database: "harbor", MaxIdle: 40, MaxOpen: 40, }) if err != nil { log.Fatalln(err.Error()) } r.DbCreate("harbor").RunWrite(session) r.Db("harbor").TableCreate("users").Run(session) }
// Create/Setup all relevant tables in the database func (db *RethinkDBAdapter) Setup() *CASServerError { // Setup the Database _, err := r. DbCreate(db.dbName). Run(db.session) if err != nil { casError := &FailedToSetupDatabaseError casError.err = &err return casError } // Setup tables db.SetupServicesTable() db.SetupTicketsTable() db.SetupUsersTable() db.SetupApiKeysTable() return nil }
func initDb(dbSession *r.Session) error { // log.Println("initDb") _, database := getDbConf() log.Println("Database name ", database) _, err := r.DbCreate(database).Run(dbSession) if err != nil { // log.Println(err) } _, err = r.Db(database).TableCreate("accounts").Run(dbSession) if err != nil { // log.Println(err) } _, err = r.Db(database).TableCreate("transactions").Run(dbSession) if err != nil { // log.Println(err) } return nil }
func Setup() error { if err := r.DbCreate(TestDatabase).Exec(rethinkSession()); err != nil { return err } return r.Db(TestDatabase).TableCreate(TestTable).Exec(rethinkSession()) }
func main() { flag.Parse() // Initialize a new logger log = logrus.New() if *logFormatterType == "text" { log.Formatter = &logrus.TextFormatter{ ForceColors: *forceColors, } } else if *logFormatterType == "json" { log.Formatter = &logrus.JSONFormatter{} } log.Level = logrus.DebugLevel // Parse kiri addresses ka := strings.Split(*kiriAddresses, ",") // Set up kiri agent for discovery kd := kiri.New(ka) // Add stores to kd for i, store := range strings.Split(*kiriDiscoveryStores, ";") { parts := strings.Split(store, ",") if len(parts) != 2 { log.Fatalf("Invalid parts count in kiri_discovery_stores#%d", i) } var kind kiri.Format switch parts[0] { case "default": kind = kiri.Default case "puro": kind = kiri.Puro default: log.Fatalf("Invalid kind of store in kiri_discovery_stores#%d", i) } kd.Store(kind, parts[1]) } // Connect to RethinkDB var session *r.Session err := kd.Discover(*kiriDiscoveryRethinkDB, nil, kiri.DiscoverFunc(func(service *kiri.Service) error { var err error session, err = r.Connect(r.ConnectOpts{ Address: service.Address, }) if err != nil { log.Print(err) } return err })) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to connect to RethinkDB") } // Prepare database's structure r.DbCreate(*rethinkdbDatabase).Exec(session) r.Db(*rethinkdbDatabase).TableCreate("jobs").Exec(session) // Connect to nsq var producer *nsq.Producer err = kd.Discover(*kiriDiscoveryNSQd, nil, kiri.DiscoverFunc(func(service *kiri.Service) error { producer, err = nsq.NewProducer(service.Address, nsq.NewConfig()) if err != nil { log.Error(err) return err } err = producer.Ping() if err != nil { log.Error(err) return err } return nil })) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to connect to NSQd") } // Fetch the jobs cursor, err := r.Db(*rethinkdbDatabase).Table("jobs").Run(session) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to fetch jobs from RethinkDB") } var jobs []*Job if err := cursor.All(&jobs); err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to fetch jobs from RethinkDB") } // Create a new cron runner runner := cron.New() for _, job := range jobs { id, err := runner.AddJob(job.When, job) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to queue a job") } mapping[job.ID] = id } log.Print("Starting the runner") runner.Start() log.Print("Starting the change watcher") // Watch for changes cursor, err = r.Db(*rethinkdbDatabase).Table("jobs").Changes().Run(session) var change struct { NewValue *Job `gorethink:"new_val"` OldValue *Job `gorethink:"old_val"` } for cursor.Next(&change) { if change.NewValue == nil { // Remove a job if id, ok := mapping[change.OldValue.ID]; ok { runner.Remove(id) } } else if change.OldValue == nil { // Create a new job id, err := runner.AddJob(change.NewValue.When, change.NewValue) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to queue a job") } mapping[change.NewValue.ID] = id } else { // Recreate a job if id, ok := mapping[change.OldValue.ID]; ok { runner.Remove(id) } // Create a new job id, err := runner.AddJob(change.NewValue.When, change.NewValue) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to queue a job") } mapping[change.NewValue.ID] = id } } }
func main() { // Parse the flags flag.Parse() // Initialize a new logger log := logrus.New() if *logFormatterType == "text" { log.Formatter = &logrus.TextFormatter{ ForceColors: *forceColors, } } else if *logFormatterType == "json" { log.Formatter = &logrus.JSONFormatter{} } log.Level = logrus.DebugLevel // Parse kiri addresses ka := strings.Split(*kiriAddresses, ",") // Set up kiri agent for discovery kd := kiri.New(ka) // Add stores to kd for i, store := range strings.Split(*kiriDiscoveryStores, ";") { parts := strings.Split(store, ",") if len(parts) != 2 { log.Fatalf("Invalid parts count in kiri_discovery_stores#%d", i) } var kind kiri.Format switch parts[0] { case "default": kind = kiri.Default case "puro": kind = kiri.Puro default: log.Fatalf("Invalid kind of store in kiri_discovery_stores#%d", i) } kd.Store(kind, parts[1]) } // Connect to RethinkDB var session *r.Session err := kd.Discover(*kiriDiscoveryRethinkDB, nil, kiri.DiscoverFunc(func(service *kiri.Service) error { var err error session, err = r.Connect(r.ConnectOpts{ Address: service.Address, }) if err != nil { log.Print(err) } return err })) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to connect to RethinkDB") } // Create the database and a scripts table r.DbCreate(*rethinkdbDatabase).Exec(session) r.Db(*rethinkdbDatabase).TableCreate("scripts").Exec(session) // Fetch the scripts cursor, err := r.Db(*rethinkdbDatabase).Table("scripts").Run(session) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to fetch scripts from RethinkDB") } var scripts []*shared.Script if err := cursor.All(&scripts); err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to fetch scripts from RethinkDB") } // Load them for _, script := range scripts { if script.Interpreter == "js" { tasks[script.ID] = &JSTask{ ID: script.ID, Source: script.Source, } } /* else if script.Interpreter == "lua" { tasks[script.ID] = &LuaTask{ ID: script.ID, Source: script.Source, } }*/ } // Queue for jobs hostname, err := os.Hostname() if err != nil { log.WithFields(logrus.Fields{ "error": err, }).Fatal("Unable to get the hostname") } // Create a new consumer consumer, err := nsq.NewConsumer("jobs", hostname, nsq.NewConfig()) if err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to create a new consumer") } consumer.AddConcurrentHandlers(nsq.HandlerFunc(func(m *nsq.Message) error { // Decode the job var job *shared.Job if err := json.Unmarshal(m.Body, &job); err != nil { return err } // Ensure that we have such job if task, ok := tasks[job.Name]; ok { // Run it if err := task.Run(job); err != nil { m.Requeue(-1) return err } m.Finish() return nil } // We failed. m.Requeue(-1) return nil }), runtime.GOMAXPROCS(0)) if err = kd.Discover(*kiriDiscoveryNSQLookupd, nil, kiri.DiscoverFunc(func(service *kiri.Service) error { return consumer.ConnectToNSQLookupd(service.Address) })); err != nil { log.WithFields(logrus.Fields{ "error": err.Error(), }).Fatal("Unable to connect to the lookupd") } log.Print("Loaded all scripts.") log.Print("Starting the watcher.") // Watch for changes cursor, err = r.Db(*rethinkdbDatabase).Table("scripts").Changes().Run(session) var change struct { NewValue *shared.Script `gorethink:"new_val"` OldValue *shared.Script `gorethink:"old_val"` } for cursor.Next(&change) { if change.NewValue == nil { // Remove a job if _, ok := tasks[change.OldValue.ID]; ok { delete(tasks, change.OldValue.ID) } } else if change.OldValue == nil { if change.NewValue.Interpreter == "js" { tasks[change.NewValue.ID] = &JSTask{ ID: change.NewValue.ID, Source: change.NewValue.Source, } } /* else if change.NewValue.Interpreter == "lua" { tasks[change.NewValue.ID] = &LuaTask{ ID: change.NewValue.ID, Source: change.NewValue.Source, } }*/ } else { if _, ok := tasks[change.OldValue.ID]; ok { delete(tasks, change.OldValue.ID) } if change.NewValue.Interpreter == "js" { tasks[change.NewValue.ID] = &JSTask{ ID: change.NewValue.ID, Source: change.NewValue.Source, } } /* else if change.NewValue.Interpreter == "lua" { tasks[change.NewValue.ID] = &LuaTask{ ID: change.NewValue.ID, Source: change.NewValue.Source, } }*/ } } }
// Setup configures the RethinkDB server func Setup(opts r.ConnectOpts) error { // Initialize a new setup connection ss, err := r.Connect(opts) if err != nil { return err } // Create databases for _, d := range databaseNames { r.DbCreate(d).Exec(ss) r.Db(d).TableCreate("accounts").Exec(ss) r.Db(d).Table("accounts").IndexCreate("name").Exec(ss) r.Db(d).Table("accounts").IndexCreate("date_created").Exec(ss) r.Db(d).Table("accounts").IndexCreate("date_modified").Exec(ss) r.Db(d).Table("accounts").IndexCreate("alt_email").Exec(ss) r.Db(d).Table("accounts").IndexCreate("type").Exec(ss) r.Db(d).Table("accounts").IndexCreate("status").Exec(ss) r.Db(d).TableCreate("addresses").Exec(ss) r.Db(d).Table("addresses").IndexCreate("owner").Exec(ss) r.Db(d).Table("addresses").IndexCreate("date_created").Exec(ss) r.Db(d).Table("addresses").IndexCreate("date_modified").Exec(ss) r.Db(d).TableCreate("contacts").Exec(ss) r.Db(d).Table("contacts").IndexCreate("owner").Exec(ss) r.Db(d).Table("contacts").IndexCreate("name").Exec(ss) r.Db(d).Table("contacts").IndexCreate("date_created").Exec(ss) r.Db(d).Table("contacts").IndexCreate("date_modified").Exec(ss) r.Db(d).TableCreate("emails").Exec(ss) r.Db(d).Table("emails").IndexCreate("owner").Exec(ss) r.Db(d).Table("emails").IndexCreate("date_created").Exec(ss) r.Db(d).Table("emails").IndexCreate("date_modified").Exec(ss) r.Db(d).Table("emails").IndexCreate("thread").Exec(ss) r.Db(d).Table("emails").IndexCreate("kind").Exec(ss) r.Db(d).Table("emails").IndexCreate("from").Exec(ss) r.Db(d).Table("emails").IndexCreate("message_id").Exec(ss) r.Db(d).Table("emails").IndexCreate("to", r.IndexCreateOpts{Multi: true}).Exec(ss) r.Db(d).Table("emails").IndexCreate("cc", r.IndexCreateOpts{Multi: true}).Exec(ss) r.Db(d).Table("emails").IndexCreate("bcc", r.IndexCreateOpts{Multi: true}).Exec(ss) r.Db(d).Table("emails").IndexCreateFunc("messageIDOwner", func(row r.Term) interface{} { return []interface{}{ row.Field("message_id"), row.Field("owner"), } }).Exec(ss) r.Db(d).Table("emails").IndexCreateFunc("threadStatus", func(row r.Term) interface{} { return []interface{}{ row.Field("thread"), row.Field("status"), } }).Exec(ss) r.Db(d).TableCreate("files").Exec(ss) r.Db(d).Table("files").IndexCreate("owner").Exec(ss) r.Db(d).Table("files").IndexCreate("name").Exec(ss) r.Db(d).Table("files").IndexCreate("date_created").Exec(ss) r.Db(d).Table("files").IndexCreate("date_modified").Exec(ss) r.Db(d).TableCreate("keys").Exec(ss) r.Db(d).Table("keys").IndexCreate("owner").Exec(ss) r.Db(d).Table("keys").IndexCreate("date_created").Exec(ss) r.Db(d).Table("keys").IndexCreate("date_modified").Exec(ss) r.Db(d).Table("keys").IndexCreate("key_id").Exec(ss) r.Db(d).TableCreate("labels").Exec(ss) r.Db(d).Table("labels").IndexCreate("name").Exec(ss) r.Db(d).Table("labels").IndexCreate("builtin").Exec(ss) r.Db(d).Table("labels").IndexCreate("owner").Exec(ss) r.Db(d).Table("labels").IndexCreateFunc("nameOwnerBuiltin", func(row r.Term) interface{} { return []interface{}{ row.Field("name"), row.Field("owner"), row.Field("builtin"), } }).Exec(ss) r.Db(d).TableCreate("threads").Exec(ss) r.Db(d).Table("threads").IndexCreate("name").Exec(ss) r.Db(d).Table("threads").IndexCreate("owner").Exec(ss) r.Db(d).Table("threads").IndexCreate("date_created").Exec(ss) r.Db(d).Table("threads").IndexCreate("date_modified").Exec(ss) r.Db(d).Table("threads").IndexCreate("emails", r.IndexCreateOpts{Multi: true}).Exec(ss) r.Db(d).Table("threads").IndexCreate("labels", r.IndexCreateOpts{Multi: true}).Exec(ss) r.Db(d).Table("threads").IndexCreate("members", r.IndexCreateOpts{Multi: true}).Exec(ss) r.Db(d).Table("threads").IndexCreate("subject_hash").Exec(ss) r.Db(d).Table("threads").IndexCreate("secure").Exec(ss) r.Db(d).Table("threads").IndexCreateFunc("subjectOwner", func(row r.Term) interface{} { return []interface{}{ row.Field("subject_hash"), row.Field("owner"), } }).Exec(ss) r.Db(d).TableCreate("tokens").Exec(ss) r.Db(d).Table("tokens").IndexCreate("name").Exec(ss) r.Db(d).Table("tokens").IndexCreate("owner").Exec(ss) r.Db(d).Table("tokens").IndexCreate("date_created").Exec(ss) r.Db(d).Table("tokens").IndexCreate("date_modified").Exec(ss) r.Db(d).Table("tokens").IndexCreate("type").Exec(ss) r.Db(d).Table("tokens").IndexCreate("expiry_date").Exec(ss) r.Db(d).TableCreate("webhooks").Exec(ss) r.Db(d).Table("webhooks").IndexCreate("target").Exec(ss) r.Db(d).Table("webhooks").IndexCreate("type").Exec(ss) r.Db(d).Table("webhooks").IndexCreateFunc("targetType", func(row r.Term) interface{} { return []interface{}{ row.Field("target"), row.Field("type"), } }).Exec(ss) } return ss.Close() }