// Aggregates
func (u *Uchiwa) aggregatesHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
http.Error(w, "", http.StatusBadRequest)
return
}
// verify that the authenticated user is authorized to access this resource
token := auth.GetTokenFromContext(r)
resources := strings.Split(r.URL.Path, "/")
if len(resources) == 2 {
token := auth.GetTokenFromContext(r)
aggregates := FilterAggregates(&u.Data.Aggregates, token)
encoder := json.NewEncoder(w)
if err := encoder.Encode(aggregates); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
} else if len(resources) == 5 {
check := resources[3]
dc := resources[2]
issued := resources[4]
if check == "" || dc == "" || issued == "" {
http.Error(w, "", http.StatusBadRequest)
return
}
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
aggregate, err := u.GetAggregateByIssued(check, issued, dc)
if err != nil {
http.Error(w, fmt.Sprint(err), 500)
return
}
encoder := json.NewEncoder(w)
if err := encoder.Encode(aggregate); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
} else {
http.Error(w, "", http.StatusBadRequest)
return
}
}
func (u *Uchiwa) getAggregateByIssuedHandler(w http.ResponseWriter, r *http.Request) {
urlStruct, _ := url.Parse(r.URL.String())
check := urlStruct.Query().Get("check")
issued := urlStruct.Query().Get("issued")
dc := urlStruct.Query().Get("dc")
if check == "" || issued == "" || dc == "" {
http.Error(w, fmt.Sprint("Parameters 'check', 'issued' and 'dc' are required"), http.StatusNotFound)
return
}
// verify that the authenticated user is authorized to access this resource
token := auth.GetTokenFromContext(r)
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
aggregate, err := u.GetAggregateByIssued(check, issued, dc)
if err != nil {
http.Error(w, fmt.Sprint(err), 500)
} else {
encoder := json.NewEncoder(w)
if err := encoder.Encode(aggregate); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
}
}
}
func (u *Uchiwa) getClientHandler(w http.ResponseWriter, r *http.Request) {
urlStruct, _ := url.Parse(r.URL.String())
id := urlStruct.Query().Get("id")
dc := urlStruct.Query().Get("dc")
if id == "" || dc == "" {
http.Error(w, fmt.Sprint("Parameters 'id' and 'dc' are required"), http.StatusNotFound)
return
}
// verify that the authenticated user is authorized to access this resource
token := auth.GetTokenFromContext(r)
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
client, err := u.GetClient(id, dc)
if err != nil {
http.Error(w, fmt.Sprint(err), http.StatusNotFound)
return
}
encoder := json.NewEncoder(w)
if err := encoder.Encode(client); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
}
// Results
func (u *Uchiwa) resultsHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != "DELETE" {
http.Error(w, "", http.StatusBadRequest)
return
}
resources := strings.Split(r.URL.Path, "/")
if len(resources) != 5 {
http.Error(w, "", http.StatusBadRequest)
return
}
check := resources[4]
client := resources[3]
dc := resources[2]
token := auth.GetTokenFromContext(r)
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
err := u.DeleteCheckResult(check, client, dc)
if err != nil {
http.Error(w, fmt.Sprint(err), http.StatusInternalServerError)
return
}
}
func (u *Uchiwa) stashHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
http.Error(w, "", http.StatusBadRequest)
return
}
decoder := json.NewDecoder(r.Body)
var data stash
err := decoder.Decode(&data)
if err != nil {
http.Error(w, "Could not decode body", http.StatusInternalServerError)
return
}
// verify that the authenticated user is authorized to access this resource
token := auth.GetTokenFromContext(r)
unauthorized := FilterGetRequest(data.Dc, token)
// add username to the stash content
if token != nil && token.Claims["Username"] != nil {
data.Content["username"] = token.Claims["Username"]
}
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
err = u.PostStash(data)
if err != nil {
http.Error(w, "Could not create the stash", http.StatusNotFound)
}
}
// Request
func (u *Uchiwa) requestHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != "POST" {
http.Error(w, "", http.StatusBadRequest)
return
}
decoder := json.NewDecoder(r.Body)
var data structs.CheckExecution
err := decoder.Decode(&data)
if err != nil {
http.Error(w, "Could not decode body", http.StatusInternalServerError)
return
}
// verify that the authenticated user is authorized to access this resource
token := auth.GetTokenFromContext(r)
unauthorized := FilterGetRequest(data.Dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
err = u.IssueCheckExecution(data)
if err != nil {
http.Error(w, "Could not create the stash", http.StatusNotFound)
return
}
return
}
// Stashes
func (u *Uchiwa) stashesHandler(w http.ResponseWriter, r *http.Request) {
token := auth.GetTokenFromContext(r)
resources := strings.Split(r.URL.Path, "/")
if r.Method == "DELETE" && len(resources) >= 3 {
dc := resources[2]
path := strings.Join(resources[3:], "/")
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
err := u.DeleteStash(dc, path)
if err != nil {
http.Error(w, "Could not create the stash", http.StatusNotFound)
}
} else if r.Method == "GET" {
stashes := FilterStashes(&u.Data.Stashes, token)
encoder := json.NewEncoder(w)
if err := encoder.Encode(stashes); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
} else if r.Method == "POST" {
decoder := json.NewDecoder(r.Body)
var data stash
err := decoder.Decode(&data)
if err != nil {
http.Error(w, "Could not decode body", http.StatusInternalServerError)
return
}
// verify that the authenticated user is authorized to access this resource
unauthorized := FilterGetRequest(data.Dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
if token != nil && token.Claims["Username"] != nil {
data.Content["username"] = token.Claims["Username"]
}
err = u.PostStash(data)
if err != nil {
http.Error(w, "Could not create the stash", http.StatusNotFound)
return
}
} else {
http.Error(w, "", http.StatusBadRequest)
return
}
}
func (u *Uchiwa) getSensuHandler(w http.ResponseWriter, r *http.Request) {
//Test()
token := auth.GetTokenFromContext(r)
data := FilterSensuData(token, u.Data)
encoder := json.NewEncoder(w)
if err := encoder.Encode(data); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
}
}
// stashes
func (u *Uchiwa) stashesHandler(w http.ResponseWriter, r *http.Request) {
if r.Method == "GET" {
token := auth.GetTokenFromContext(r)
stashes := FilterStashes(&u.Data.Stashes, token)
encoder := json.NewEncoder(w)
if err := encoder.Encode(stashes); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
} else if r.Method == "POST" {
decoder := json.NewDecoder(r.Body)
var data stash
err := decoder.Decode(&data)
if err != nil {
http.Error(w, "Could not decode body", http.StatusInternalServerError)
return
}
// verify that the authenticated user is authorized to access this resource
token := auth.GetTokenFromContext(r)
unauthorized := FilterGetRequest(data.Dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
err = u.PostStash(data)
if err != nil {
http.Error(w, "Could not create the stash", http.StatusNotFound)
return
}
} else {
http.Error(w, "", http.StatusBadRequest)
return
}
}
// Subscriptions
func (u *Uchiwa) subscriptionsHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
http.Error(w, "", http.StatusBadRequest)
return
}
token := auth.GetTokenFromContext(r)
subscriptions := FilterSubscriptions(&u.Data.Subscriptions, token)
encoder := json.NewEncoder(w)
if err := encoder.Encode(subscriptions); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
}
// Events
func (u *Uchiwa) eventsHandler(w http.ResponseWriter, r *http.Request) {
token := auth.GetTokenFromContext(r)
// DELETE on /events
if r.Method == "DELETE" {
resources := strings.Split(r.URL.Path, "/")
if len(resources) != 5 {
http.Error(w, "", http.StatusBadRequest)
return
}
check := resources[4]
client := resources[3]
dc := resources[2]
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
err := u.ResolveEvent(check, client, dc)
if err != nil {
http.Error(w, fmt.Sprint(err), http.StatusInternalServerError)
return
}
} else if r.Method == "GET" {
// GET on /events
events := FilterEvents(&u.Data.Events, token)
// Create header
w.Header().Add("Accept-Charset", "utf-8")
w.Header().Add("Content-Type", "application/json")
w.Header().Set("Content-Encoding", "gzip")
gz := gzip.NewWriter(w)
defer gz.Close()
if err := json.NewEncoder(gz).Encode(events); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
return
} else {
http.Error(w, "", http.StatusBadRequest)
return
}
}
// Datacenters
func (u *Uchiwa) datacentersHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
http.Error(w, "", http.StatusBadRequest)
return
}
token := auth.GetTokenFromContext(r)
datacenters := FilterDatacenters(u.Data.Dc, token)
// Create header
w.Header().Add("Accept-Charset", "utf-8")
w.Header().Add("Content-Type", "application/json")
w.Header().Set("Content-Encoding", "gzip")
gz := gzip.NewWriter(w)
defer gz.Close()
if err := json.NewEncoder(gz).Encode(datacenters); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
return
}
// Events
func (u *Uchiwa) eventsHandler(w http.ResponseWriter, r *http.Request) {
token := auth.GetTokenFromContext(r)
if r.Method == "DELETE" {
resources := strings.Split(r.URL.Path, "/")
if len(resources) != 5 {
http.Error(w, "", http.StatusBadRequest)
return
}
check := resources[4]
client := resources[3]
dc := resources[2]
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
err := u.ResolveEvent(check, client, dc)
if err != nil {
http.Error(w, fmt.Sprint(err), http.StatusInternalServerError)
return
}
} else if r.Method == "GET" {
events := FilterEvents(&u.Data.Events, token)
encoder := json.NewEncoder(w)
if err := encoder.Encode(events); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
} else {
http.Error(w, "", http.StatusBadRequest)
return
}
}
func (u *Uchiwa) postEventHandler(w http.ResponseWriter, r *http.Request) {
decoder := json.NewDecoder(r.Body)
var data interface{}
err := decoder.Decode(&data)
if err != nil {
http.Error(w, fmt.Sprint("Could not decode body"), http.StatusInternalServerError)
return
}
// verify that the authenticated user is authorized to access this resource
token := auth.GetTokenFromContext(r)
unauthorized := FilterPostRequest(token, &data)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
err = u.ResolveEvent(data)
if err != nil {
http.Error(w, fmt.Sprint(err), http.StatusInternalServerError)
}
}
// Aggregates
func (u *Uchiwa) aggregatesHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != "GET" {
http.Error(w, "", http.StatusBadRequest)
return
}
// verify that the authenticated user is authorized to access this resource
token := auth.GetTokenFromContext(r)
resources := strings.Split(r.URL.Path, "/")
// GET on /aggregates
if len(resources) == 2 {
token := auth.GetTokenFromContext(r)
aggregates := FilterAggregates(&u.Data.Aggregates, token)
// Create header
w.Header().Add("Accept-Charset", "utf-8")
w.Header().Add("Content-Type", "application/json")
w.Header().Set("Content-Encoding", "gzip")
gz := gzip.NewWriter(w)
defer gz.Close()
if err := json.NewEncoder(gz).Encode(aggregates); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
return
} else if len(resources) == 5 {
// GET on /aggregates/{dc}/{check}/{issued}
check := resources[3]
dc := resources[2]
issued := resources[4]
if check == "" || dc == "" || issued == "" {
http.Error(w, "", http.StatusBadRequest)
return
}
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
aggregate, err := u.GetAggregateByIssued(check, issued, dc)
if err != nil {
http.Error(w, fmt.Sprint(err), 500)
return
}
encoder := json.NewEncoder(w)
if err := encoder.Encode(aggregate); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
} else {
http.Error(w, "", http.StatusBadRequest)
return
}
}
// Stashes
func (u *Uchiwa) stashesHandler(w http.ResponseWriter, r *http.Request) {
token := auth.GetTokenFromContext(r)
resources := strings.Split(r.URL.Path, "/")
// DELETE on /stashes/{dc}/{path}
if r.Method == "DELETE" && len(resources) >= 3 {
dc := resources[2]
path := strings.Join(resources[3:], "/")
if dc == "" || path == "" {
http.Error(w, "", http.StatusBadRequest)
return
}
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
err := u.DeleteStash(dc, path)
if err != nil {
logger.Warningf("Could not delete the stash '%s': %s", path, err)
http.Error(w, "Could not create the stash", http.StatusNotFound)
return
}
} else if r.Method == "GET" {
// GET on /stashes
stashes := FilterStashes(&u.Data.Stashes, token)
// Create header
w.Header().Add("Accept-Charset", "utf-8")
w.Header().Add("Content-Type", "application/json")
w.Header().Set("Content-Encoding", "gzip")
gz := gzip.NewWriter(w)
defer gz.Close()
if err := json.NewEncoder(gz).Encode(stashes); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
return
} else if r.Method == "POST" {
// POST on /stashes
decoder := json.NewDecoder(r.Body)
var data stash
err := decoder.Decode(&data)
if err != nil {
http.Error(w, "Could not decode body", http.StatusInternalServerError)
return
}
// verify that the authenticated user is authorized to access this resource
unauthorized := FilterGetRequest(data.Dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
if token != nil && token.Claims["Username"] != nil {
data.Content["username"] = token.Claims["Username"]
}
err = u.PostStash(data)
if err != nil {
http.Error(w, "Could not create the stash", http.StatusNotFound)
return
}
} else {
http.Error(w, "", http.StatusBadRequest)
return
}
}
// Clients
func (u *Uchiwa) clientsHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != "DELETE" && r.Method != "GET" {
http.Error(w, "", http.StatusBadRequest)
return
}
token := auth.GetTokenFromContext(r)
resources := strings.Split(r.URL.Path, "/")
// GET on /clients
if len(resources) == 2 && r.Method == "GET" {
clients := FilterClients(&u.Data.Clients, token)
// Create header
w.Header().Add("Accept-Charset", "utf-8")
w.Header().Add("Content-Type", "application/json")
w.Header().Set("Content-Encoding", "gzip")
gz := gzip.NewWriter(w)
defer gz.Close()
if err := json.NewEncoder(gz).Encode(clients); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
return
} else if len(resources) != 4 {
http.Error(w, "", http.StatusBadRequest)
return
}
client := resources[3]
dc := resources[2]
if client == "" || dc == "" {
http.Error(w, "", http.StatusBadRequest)
return
}
// DELETE on /clients
if r.Method == "DELETE" {
// verify that the authenticated user is authorized to access this resource
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
err := u.DeleteClient(client, dc)
if err != nil {
http.Error(w, fmt.Sprint(err), http.StatusInternalServerError)
return
}
} else if r.Method == "GET" {
// GET on /clients/{client}
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
data, err := u.GetClient(client, dc)
if err != nil {
http.Error(w, fmt.Sprint(err), http.StatusNotFound)
return
}
encoder := json.NewEncoder(w)
if err := encoder.Encode(data); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
}
}
// Clients
func (u *Uchiwa) clientsHandler(w http.ResponseWriter, r *http.Request) {
if r.Method != "DELETE" && r.Method != "GET" {
http.Error(w, "", http.StatusBadRequest)
return
}
token := auth.GetTokenFromContext(r)
resources := strings.Split(r.URL.Path, "/")
if len(resources) == 2 && r.Method == "GET" {
clients := FilterClients(&u.Data.Clients, token)
encoder := json.NewEncoder(w)
if err := encoder.Encode(clients); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
return
} else if len(resources) != 4 {
http.Error(w, "", http.StatusBadRequest)
return
}
client := resources[3]
dc := resources[2]
if client == "" || dc == "" {
http.Error(w, "", http.StatusBadRequest)
return
}
if r.Method == "DELETE" {
// verify that the authenticated user is authorized to access this resource
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
err := u.DeleteClient(client, dc)
if err != nil {
http.Error(w, fmt.Sprint(err), http.StatusInternalServerError)
return
}
} else if r.Method == "GET" {
unauthorized := FilterGetRequest(dc, token)
if unauthorized {
http.Error(w, fmt.Sprint(""), http.StatusNotFound)
return
}
data, err := u.GetClient(client, dc)
if err != nil {
http.Error(w, fmt.Sprint(err), http.StatusNotFound)
return
}
encoder := json.NewEncoder(w)
if err := encoder.Encode(data); err != nil {
http.Error(w, fmt.Sprintf("Cannot encode response data: %v", err), http.StatusInternalServerError)
return
}
}
}