func (items RDBItems) watch(ctx context.Context, sess *r.Session, lock sync.RWMutex, table r.Term) {
go pkg.Retry(time.Second*15, time.Minute, func() error {
changes, err := table.Changes().Run(sess)
if err != nil {
pkg.LogError(errors.New(err))
return errors.New(err)
}
defer changes.Close()
var update = map[string]*RdbSchema{}
for changes.Next(&update) {
newVal := update["new_val"]
oldVal := update["old_val"]
lock.Lock()
if newVal == nil && oldVal != nil {
delete(items, oldVal.ID)
} else if newVal != nil && oldVal != nil {
delete(items, oldVal.ID)
items[newVal.ID] = newVal
} else {
items[newVal.ID] = newVal
}
lock.Unlock()
}
if changes.Err() != nil {
err = errors.New(changes.Err())
pkg.LogError(err)
return err
}
return nil
})
}
func (m *RethinkManager) Watch(ctx context.Context) {
go pkg.Retry(time.Second*15, time.Minute, func() error {
clients, err := m.Table.Changes().Run(m.Session)
if err != nil {
return errors.New(err)
}
defer clients.Close()
var update map[string]*fosite.DefaultClient
for clients.Next(&update) {
newVal := update["new_val"]
oldVal := update["old_val"]
m.Lock()
if newVal == nil && oldVal != nil {
delete(m.Clients, oldVal.GetID())
} else if newVal != nil && oldVal != nil {
delete(m.Clients, oldVal.GetID())
m.Clients[newVal.GetID()] = newVal
} else {
m.Clients[newVal.GetID()] = newVal
}
m.Unlock()
}
if clients.Err() != nil {
err = errors.New(clients.Err())
pkg.LogError(err)
return err
}
return nil
})
}
func (m *RethinkManager) Watch(ctx context.Context) {
go pkg.Retry(time.Second*15, time.Minute, func() error {
connections, err := m.Table.Changes().Run(m.Session)
if err != nil {
return errors.New(err)
}
defer connections.Close()
var update map[string]*rethinkSchema
for connections.Next(&update) {
newVal := update["new_val"]
oldVal := update["old_val"]
m.Lock()
if newVal == nil && oldVal != nil {
m.watcherRemove(oldVal)
} else if newVal != nil && oldVal != nil {
m.watcherRemove(oldVal)
m.watcherInsert(newVal)
} else {
m.watcherInsert(newVal)
}
m.Unlock()
}
if connections.Err() != nil {
err = errors.New(connections.Err())
pkg.LogError(err)
return err
}
return nil
})
}
func (c *RethinkDBConnection) GetSession() *r.Session {
if c.session != nil {
return c.session
}
var err error
var username, password string
database := c.URL.Path[1:]
if c.URL.User != nil {
password, _ = c.URL.User.Password()
username = c.URL.User.Username()
}
if err := pkg.Retry(time.Second*15, time.Minute*2, func() error {
logrus.Infof("Connecting with RethinkDB: %s (%s) (%s)", c.URL.String(), c.URL.Host, database)
if c.session, err = r.Connect(r.ConnectOpts{
Address: c.URL.Host,
Username: username,
Password: password,
}); err != nil {
return errors.Errorf("Could not connect to RethinkDB: %s", err)
}
if _, err := r.DBList().Contains(database).Do(func(e r.Term) r.Term {
return r.Branch(
e,
map[string]interface{}{"dbs_created": 0},
r.DBCreate(database),
)
}).RunWrite(c.session); err != nil {
return errors.Errorf("Could not create database: %s", err)
}
c.session.Use(database)
logrus.Infof("Connected to RethinkDB!")
return nil
}); err != nil {
logrus.Fatalf("Could not connect to RethinkDB: %s", err)
}
return c.session
}