func (s *Service) regSrv(config vulcan.Config) {
for {
registry := vulcan.NewRegistry(config, s.options.EtcdNodes)
entry, err := vulcan.NewEndpointWithID(s.options.ApplicationId,
s.options.ApplicationId,
s.options.Interface,
s.options.Port)
if err != nil {
log.Errorf(err.Error())
}
log.Debugf(entry.String())
if err := registry.RegisterBackend(entry); err != nil {
log.Errorf(err.Error())
}
if err := registry.RegisterServer(entry); err != nil {
log.Errorf(err.Error())
}
loc := vulcan.NewLocation(s.options.HostLimit,
[]string{},
s.options.RegisterPath,
s.options.ApplicationId,
[]middleware.Middleware{})
if err := registry.RegisterFrontend(loc); err != nil {
log.Errorf(err.Error())
}
log.Debugf("Syncing up Vulcan")
time.Sleep(4000 * time.Millisecond)
}
}
// RegisterApp adds a new backend and a single server with Vulcand.
func (s *LeaderRegistry) RegisterApp(registration *AppRegistration) error {
log.Infof("Registering app: %v", registration)
endpoint, err := vulcan.NewEndpointWithID(s.Group, registration.Name, registration.Host, registration.Port)
if err != nil {
return err
}
err = s.client.RegisterBackend(endpoint)
if err != nil {
log.Errorf("Failed to register backend for endpoint: %v, %s", endpoint, err)
return err
}
if s.IsMaster {
err = s.maintainLeader(endpoint)
} else {
err = s.initLeader(endpoint)
}
if err != nil {
log.Errorf("Failed to register server for endpoint: %v, %s", endpoint, err)
return err
}
return nil
}
// Subscribe watches etcd changes and generates structured events telling vulcand to add or delete frontends, hosts etc.
// It is a blocking function.
func (n *ng) Subscribe(changes chan interface{}, cancelC chan bool) error {
// This index helps us to get changes in sequence, as they were performed by clients.
waitIndex := uint64(0)
for {
response, err := n.client.Watch(n.etcdKey, waitIndex, true, nil, cancelC)
if err != nil {
switch err {
case etcd.ErrWatchStoppedByUser:
log.Infof("Stop watching: graceful shutdown")
return nil
default:
log.Errorf("unexpected error: %s, stop watching", err)
return err
}
}
waitIndex = response.Node.ModifiedIndex + 1
log.Infof("%s", responseToString(response))
change, err := n.parseChange(response)
if err != nil {
log.Warningf("Ignore '%s', error: %s", responseToString(response), err)
continue
}
if change != nil {
log.Infof("%v", change)
select {
case changes <- change:
case <-cancelC:
return nil
}
}
}
}
func (n *ng) GetUserByEmail(email string) (MinimalUserRecord, error) {
user := MinimalUserRecord{}
session, _ := n.Database.CreateSession()
defer session.Close()
log.Debugf("===> Querying Database for email: " + email)
if err := session.Query(`SELECT id,
email,
hashed_password,
password_salt,
encryption_keys,
meta_storage,
is_active
FROM access_users
WHERE email = ?
LIMIT 1 ALLOW FILTERING`,
email).Consistency(gocql.One).Scan(&user.Id,
&user.Email,
&user.HashedPassword,
&user.PasswordSalt,
&user.EncryptionKeys,
&user.MetaStorage,
&user.IsActive); err != nil {
log.Errorf("===> Got a database error while querying for specific user")
return MinimalUserRecord{}, err
}
return user, nil
}
// registerLocationForScope registers a location with a specified scope.
func (app *App) registerLocationForScope(methods []string, path string, scope Scope, middlewares []middleware.Middleware) {
host, err := app.apiHostForScope(scope)
if err != nil {
log.Errorf("Failed to register a location: %v", err)
return
}
app.registerLocationForHost(methods, path, host, middlewares)
}
// RegisterHandler registers the frontends and middlewares with Vulcand.
func (s *LeaderRegistry) RegisterHandler(registration *HandlerRegistration) error {
log.Infof("Registering handler: %v", registration)
location := vulcan.NewLocation(registration.Host, registration.Methods, registration.Path, registration.Name, registration.Middlewares)
err := s.client.RegisterFrontend(location)
if err != nil {
log.Errorf("Failed to register frontend for location: %v, %s", location, err)
return err
}
err = s.client.RegisterMiddleware(location)
if err != nil {
log.Errorf("Failed to register middleware for location: %v, %s", location, err)
return err
}
return nil
}
// RegisterApp adds a new backend and a single server with Vulcand.
func (s *LBRegistry) RegisterApp(registration *AppRegistration) error {
log.Infof("Registering app: %v", registration)
endpoint, err := vulcan.NewEndpoint(registration.Name, registration.Host, registration.Port)
if err != nil {
return err
}
err = s.client.RegisterBackend(endpoint)
if err != nil {
log.Errorf("Failed to register backend for endpoint: %v, %s", endpoint, err)
return err
}
err = s.client.UpsertServer(endpoint, s.TTL)
if err != nil {
log.Errorf("Failed to register server for endpoint: %v, %s", endpoint, err)
return err
}
return nil
}
func Run() error {
options, err := ParseCommandLine()
if err != nil {
return fmt.Errorf("failed to parse command line: %s", err)
}
service := NewService(options)
if err := service.Start(); err != nil {
log.Errorf("Failed to start service: %v", err)
return fmt.Errorf("service start failure: %s", err)
} else {
log.Infof("Service exited gracefully")
}
return nil
}
func (n *ng) GetJwtToken(token string) ([]byte, error) {
//log.Debugf(validTime)
var key string
session, _ := n.Database.CreateSession()
defer session.Close()
if err := session.Query(`SELECT key
FROM tokens
WHERE jwt = ?
LIMIT 1`,
token).Consistency(gocql.One).Scan(&key); err != nil {
log.Errorf("===> Got a database error while querying for a specific key")
return []byte(""), err
}
return []byte(key), nil
}
// Helper that replies with the 500 code and happened error message.
func ReplyInternalError(w http.ResponseWriter, message string) {
log.Errorf("Internal server error: %v", message)
Reply(w, Response{"message": message}, http.StatusInternalServerError)
}
func main() {
app := cli.NewApp()
app.Name = "XTOOLS for SITREP"
app.Usage = "Tools for the SITREP Server Environment"
app.Commands = []cli.Command{
{
Name: "index",
Aliases: []string{"i"},
Usage: "Re-Index everything into Elasticsearch",
Flags: []cli.Flag{
cli.StringFlag{
Name: "cassandra, c",
Value: "127.0.0.1",
Usage: "Cassandra Endpoint",
},
cli.StringFlag{
Name: "keyspace, k",
Value: "sitrep_dev",
Usage: "SITREP ENDPOINT",
},
cli.StringFlag{
Name: "elastichost, e",
Value: "elasticsearch.dev.docker",
Usage: "Elasticsearch Host",
},
},
Action: func(c *cli.Context) {
db := gocql.NewCluster(c.String("cassandra"))
db.Keyspace = "sitrep_dev"
db.DiscoverHosts = true
db.Discovery = gocql.DiscoveryConfig{
DcFilter: "",
RackFilter: "",
Sleep: 30 * time.Second,
}
session, _ := db.CreateSession()
defer session.Close()
news := NewsRecord{}
cl := elastigo.NewConn()
cl.Domain = c.String("elastichost")
iter := session.Query(`SELECT url, newsid, content, media, postedat, previewcontent, title FROM newsstoriestable`).Iter()
for iter.Scan(&news.Url,
&news.NewsId,
&news.Content,
&news.Media,
&news.PostedAt,
&news.PreviewContent,
&news.Title) {
item := &Record{
Title: news.Title,
Preview: news.PreviewContent,
Image: *news.Media["preview"],
Link: "/news/flobama/" + news.Url,
Content: news.Content,
PostedAt: news.PostedAt,
Media: news.Media,
}
cl.Index("sites", "news", news.Url, nil, item)
fmt.Println("Indexed:", news.Url)
}
if err := iter.Close(); err != nil {
log.Errorf(err.Error())
}
page := IntellipediaPage{}
iter2 := session.Query(`SELECT url, content, image, mapimg, name FROM intellipediapagestable`).Iter()
for iter2.Scan(&page.Url,
&page.Content,
&page.Image,
&page.PreviewContent,
&page.Title) {
item := &Record{
Title: page.Title,
Preview: page.PreviewContent,
Image: page.Image,
Link: "/intellipedia/" + page.Url,
Content: page.Content,
}
cl.Index("sites", "intellipedia", page.Url, nil, item)
fmt.Println("Indexed:", page.Url)
}
if err := iter2.Close(); err != nil {
log.Errorf(err.Error())
}
site := SocialSite{}
iter3 := session.Query(`SELECT name, link, tile FROM categoriestable`).Iter()
for iter3.Scan(&site.Name,
&site.Link,
&site.Tile) {
item := &Record{
Title: site.Name,
Preview: "",
Image: site.Tile,
Link: site.Link,
}
cl.Index("sites", "sites", strings.Replace(site.Name, " ", "-", -1), nil, item)
fmt.Println("Indexed:", site.Name)
}
if err := iter3.Close(); err != nil {
log.Errorf(err.Error())
}
},
},
{
Name: "complete",
Aliases: []string{"c"},
Usage: "complete a task on the list",
Action: func(c *cli.Context) {
println("completed task: ", c.Args().First())
},
},
{
Name: "template",
Aliases: []string{"r"},
Usage: "options for task templates",
Subcommands: []cli.Command{
{
Name: "add",
Usage: "add a new template",
Action: func(c *cli.Context) {
println("new task template: ", c.Args().First())
},
},
{
Name: "remove",
Usage: "remove an existing template",
Action: func(c *cli.Context) {
println("removed task template: ", c.Args().First())
},
},
},
},
}
app.Run(os.Args)
}