func createEndpointGroupResultView(results []EndpointGroupInterface, report reports.MongoInterface, format string) ([]byte, error) {
docRoot := &root{}
prevSuperGroup := ""
prevEndpointGroup := ""
endpointGroup := &Group{}
superGroup := &SuperGroup{}
// we iterate through the results struct array
// keeping only the value of each row
for _, row := range results {
timestamp, _ := time.Parse(customForm[0], fmt.Sprint(row.Date))
//if new superGroup value does not match the previous superGroup value
//we create a new superGroup in the xml
if prevSuperGroup != row.SuperGroup {
prevSuperGroup = row.SuperGroup
superGroup = &SuperGroup{
Name: row.SuperGroup,
Type: report.GetGroupType(),
}
docRoot.Result = append(docRoot.Result, superGroup)
prevEndpointGroup = ""
}
//if new endpointGroup does not match the previous service value
//we create a new endpointGroup entry in the xml
if prevEndpointGroup != row.Name {
prevEndpointGroup = row.Name
endpointGroup = &Group{
Name: row.Name,
Type: report.GetEndpointGroupType(),
}
superGroup.Endpoints = append(superGroup.Endpoints, endpointGroup)
}
//we append the new availability values
endpointGroup.Availability = append(endpointGroup.Availability,
&Availability{
Timestamp: timestamp.Format(customForm[1]),
Availability: fmt.Sprintf("%g", row.Availability),
Reliability: fmt.Sprintf("%g", row.Reliability),
Unknown: fmt.Sprintf("%g", row.Unknown),
Uptime: fmt.Sprintf("%g", row.Up),
Downtime: fmt.Sprintf("%g", row.Down),
})
}
if strings.ToLower(format) == "application/json" {
return json.MarshalIndent(docRoot, " ", " ")
} else {
return xml.MarshalIndent(docRoot, " ", " ")
}
}
func routeCheckGroup(r *http.Request, cfg config.Config) (int, http.Header, []byte, error) {
//STANDARD DECLARATIONS START
code := http.StatusOK
h := http.Header{}
output := []byte("group check")
err := error(nil)
contentType := "application/xml"
charset := "utf-8"
//STANDARD DECLARATIONS END
// Handle response format based on Accept Header
// Default is application/xml
format := r.Header.Get("Accept")
if strings.EqualFold(format, "application/json") {
contentType = "application/json"
}
vars := mux.Vars(r)
tenantcfg, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
return code, h, output, err
}
session, err := mongo.OpenSession(tenantcfg)
defer mongo.CloseSession(session)
if err != nil {
return code, h, output, err
}
result := reports.MongoInterface{}
err = mongo.FindOne(session, tenantcfg.Db, "reports", bson.M{"info.name": vars["report_name"]}, &result)
if err != nil {
message := "The report with the name " + vars["report_name"] + " does not exist"
output, err := createMessageOUT(message, format) //Render the response into XML or JSON
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
if vars["group_type"] != result.GetEndpointGroupType() {
message := "The report " + vars["report_name"] + " does not define endpoint group type: " + vars["group_type"]
output, err := createMessageOUT(message, format) //Render the response into XML or JSON
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
return ListEndpointTimelines(r, cfg)
}
func routeCheckGroup(r *http.Request, cfg config.Config) (int, http.Header, []byte, error) {
//STANDARD DECLARATIONS START
code := http.StatusOK
h := http.Header{}
output := []byte("group check")
err := error(nil)
charset := "utf-8"
//STANDARD DECLARATIONS END
// Handle response format based on Accept Header
contentType := r.Header.Get("Accept")
vars := mux.Vars(r)
// Grab Tenant DB configuration from context
tenantcfg := context.Get(r, "tenant_conf").(config.MongoConfig)
session, err := mongo.OpenSession(tenantcfg)
defer mongo.CloseSession(session)
if err != nil {
code = http.StatusInternalServerError
output, _ = respond.MarshalContent(respond.InternalServerErrorMessage, contentType, "", " ")
return code, h, output, err
}
result := reports.MongoInterface{}
err = mongo.FindOne(session, tenantcfg.Db, "reports", bson.M{"info.name": vars["report_name"]}, &result)
if err != nil {
code = http.StatusNotFound
message := "The report with the name " + vars["report_name"] + " does not exist"
output, err := createMessageOUT(message, code, contentType) //Render the response into XML or JSON
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
if vars["group_type"] != result.GetEndpointGroupType() {
code = http.StatusNotFound
message := "The report " + vars["report_name"] + " does not define endpoint group type: " + vars["group_type"]
output, err := createMessageOUT(message, code, contentType) //Render the response into XML or JSON
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
return ListMetricTimelines(r, cfg)
}
// ListServiceFlavorResults is responsible for handling request to list service flavor results
func ListServiceFlavorResults(r *http.Request, cfg config.Config) (int, http.Header, []byte, error) {
//STANDARD DECLARATIONS START
code := http.StatusOK
h := http.Header{}
output := []byte("")
err := error(nil)
contentType := "application/xml"
charset := "utf-8"
//STANDARD DECLARATIONS END
contentType, err = respond.ParseAcceptHeader(r)
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
if err != nil {
code = http.StatusNotAcceptable
output, _ = respond.MarshalContent(respond.NotAcceptableContentType, contentType, "", " ")
return code, h, output, err
}
// Parse the request into the input
urlValues := r.URL.Query()
vars := mux.Vars(r)
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
if err.Error() == "Unauthorized" {
code = http.StatusUnauthorized
out := respond.UnauthorizedMessage
output = out.MarshalTo(contentType)
return code, h, output, err
}
code = http.StatusInternalServerError
return code, h, output, err
}
session, err := mongo.OpenSession(tenantDbConfig)
defer mongo.CloseSession(session)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
report := reports.MongoInterface{}
err = mongo.FindOne(session, tenantDbConfig.Db, "reports", bson.M{"info.name": vars["report_name"]}, &report)
if err != nil {
code = http.StatusBadRequest
message := "The report with the name " + vars["report_name"] + " does not exist"
output, err := createErrorMessage(message, contentType) //Render the response into XML or JSON
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
input := serviceFlavorResultQuery{
basicQuery: basicQuery{
Name: vars["service_type"],
Granularity: urlValues.Get("granularity"),
Format: contentType,
StartTime: urlValues.Get("start_time"),
EndTime: urlValues.Get("end_time"),
Report: report,
Vars: vars,
},
EndpointGroup: vars["lgroup_name"],
}
tenantDB := session.DB(tenantDbConfig.Db)
errs := input.Validate(tenantDB)
if len(errs) > 0 {
out := respond.BadRequestSimple
out.Errors = errs
output = out.MarshalTo(contentType)
code = 400
return code, h, output, err
}
if vars["lgroup_type"] != report.GetEndpointGroupType() {
code = http.StatusBadRequest
message := "The report " + vars["report_name"] + " does not define endpoint group type: " + vars["lgroup_type"] + ". Try using " + report.GetEndpointGroupType() + " instead."
output, err := createErrorMessage(message, contentType) //Render the response into XML or JSON
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
results := []ServiceFlavorInterface{}
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// Construct the query to mongodb based on the input
filter := bson.M{
"date": bson.M{"$gte": input.StartTimeInt, "$lte": input.EndTimeInt},
"report": report.ID,
}
if input.Name != "" {
filter["name"] = input.Name
}
if input.EndpointGroup != "" {
filter["supergroup"] = input.EndpointGroup
}
// Select the granularity of the search daily/monthly
if input.Granularity == "daily" {
customForm[0] = "20060102"
customForm[1] = "2006-01-02"
query := DailyServiceFlavor(filter)
err = mongo.Pipe(session, tenantDbConfig.Db, "service_ar", query, &results)
} else if input.Granularity == "monthly" {
customForm[0] = "200601"
customForm[1] = "2006-01"
query := MonthlyServiceFlavor(filter)
err = mongo.Pipe(session, tenantDbConfig.Db, "service_ar", query, &results)
}
// mongo.Find(session, tenantDbConfig.Db, "endpoint_group_ar", bson.M{}, "_id", &results)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
output, err = createServiceFlavorResultView(results, report, input.Format)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
return code, h, output, err
}
// ListEndpointGroupResults endpoint group availabilities according to the http request
func ListEndpointGroupResults(r *http.Request, cfg config.Config) (int, http.Header, []byte, error) {
//STANDARD DECLARATIONS START
code := http.StatusOK
h := http.Header{}
output := []byte("")
err := error(nil)
charset := "utf-8"
//STANDARD DECLARATIONS END
// Set Content-Type response Header value
contentType := r.Header.Get("Accept")
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
// Parse the request into the input
urlValues := r.URL.Query()
vars := mux.Vars(r)
// Grab Tenant DB configuration from context
tenantDbConfig := context.Get(r, "tenant_conf").(config.MongoConfig)
session, err := mongo.OpenSession(tenantDbConfig)
defer mongo.CloseSession(session)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
report := reports.MongoInterface{}
err = mongo.FindOne(session, tenantDbConfig.Db, "reports", bson.M{"info.name": vars["report_name"]}, &report)
if err != nil {
code = http.StatusNotFound
message := "The report with the name " + vars["report_name"] + " does not exist"
output, err := createErrorMessage(message, code, contentType) //Render the response into XML or JSON
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
input := endpointGroupResultQuery{
basicQuery{
Name: vars["lgroup_name"],
Granularity: urlValues.Get("granularity"),
Format: contentType,
StartTime: urlValues.Get("start_time"),
EndTime: urlValues.Get("end_time"),
Report: report,
Vars: vars,
}, "",
}
tenantDB := session.DB(tenantDbConfig.Db)
errs := input.Validate(tenantDB)
if len(errs) > 0 {
out := respond.BadRequestSimple
out.Errors = errs
output = out.MarshalTo(contentType)
code = 400
return code, h, output, err
}
if vars["lgroup_type"] != report.GetEndpointGroupType() {
code = http.StatusNotFound
message := "The report " + vars["report_name"] + " does not define endpoint group type: " + vars["lgroup_type"] + ". Try using " + report.GetEndpointGroupType() + " instead."
output, err := createErrorMessage(message, code, contentType) //Render the response into XML or JSON
return code, h, output, err
}
results := []EndpointGroupInterface{}
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// Construct the query to mongodb based on the input
filter := bson.M{
"date": bson.M{"$gte": input.StartTimeInt, "$lte": input.EndTimeInt},
"report": report.ID,
}
if input.Name != "" {
filter["name"] = input.Name
}
// Select the granularity of the search daily/monthly
if input.Granularity == "daily" {
customForm[0] = "20060102"
customForm[1] = "2006-01-02"
query := DailyEndpointGroup(filter)
err = mongo.Pipe(session, tenantDbConfig.Db, "endpoint_group_ar", query, &results)
} else if input.Granularity == "monthly" {
customForm[0] = "200601"
customForm[1] = "2006-01"
query := MonthlyEndpointGroup(filter)
err = mongo.Pipe(session, tenantDbConfig.Db, "endpoint_group_ar", query, &results)
}
// mongo.Find(session, tenantDbConfig.Db, "endpoint_group_ar", bson.M{}, "_id", &results)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
if len(results) == 0 {
code = http.StatusNotFound
message := "No results found for given query"
output, err = createErrorMessage(message, code, contentType)
return code, h, output, err
}
output, err = createEndpointGroupResultView(results, report, input.Format)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
return code, h, output, err
}