// WebServer starts the web server and serves GET & POST requests
func (u *Uchiwa) WebServer(publicPath *string, auth auth.Config) {
// Private endpoints
http.Handle("/aggregates", auth.Authenticate(http.HandlerFunc(u.aggregatesHandler)))
http.Handle("/aggregates/", auth.Authenticate(http.HandlerFunc(u.aggregatesHandler)))
http.Handle("/checks", auth.Authenticate(http.HandlerFunc(u.checksHandler)))
http.Handle("/clients", auth.Authenticate(http.HandlerFunc(u.clientsHandler)))
http.Handle("/clients/", auth.Authenticate(http.HandlerFunc(u.clientsHandler)))
http.Handle("/config", auth.Authenticate(http.HandlerFunc(u.configHandler)))
http.Handle("/datacenters", auth.Authenticate(http.HandlerFunc(u.datacentersHandler)))
http.Handle("/events", auth.Authenticate(http.HandlerFunc(u.eventsHandler)))
http.Handle("/events/", auth.Authenticate(http.HandlerFunc(u.eventsHandler)))
http.Handle("/stashes", auth.Authenticate(http.HandlerFunc(u.stashesHandler)))
http.Handle("/stashes/", auth.Authenticate(http.HandlerFunc(u.stashesHandler)))
http.Handle("/subscriptions", auth.Authenticate(http.HandlerFunc(u.subscriptionsHandler)))
if u.Config.Uchiwa.Enterprise == false {
http.Handle("/metrics", auth.Authenticate(http.HandlerFunc(u.metricsHandler)))
}
// Static files
http.Handle("/", http.FileServer(http.Dir(*publicPath)))
// Public endpoints
http.Handle("/config/", http.HandlerFunc(u.configHandler))
http.Handle("/health", http.HandlerFunc(u.healthHandler))
http.Handle("/health/", http.HandlerFunc(u.healthHandler))
http.Handle("/login", auth.GetIdentification())
listen := fmt.Sprintf("%s:%d", u.Config.Uchiwa.Host, u.Config.Uchiwa.Port)
logger.Infof("Uchiwa is now listening on %s", listen)
logger.Fatal(http.ListenAndServe(listen, nil))
}
// WebServer starts the web server and serves GET & POST requests
func (u *Uchiwa) WebServer(publicPath *string, auth auth.Config) {
// private endpoints
http.Handle("/aggregates", auth.Authenticate(http.HandlerFunc(u.aggregatesHandler)))
http.Handle("/checks", auth.Authenticate(http.HandlerFunc(u.checksHandler)))
http.Handle("/clients", auth.Authenticate(http.HandlerFunc(u.clientsHandler)))
http.Handle("/datacenters", auth.Authenticate(http.HandlerFunc(u.datacentersHandler)))
http.Handle("/events", auth.Authenticate(http.HandlerFunc(u.eventsHandler)))
http.Handle("/results", auth.Authenticate(http.HandlerFunc(u.resultsHandler)))
http.Handle("/stashes", auth.Authenticate(http.HandlerFunc(u.stashesHandler)))
http.Handle("/stashes/delete", auth.Authenticate(http.HandlerFunc(u.stashDeleteHandler)))
http.Handle("/subscriptions", auth.Authenticate(http.HandlerFunc(u.subscriptionsHandler)))
http.Handle("/delete_client", auth.Authenticate(http.HandlerFunc(u.deleteClientHandler)))
http.Handle("/get_aggregate", auth.Authenticate(http.HandlerFunc(u.getAggregateHandler)))
http.Handle("/get_aggregate_by_issued", auth.Authenticate(http.HandlerFunc(u.getAggregateByIssuedHandler)))
http.Handle("/get_client", auth.Authenticate(http.HandlerFunc(u.getClientHandler)))
http.Handle("/get_config", auth.Authenticate(http.HandlerFunc(u.getConfigHandler)))
http.Handle("/get_sensu", auth.Authenticate(http.HandlerFunc(u.getSensuHandler)))
http.Handle("/post_event", auth.Authenticate(http.HandlerFunc(u.postEventHandler)))
// static files
http.Handle("/", http.FileServer(http.Dir(*publicPath)))
// public endpoints
http.Handle("/config/auth", http.HandlerFunc(u.configAuthHandler))
http.Handle("/health", http.HandlerFunc(u.healthHandler))
http.Handle("/health/", http.HandlerFunc(u.healthHandler))
http.Handle("/login", auth.GetIdentification())
listen := fmt.Sprintf("%s:%d", u.Config.Uchiwa.Host, u.Config.Uchiwa.Port)
logger.Infof("Uchiwa is now listening on %s", listen)
logger.Fatal(http.ListenAndServe(listen, nil))
}
func (s *Sensu) delete(endpoint string) error {
apis := shuffle(s.APIs)
var err error
for i := 0; i < len(apis); i++ {
logger.Infof("DELETE %s/%s", s.APIs[i].URL, endpoint)
err = apis[i].delete(endpoint)
if err == nil {
return err
}
logger.Warningf("DELETE %s/%s returned: %v", s.APIs[i].URL, endpoint, err)
}
return err
}
// Load retrieves a specified configuration file and return a Config struct
func Load(path string) (*Config, error) {
logger.Infof("Loading configuration file %s", path)
c := new(Config)
file, err := os.Open(path)
if err != nil {
if len(path) > 1 {
return nil, fmt.Errorf("Error: could not read config file %s.", path)
}
}
decoder := json.NewDecoder(file)
err = decoder.Decode(c)
if err != nil {
return nil, fmt.Errorf("Error decoding file %s: %s", path, err)
}
c.initUchiwa()
c.initSensu()
return c, nil
}
// getData retrieves all endpoints for every datacenter
func (d *Daemon) fetchData() {
d.Data.Health.Sensu = make(map[string]structs.SensuHealth, len(*d.Datacenters))
for _, datacenter := range *d.Datacenters {
logger.Infof("Updating the datacenter %s", datacenter.Name)
// set default health status
d.Data.Health.Sensu[datacenter.Name] = structs.SensuHealth{Output: datacenterErrorString, Status: 2}
d.Data.Health.Uchiwa = "ok"
// fetch sensu data from the datacenter
stashes, err := datacenter.GetStashes()
if err != nil {
logger.Warningf("Connection failed to the datacenter %s", datacenter.Name)
continue
}
checks, err := datacenter.GetChecks()
if err != nil {
logger.Warningf("Connection failed to the datacenter %s", datacenter.Name)
continue
}
clients, err := datacenter.GetClients()
if err != nil {
logger.Warningf("Connection failed to the datacenter %s", datacenter.Name)
continue
}
events, err := datacenter.GetEvents()
if err != nil {
logger.Warningf("Connection failed to the datacenter %s", datacenter.Name)
continue
}
info, err := datacenter.GetInfo()
if err != nil {
logger.Warningf("Connection failed to the datacenter %s", datacenter.Name)
continue
}
aggregates, err := datacenter.GetAggregates()
if err != nil {
logger.Warningf("Connection failed to the datacenter %s", datacenter.Name)
continue
}
if d.Enterprise {
d.Data.SERawMetrics = *getEnterpriseMetrics(&datacenter, &d.Data.SERawMetrics)
}
// Determine the status of the datacenter
if !info.Redis.Connected {
d.Data.Health.Sensu[datacenter.Name] = structs.SensuHealth{Output: "Not connected to Redis", Status: 1}
} else if !info.Transport.Connected {
d.Data.Health.Sensu[datacenter.Name] = structs.SensuHealth{Output: "Not connected to the transport", Status: 1}
} else {
d.Data.Health.Sensu[datacenter.Name] = structs.SensuHealth{Output: "ok", Status: 0}
}
// add fetched data into d.Data interface
for _, v := range stashes {
setDc(v, datacenter.Name)
d.Data.Stashes = append(d.Data.Stashes, v)
}
for _, v := range checks {
setDc(v, datacenter.Name)
d.Data.Checks = append(d.Data.Checks, v)
}
for _, v := range clients {
setDc(v, datacenter.Name)
d.Data.Clients = append(d.Data.Clients, v)
}
for _, v := range events {
setDc(v, datacenter.Name)
d.Data.Events = append(d.Data.Events, v)
}
for _, v := range aggregates {
setDc(v, datacenter.Name)
d.Data.Aggregates = append(d.Data.Aggregates, v)
}
// build datacenter
dc := d.buildDatacenter(&datacenter.Name, info)
dc.Stats["aggregates"] = len(aggregates)
dc.Stats["checks"] = len(checks)
dc.Stats["clients"] = len(clients)
dc.Stats["events"] = len(events)
dc.Stats["stashes"] = len(stashes)
d.Data.Dc = append(d.Data.Dc, dc)
}
}
// getData retrieves all endpoints for every datacenter
func (d *Daemon) fetchData() {
d.Data.Health.Sensu = make(map[string]structs.SensuHealth, len(*d.Datacenters))
for _, datacenter := range *d.Datacenters {
logger.Infof("Updating the datacenter %s", datacenter.Name)
// set default health status
d.Data.Health.Sensu[datacenter.Name] = structs.SensuHealth{Output: datacenterErrorString, Status: 2}
d.Data.Health.Uchiwa = "ok"
// fetch sensu data from the datacenter
stashes, err := datacenter.GetStashes()
if err != nil {
logger.Warningf("Connection failed to the datacenter %s", datacenter.Name)
continue
}
checks, err := datacenter.GetChecks()
if err != nil {
logger.Warningf("Connection failed to the datacenter %s", datacenter.Name)
continue
}
clients, err := datacenter.GetClients()
if err != nil {
logger.Warningf("Connection failed to the datacenter %s", datacenter.Name)
continue
}
events, err := datacenter.GetEvents()
if err != nil {
logger.Warningf("Connection failed to the datacenter %s", datacenter.Name)
continue
}
info, err := datacenter.GetInfo()
if err != nil {
logger.Warningf("Connection failed to the datacenter %s", datacenter.Name)
continue
}
aggregates, err := datacenter.GetAggregates()
if err != nil {
logger.Warningf("Connection failed to the datacenter %s", datacenter.Name)
continue
}
if d.Enterprise {
hasMetrics := true
metrics := make(map[string]*structs.SERawMetric)
metricsEndpoints := []string{"clients", "events", "keepalives_avg_60", "check_requests", "results"}
for _, metric := range metricsEndpoints {
metrics[metric], err = datacenter.Metric(metric)
if err != nil {
logger.Warningf("Could not retrieve the %s metrics. Discarding all metrics for the datacenter %s", metric, datacenter.Name)
hasMetrics = false
break
}
}
if hasMetrics {
metrics["events"].Name = datacenter.Name
d.Data.SERawMetrics.Clients = append(d.Data.SERawMetrics.Clients, metrics["clients"])
d.Data.SERawMetrics.Events = append(d.Data.SERawMetrics.Events, metrics["events"])
d.Data.SERawMetrics.KeepalivesAVG60 = append(d.Data.SERawMetrics.KeepalivesAVG60, metrics["keepalives_avg_60"])
d.Data.SERawMetrics.Requests = append(d.Data.SERawMetrics.Requests, metrics["check_requests"])
d.Data.SERawMetrics.Results = append(d.Data.SERawMetrics.Results, metrics["results"])
}
}
// Determine the status of the datacenter
if !info.Redis.Connected {
d.Data.Health.Sensu[datacenter.Name] = structs.SensuHealth{Output: "Not connected to Redis", Status: 1}
} else if !info.Transport.Connected {
d.Data.Health.Sensu[datacenter.Name] = structs.SensuHealth{Output: "Not connected to the transport", Status: 1}
} else {
d.Data.Health.Sensu[datacenter.Name] = structs.SensuHealth{Output: "ok", Status: 0}
}
// add fetched data into d.Data interface
for _, v := range stashes {
setDc(v, datacenter.Name)
d.Data.Stashes = append(d.Data.Stashes, v)
}
for _, v := range checks {
setDc(v, datacenter.Name)
d.Data.Checks = append(d.Data.Checks, v)
}
for _, v := range clients {
setDc(v, datacenter.Name)
d.Data.Clients = append(d.Data.Clients, v)
}
for _, v := range events {
setDc(v, datacenter.Name)
d.Data.Events = append(d.Data.Events, v)
}
for _, v := range aggregates {
setDc(v, datacenter.Name)
d.Data.Aggregates = append(d.Data.Aggregates, v)
}
// build datacenter
dc := d.buildDatacenter(&datacenter.Name, info)
dc.Stats["aggregates"] = len(aggregates)
dc.Stats["checks"] = len(checks)
dc.Stats["clients"] = len(clients)
dc.Stats["events"] = len(events)
dc.Stats["stashes"] = len(stashes)
d.Data.Dc = append(d.Data.Dc, dc)
}
}