// List existing recomputations
func List(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/json"
charset := "utf-8"
//STANDARD DECLARATIONS END
urlValues := r.URL.Query()
contentType := r.Header.Get("Accept")
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
}
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output, _ = respond.MarshalContent(respond.UnauthorizedMessage, contentType, "", " ")
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
return code, h, output, err
}
filter := IncomingRecomputation{
StartTime: urlValues.Get("start_time"),
EndTime: urlValues.Get("end_time"),
Reason: urlValues.Get("reason"),
Report: urlValues.Get("report"),
}
session, err := mongo.OpenSession(tenantDbConfig)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
results := []MongoInterface{}
err = mongo.Find(session, tenantDbConfig.Db, recomputationsColl, filter, "timestamp", &results)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
output, err = createListView(results, contentType)
return code, h, output, err
}
// List returns a list of factors (weights) per endpoint group (i.e. site)
func List(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 := "text/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
}
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output = []byte(http.StatusText(http.StatusUnauthorized))
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
session, err := mongo.OpenSession(tenantDbConfig)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
defer mongo.CloseSession(session)
results := []FactorsOutput{}
err = mongo.Find(session, tenantDbConfig.Db, "weights", nil, "name", &results)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
output, err = createView(results, contentType) //Render the results into XML format
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
mongo.CloseSession(session)
return code, h, output, err
}
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)
}
// WrapAuthenticate handle wrapper to apply authentication
func WrapAuthenticate(hfn http.Handler, cfg config.Config, routeName string) http.HandlerFunc {
return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
var errs []ErrorResponse
// check if api admin authentication is needed (for tenants etc...)
if needsAPIAdmin(routeName) {
// Authenticate admin api and check
if (authentication.AuthenticateAdmin(r.Header, cfg)) == false {
// Because not authenticated respond with error
Error(w, r, ErrAuthen, cfg, errs)
return
}
// admin api authenticated so continue serving
context.Set(r, "authen", true)
context.Set(r, "roles", []string{"super_admin"})
hfn.ServeHTTP(w, r)
} else {
// authenticate tenant user
tenantConf, tErr := authentication.AuthenticateTenant(r.Header, cfg)
// If tenant user not authenticated respond with error
if tErr != nil {
Error(w, r, ErrAuthen, cfg, errs)
return
}
context.Set(r, "roles", tenantConf.Roles)
context.Set(r, "tenant_conf", tenantConf)
context.Set(r, "authen", true)
hfn.ServeHTTP(w, r)
}
})
}
// ListMetricTimelines returns a list of metric timelines
func ListMetricTimelines(r *http.Request, cfg config.Config) (int, http.Header, []byte, error) {
//STANDARD DECLARATIONS START
code := http.StatusOK
h := http.Header{}
output := []byte("List Metric Timelines")
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)
parsedStart, parsedEnd, errs := respond.ValidateDateRange(urlValues.Get("start_time"), urlValues.Get("end_time"))
if len(errs) > 0 {
code = http.StatusBadRequest
output = respond.CreateFailureResponseMessage("Bad Request", "400", errs).MarshalTo(contentType)
}
input := InputParams{
parsedStart,
parsedEnd,
vars["report_name"],
vars["group_type"],
vars["group_name"],
vars["service_name"],
vars["endpoint_name"],
vars["metric_name"],
contentType,
}
// Call authenticateTenant to check the api key and retrieve
// the correct tenant db conf
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output = []byte(http.StatusText(http.StatusUnauthorized))
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
// Mongo Session
results := []DataOutput{}
session, err := mongo.OpenSession(tenantDbConfig)
defer mongo.CloseSession(session)
metricCollection := session.DB(tenantDbConfig.Db).C("status_metrics")
// Query the detailed metric results
reportID, err := mongo.GetReportID(session, tenantDbConfig.Db, input.report)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
err = metricCollection.Find(prepareQuery(input, reportID)).All(&results)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
output, err = createView(results, input) //Render the results into XML format
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
// SubmitRecomputation insert a new pending recomputation in the tenants database
func SubmitRecomputation(r *http.Request, cfg config.Config) (int, http.Header, []byte, error) {
//STANDARD DECLARATIONS START
code := http.StatusAccepted
h := http.Header{}
output := []byte("")
err := error(nil)
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
}
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output, _ = respond.MarshalContent(respond.UnauthorizedMessage, contentType, "", " ")
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
return code, h, output, err
}
session, err := mongo.OpenSession(tenantDbConfig)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
var recompSubmission IncomingRecomputation
// urlValues := r.URL.Query()
body, err := ioutil.ReadAll(io.LimitReader(r.Body, cfg.Server.ReqSizeLimit))
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
if err := json.Unmarshal(body, &recompSubmission); err != nil {
code = 422 // unprocessable entity
output = []byte("Unprocessable JSON")
return code, h, output, err
}
now := time.Now()
recomputation := MongoInterface{
ID: mongo.NewUUID(),
RequesterName: tenantDbConfig.User,
RequesterEmail: tenantDbConfig.Email,
StartTime: recompSubmission.StartTime,
EndTime: recompSubmission.EndTime,
Reason: recompSubmission.Reason,
Report: recompSubmission.Report,
Exclude: recompSubmission.Exclude,
Timestamp: now.Format("2006-01-02 15:04:05"),
Status: "pending",
}
err = mongo.Insert(session, tenantDbConfig.Db, recomputationsColl, recomputation)
if err != nil {
panic(err)
}
output, err = createSubmitView(recomputation, contentType, r)
return code, h, output, err
}
// This function runs before any test and setups the environment
// A test configuration object is instantiated using a reference
// to testdb: argo_test_reports. Also here is are instantiated some expected
// xml response validation messages (authorization,crud responses).
// Also the testdb is seeded with two reports
func (suite *ReportTestSuite) SetupTest() {
// Connect to mongo testdb
session, _ := mongo.OpenSession(suite.cfg.MongoDB)
// Add authentication token to mongo testdb
seedAuth := bson.M{"api_key": "S3CR3T"}
_ = mongo.Insert(session, suite.cfg.MongoDB.Db, "authentication", seedAuth)
// seed mongo
session, err := mgo.Dial(suite.cfg.MongoDB.Host)
if err != nil {
panic(err)
}
defer session.Close()
// seed a tenant to use
c := session.DB(suite.cfg.MongoDB.Db).C("tenants")
c.Insert(bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50c",
"info": bson.M{
"name": "GUARDIANS",
"email": "email@something2",
"website": "www.gotg.com",
"created": "2015-10-20 02:08:04",
"updated": "2015-10-20 02:08:04"},
"db_conf": []bson.M{
bson.M{
"store": "ar",
"server": "localhost",
"port": 27017,
"database": "argo_test_tenant_reports2_db1",
"username": "******",
"password": "******"},
bson.M{
"store": "status",
"server": "b.mongodb.org",
"port": 27017,
"database": "reports_db_tenant",
"username": "******",
"password": "******"},
},
"users": []bson.M{
bson.M{
"name": "cap",
"email": "*****@*****.**",
"api_key": "C4PK3Y"},
bson.M{
"name": "thor",
"email": "*****@*****.**",
"api_key": "TH0RK3Y"},
}})
// get dbconfiguration based on the tenant
// Prepare the request object
request, _ := http.NewRequest("GET", "", strings.NewReader(""))
// add the content-type header to application/json
request.Header.Set("Accept", "application/json;")
// add the authentication token which is seeded in testdb
request.Header.Set("x-api-key", "C4PK3Y")
// authenticate user's api key and find corresponding tenant
suite.tenantDbConf, err = authentication.AuthenticateTenant(request.Header, suite.cfg)
c = session.DB(suite.tenantDbConf.Db).C("metric_profiles")
c.Insert(
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50b",
"name": "profile1",
"services": []bson.M{
bson.M{"service": "CREAM-CE",
"metrics": []string{
"emi.cream.CREAMCE-JobSubmit",
"emi.wn.WN-Bi",
"emi.wn.WN-Csh",
"emi.wn.WN-SoftVer"},
},
bson.M{"service": "SRMv2",
"metrics": []string{"hr.srce.SRM2-CertLifetime",
"org.sam.SRM-Del",
"org.sam.SRM-Get",
"org.sam.SRM-GetSURLs",
"org.sam.SRM-GetTURLs",
"org.sam.SRM-Ls",
"org.sam.SRM-LsDir",
"org.sam.SRM-Put"},
},
},
})
c.Insert(
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50c",
"name": "ch.cern.SAM.ROC",
"services": []bson.M{
bson.M{"service": "CREAM-CE",
"metrics": []string{
"emi.cream.CREAMCE-JobSubmit",
"emi.wn.WN-Bi",
"emi.wn.WN-Csh",
"hr.srce.CADist-Check",
"hr.srce.CREAMCE-CertLifetime",
"emi.wn.WN-SoftVer"},
},
bson.M{"service": "SRMv2",
"metrics": []string{"hr.srce.SRM2-CertLifetime",
"org.sam.SRM-Del",
"org.sam.SRM-Get",
"org.sam.SRM-GetSURLs",
"org.sam.SRM-GetTURLs",
"org.sam.SRM-Ls",
"org.sam.SRM-LsDir",
"org.sam.SRM-Put"},
},
},
})
c = session.DB(suite.tenantDbConf.Db).C("aggregation_profiles")
c.Insert(
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50bq",
"name": "profile3",
"namespace": "test",
"endpoint_group": "sites",
"metric_operation": "AND",
"profile_operation": "AND",
"metric_profile": bson.M{
"name": "roc.critical",
"id": "5637d684-1f8e-4a02-a502-720e8f11e432",
},
"groups": []bson.M{
bson.M{"name": "compute",
"operation": "OR",
"services": []bson.M{
bson.M{
"name": "CREAM-CE",
"operation": "AND",
},
bson.M{
"name": "ARC-CE",
"operation": "AND",
},
}},
bson.M{"name": "storage",
"operation": "OR",
"services": []bson.M{
bson.M{
"name": "SRMv2",
"operation": "AND",
},
bson.M{
"name": "SRM",
"operation": "AND",
},
}},
}})
c.Insert(
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50c",
"name": "cloud",
"namespace": "test",
"endpoint_group": "sites",
"metric_operation": "AND",
"profile_operation": "AND",
"metric_profile": bson.M{
"name": "roc.critical",
"id": "5637d684-1f8e-4a02-a502-720e8f11e432",
},
"groups": []bson.M{
bson.M{"name": "compute",
"operation": "OR",
"services": []bson.M{
bson.M{
"name": "SERVICEA",
"operation": "AND",
},
bson.M{
"name": "SERVICEB",
"operation": "AND",
},
}},
bson.M{"name": "images",
"operation": "OR",
"services": []bson.M{
bson.M{
"name": "SERVICEC",
"operation": "AND",
},
bson.M{
"name": "SERVICED",
"operation": "AND",
},
}},
}})
c = session.DB(suite.tenantDbConf.Db).C("operations_profiles")
c.Insert(
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e523",
"name": "profile2",
"available_states": []string{"A,B,C"},
"defaults": bson.M{
"missing": "A",
"down": "B",
"unknown": "C"},
"operations": []bson.M{
bson.M{
"name": "AND",
"truth_table": []bson.M{
bson.M{
"a": "A",
"b": "B",
"x": "B",
},
bson.M{
"a": "A",
"b": "C",
"x": "C",
},
bson.M{
"a": "B",
"b": "C",
"x": "C",
}}},
bson.M{
"name": "OR",
"truth_table": []bson.M{
bson.M{
"a": "A",
"b": "B",
"x": "A",
},
bson.M{
"a": "A",
"b": "C",
"x": "A",
},
bson.M{
"a": "B",
"b": "C",
"x": "B",
}}},
}})
// Now seed the report DEFINITIONS
c = session.DB(suite.tenantDbConf.Db).C(reportsColl)
c.Insert(bson.M{
"id": "eba61a9e-22e9-4521-9e47-ecaa4a494364",
"info": bson.M{
"name": "Report_A",
"description": "report aaaaa",
"created": "2015-9-10 13:43:00",
"updated": "2015-10-11 13:43:00",
},
"topology_schema": bson.M{
"group": bson.M{
"type": "NGI",
"group": bson.M{
"type": "SITE",
},
},
},
"profiles": []bson.M{
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50b",
"type": "metric",
"name": "profile1"},
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e523",
"type": "operations",
"name": "profile2"},
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50q",
"type": "aggregation",
"name": "profile3"},
},
"filter_tags": []bson.M{
bson.M{
"name": "name1",
"value": "value1"},
bson.M{
"name": "name2",
"value": "value2"},
}})
c.Insert(bson.M{
"id": "eba61a9e-22e9-4521-9e47-ecaa4a494360",
"info": bson.M{
"name": "Report_B",
"description": "report bbb",
"created": "2015-10-08 13:43:00",
"updated": "2015-10-09 13:43:00",
},
"topology_schema": bson.M{
"group": bson.M{
"type": "ARCHIPELAGO",
"group": bson.M{
"type": "ISLAND",
},
},
},
"profiles": []bson.M{
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50b",
"type": "metric",
"name": "profile1"},
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e523",
"type": "operations",
"name": "profile2"},
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50q",
"type": "aggregation",
"name": "profile3"},
},
"filter_tags": []bson.M{
bson.M{
"name": "name1",
"value": "value1"},
bson.M{
"name": "name2",
"value": "value2"},
}})
}
// 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
}
// Setup the Test Environment
// This function runs before any test and setups the environment
// A test configuration object is instantiated using a reference
// to testdb: argo_test_details. Also here is are instantiated some expected
// xml response validation messages (authorization,crud responses).
// Also the testdb is seeded with tenants,reports,metric_profiles and status_metrics
func (suite *metricResultTestSuite) SetupTest() {
const testConfig = `
[server]
bindip = ""
port = 8080
maxprocs = 4
cache = false
lrucache = 700000000
gzip = true
[mongodb]
host = "127.0.0.1"
port = 27017
db = "ARGO_test_metric_result"
`
_ = gcfg.ReadStringInto(&suite.cfg, testConfig)
suite.tenantDbConf.Db = "ARGO_test_metric_result"
suite.tenantDbConf.Password = "******"
suite.tenantDbConf.Username = "******"
suite.tenantDbConf.Store = "ar"
suite.clientkey = "KEY1"
// Create router and confhandler for test
suite.confHandler = respond.ConfHandler{suite.cfg}
suite.router = mux.NewRouter().StrictSlash(true).PathPrefix("/api/v2/metric_result").Subrouter()
HandleSubrouter(suite.router, &suite.confHandler)
// Connect to mongo testdb
session, _ := mongo.OpenSession(suite.cfg.MongoDB)
// Add authentication token to mongo testdb
seedAuth := bson.M{"api_key": "S3CR3T"}
_ = mongo.Insert(session, suite.cfg.MongoDB.Db, "authentication", seedAuth)
// seed mongo
session, err := mgo.Dial(suite.cfg.MongoDB.Host)
if err != nil {
panic(err)
}
defer session.Close()
// seed a tenant to use
c := session.DB(suite.cfg.MongoDB.Db).C("tenants")
c.Insert(bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50c",
"info": bson.M{
"name": "EGI",
"email": "email@something2",
"website": "www.gotg.com",
"created": "2015-10-20 02:08:04",
"updated": "2015-10-20 02:08:04"},
"db_conf": []bson.M{
bson.M{
"store": "main",
"server": "localhost",
"port": 27017,
"database": "ARGO_test_metric_result_egi",
"username": "",
"password": ""},
},
"users": []bson.M{
bson.M{
"name": "egi_user",
"email": "*****@*****.**",
"api_key": "KEY1"},
}})
// get dbconfiguration based on the tenant
// Prepare the request object
request, _ := http.NewRequest("GET", "", strings.NewReader(""))
// add the content-type header to application/json
request.Header.Set("Content-Type", "application/json;")
// add the authentication token which is seeded in testdb
request.Header.Set("x-api-key", "KEY1")
// authenticate user's api key and find corresponding tenant
suite.tenantDbConf, err = authentication.AuthenticateTenant(request.Header, suite.cfg)
// seed the status detailed metric data
c = session.DB(suite.tenantDbConf.Db).C("status_metrics")
c.Insert(bson.M{
"monitoring_box": "nagios3.hellasgrid.gr",
"date_integer": 20150501,
"timestamp": "2015-05-01T00:00:00Z",
"service": "CREAM-CE",
"host": "cream01.afroditi.gr",
"metric": "emi.cream.CREAMCE-JobSubmit",
"status": "OK",
"time_integer": 0,
"previous_state": "OK",
"previous_timestamp": "2015-04-30T23:59:00Z",
"summary": "Cream status is ok",
"message": "Cream job submission test return value of ok",
})
c.Insert(bson.M{
"monitoring_box": "nagios3.hellasgrid.gr",
"date_integer": 20150501,
"timestamp": "2015-05-01T01:00:00Z",
"service": "CREAM-CE",
"host": "cream01.afroditi.gr",
"metric": "emi.cream.CREAMCE-JobSubmit",
"status": "CRITICAL",
"time_integer": 10000,
"previous_state": "OK",
"previous_timestamp": "2015-05-01T00:00:00Z",
"summary": "Cream status is CRITICAL",
"message": "Cream job submission test failed",
})
c.Insert(bson.M{
"monitoring_box": "nagios3.hellasgrid.gr",
"date_integer": 20150501,
"timestamp": "2015-05-01T05:00:00Z",
"service": "CREAM-CE",
"host": "cream01.afroditi.gr",
"metric": "emi.cream.CREAMCE-JobSubmit",
"status": "OK",
"time_integer": 50000,
"previous_state": "CRITICAL",
"previous_timestamp": "2015-05-01T01:00:00Z",
"summary": "Cream status is ok",
"message": "Cream job submission test return value of ok",
})
}
// List the existing metric profiles for the tenant making the request
// Also there is an optional url param "name" to filter results by
func List(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 := "text/xml"
charset := "utf-8"
//STANDARD DECLARATIONS END
// Content Negotiation
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
}
urlValues := r.URL.Query()
// Tenant Authentication
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output, _ = respond.MarshalContent(respond.UnauthorizedMessage, contentType, "", " ")
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
return code, h, output, err
}
// Open session to tenant database
session, err := mongo.OpenSession(tenantDbConfig)
defer mongo.CloseSession(session)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// Retrieve Results from database
var filter interface{}
if len(urlValues["name"]) > 0 {
filter = bson.M{"name": urlValues["name"][0]}
} else {
filter = nil
}
results := []MongoInterface{}
err = mongo.Find(session, tenantDbConfig.Db, "metric_profiles", filter, "name", &results)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// Create view of the results
output, err = createListView(results, "Success", code) //Render the results into JSON
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
// Create function is used to implement the create report request.
// The request is an http POST request with the report description
// provided as json structure in the request body
func Create(r *http.Request, cfg config.Config) (int, http.Header, []byte, error) {
//STANDARD DECLARATIONS START
code := http.StatusCreated
h := http.Header{}
output := []byte("")
err := error(nil)
contentType := "text/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
}
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output, _ = respond.MarshalContent(respond.UnauthorizedMessage, contentType, "", " ")
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
return code, h, output, err
}
//Reading the json input from the request body
reqBody, err := ioutil.ReadAll(io.LimitReader(r.Body, cfg.Server.ReqSizeLimit))
if err != nil {
return code, h, output, err
}
input := MongoInterface{}
//Unmarshalling the json input into byte form
err = json.Unmarshal(reqBody, &input)
// Check if json body is malformed
if err != nil {
output, _ := respond.MarshalContent(respond.MalformedJSONInput, contentType, "", " ")
code = http.StatusBadRequest
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
// Try to open the mongo session
session, err := mongo.OpenSession(tenantDbConfig)
defer session.Close()
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// Validate profiles given in report
validationErrors := input.ValidateProfiles(session.DB(tenantDbConfig.Db))
if len(validationErrors) > 0 {
code = 422
out := respond.UnprocessableEntity
out.Errors = validationErrors
output = out.MarshalTo(contentType)
return code, h, output, err
}
// Prepare structure for storing query results
results := []MongoInterface{}
// Check if report with the same name exists in datastore
query := searchName(input.Info.Name)
err = mongo.Find(session, tenantDbConfig.Db, reportsColl, query, "name", &results)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// If results are returned for the specific name
// then we already have an existing report and we must
// abort creation notifing the user
if len(results) > 0 {
// Name was found so print the error message in xml
out := respond.ResponseMessage{
Status: respond.StatusResponse{
Message: "Report with the same name already exists",
Code: strconv.Itoa(http.StatusConflict),
}}
output, _ = respond.MarshalContent(out, contentType, "", " ")
code = http.StatusConflict
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
input.Info.Created = time.Now().Format("2006-01-02 15:04:05")
input.Info.Updated = input.Info.Created
input.ID = mongo.NewUUID()
// If no report exists with this name create a new one
err = mongo.Insert(session, tenantDbConfig.Db, reportsColl, input)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// Notify user that the report has been created. In xml style
selfLink := "https://" + r.Host + r.URL.Path + "/" + input.ID
output, err = SubmitSuccesful(input, contentType, selfLink)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
// Delete function used to implement remove report request
func Delete(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 := "text/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
}
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output, _ = respond.MarshalContent(respond.UnauthorizedMessage, contentType, "", " ")
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
return code, h, output, err
}
//Extracting record id from url
id := mux.Vars(r)["id"]
// Try to open the mongo session
session, err := mongo.OpenSession(tenantDbConfig)
defer session.Close()
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// We search by name and delete the document in db
query := bson.M{"id": id}
info, err := mongo.Remove(session, tenantDbConfig.Db, reportsColl, query)
if err != nil {
if err.Error() != "not found" {
code = http.StatusInternalServerError
return code, h, output, err
}
//Render the response into XML
code = http.StatusNotFound
output, err = ReportNotFound(contentType)
return code, h, output, err
}
// info.Removed > 0 means that many documents have been removed
// If deletion took place we notify user accordingly.
// Else we notify that no tenant matched the specific name
if info.Removed > 0 {
code = http.StatusOK
output, err = respond.CreateResponseMessage("Report was successfully deleted", "200", contentType)
} else {
code = http.StatusNotFound
output, err = ReportNotFound(contentType)
}
//Render the response into XML
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
return code, h, output, err
}
// Update function used to implement update report request.
// This is an http PUT request that gets a specific report's name
// as a urlvar parameter input and a json structure in the request
// body in order to update the datastore document for the specific
// report
func Update(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 := "text/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
}
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output, _ = respond.MarshalContent(respond.UnauthorizedMessage, contentType, "", " ")
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
return code, h, output, err
}
//Extracting report name from url
id := mux.Vars(r)["id"]
//Reading the json input
reqBody, err := ioutil.ReadAll(r.Body)
input := MongoInterface{}
//Unmarshalling the json input into byte form
err = json.Unmarshal(reqBody, &input)
if err != nil {
// User provided malformed json input data
output, _ := respond.MarshalContent(respond.MalformedJSONInput, contentType, "", " ")
code = http.StatusBadRequest
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
sanitizedInput := bson.M{
"$set": bson.M{
// "info": bson.M{
"info.name": input.Info.Name,
"info.description": input.Info.Description,
"info.updated": time.Now().Format("2006-01-02 15:04:05"),
// },
"profiles": input.Profiles,
"filter_tags": input.Tags,
"topology_schema": input.Topology,
}}
// Try to open the mongo session
session, err := mongo.OpenSession(tenantDbConfig)
defer session.Close()
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// Validate profiles given in report
validationErrors := input.ValidateProfiles(session.DB(tenantDbConfig.Db))
if len(validationErrors) > 0 {
code = 422
out := respond.UnprocessableEntity
out.Errors = validationErrors
output = out.MarshalTo(contentType)
return code, h, output, err
}
// We search by name and update
query := bson.M{"id": id}
err = mongo.Update(session, tenantDbConfig.Db, reportsColl, query, sanitizedInput)
if err != nil {
if err.Error() != "not found" {
code = http.StatusInternalServerError
return code, h, output, err
}
//Render the response into XML
code = http.StatusNotFound
output, err = ReportNotFound(contentType)
return code, h, output, err
}
//Render the response into XML
output, err = respond.CreateResponseMessage("Report was successfully updated", "200", contentType)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
code = http.StatusOK
return code, h, output, err
}
// ListOne function that implements the http GET request that retrieves
// all avaiable report information
func ListOne(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 := "text/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
}
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output, _ = respond.MarshalContent(respond.UnauthorizedMessage, contentType, "", " ")
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
return code, h, output, err
}
//Extracting urlvar "name" from url path
id := mux.Vars(r)["id"]
// Try to open the mongo session
session, err := mongo.OpenSession(tenantDbConfig)
defer session.Close()
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// Create structure for storing query results
result := MongoInterface{}
// Create a simple query object to query by name
query := bson.M{"id": id}
// Query collection tenants for the specific tenant name
err = mongo.FindOne(session, tenantDbConfig.Db, reportsColl, query, &result)
// If query returned zero result then no tenant matched this name,
// abort and notify user accordingly
if err != nil {
code = http.StatusNotFound
output, _ := ReportNotFound(contentType)
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
// After successfully retrieving the db results
// call the createView function to render them into idented xml
output, err = createView([]MongoInterface{result}, contentType)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
code = http.StatusOK
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
// List function that implements the http GET request that retrieves
// all avaiable report information
func List(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 := "text/xml"
charset := "utf-8"
//STANDARD DECLARATIONS END
urlValues := r.URL.Query()
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
}
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output, _ = respond.MarshalContent(respond.UnauthorizedMessage, contentType, "", " ")
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
return code, h, output, err
}
// Try to open the mongo session
session, err := mongo.OpenSession(cfg.MongoDB)
defer session.Close()
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
query := bson.M{}
if urlValues.Get("name") != "" {
query["info.name"] = urlValues["name"]
}
// Create structure for storing query results
results := []MongoInterface{}
// Query tenant collection for all available documents.
// nil query param == match everything
err = mongo.Find(session, tenantDbConfig.Db, reportsColl, nil, "id", &results)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// After successfully retrieving the db results
// call the createView function to render them into idented xml
output, err = createView(results, contentType)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
//Create a new metric profile
func Create(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
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
}
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output, _ = respond.MarshalContent(respond.UnauthorizedMessage, contentType, "", " ")
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
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
}
incoming := OpsProfile{}
// Try ingest request body
body, err := ioutil.ReadAll(io.LimitReader(r.Body, cfg.Server.ReqSizeLimit))
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
// Parse body json
if err := json.Unmarshal(body, &incoming); err != nil {
output, _ = respond.MarshalContent(respond.BadRequestBadJSON, contentType, "", " ")
code = 400
return code, h, output, err
}
// Validate States
var errList []string
errList = append(errList, incoming.validateDuplicates()...)
errList = append(errList, incoming.validateStates()...)
errList = append(errList, incoming.validateMentions()...)
if len(errList) > 0 {
output, err = createErrView("Validation Error", 422, errList)
code = 422
return code, h, output, err
}
// Generate new id
incoming.ID = mongo.NewUUID()
err = mongo.Insert(session, tenantDbConfig.Db, "operations_profiles", incoming)
if err != nil {
panic(err)
}
// Create view of the results
output, err = createRefView(incoming, "Operations Profile successfully created", 201, r) //Render the results into JSON
code = 201
return code, h, output, err
}
//Update function to update contents of an existing metric profile
func Update(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
vars := mux.Vars(r)
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
}
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output, _ = respond.MarshalContent(respond.UnauthorizedMessage, contentType, "", " ")
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
return code, h, output, err
}
incoming := OpsProfile{}
// ingest body data
body, err := ioutil.ReadAll(io.LimitReader(r.Body, cfg.Server.ReqSizeLimit))
if err != nil {
panic(err)
}
if err := r.Body.Close(); err != nil {
panic(err)
}
// parse body json
if err := json.Unmarshal(body, &incoming); err != nil {
output, _ = respond.MarshalContent(respond.BadRequestBadJSON, contentType, "", " ")
code = 400
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
}
// create filter to retrieve specific profile with id
filter := bson.M{"id": vars["ID"]}
incoming.ID = vars["ID"]
// Retrieve Results from database
results := []OpsProfile{}
err = mongo.Find(session, tenantDbConfig.Db, "operations_profiles", filter, "name", &results)
if err != nil {
panic(err)
}
// Check if nothing found
if len(results) < 1 {
output, _ = respond.MarshalContent(respond.NotFound, contentType, "", " ")
code = 404
return code, h, output, err
}
// Validate States
var errList []string
errList = append(errList, incoming.validateDuplicates()...)
errList = append(errList, incoming.validateStates()...)
errList = append(errList, incoming.validateMentions()...)
if len(errList) > 0 {
output, err = createErrView("Validation Error", 422, errList)
code = 422
return code, h, output, err
}
// run the update query
err = mongo.Update(session, tenantDbConfig.Db, "operations_profiles", filter, incoming)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// Create view for response message
output, err = createMsgView("Operations Profile successfully updated", 200) //Render the results into JSON
code = 200
return code, h, output, err
}
func routeGroup(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
// 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 {
if err.Error() == "Unauthorized" {
code = http.StatusUnauthorized
message := err.Error()
output, err = createErrorMessage(message, contentType)
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
code = http.StatusInternalServerError
return code, h, output, err
}
session, err := mongo.OpenSession(tenantcfg)
defer mongo.CloseSession(session)
if err != nil {
return code, h, output, err
}
requestedReport := reports.MongoInterface{}
err = mongo.FindOne(session, tenantcfg.Db, "reports", bson.M{"info.name": vars["report_name"]}, &requestedReport)
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
}
selectedGroupType := requestedReport.DetermineGroupType(vars["group_type"])
if selectedGroupType == "endpoint" {
if vars["lgroup_type"] == "" {
vars["lgroup_type"] = vars["group_type"]
vars["lgroup_name"] = vars["group_name"]
vars["group_type"] = ""
vars["group_name"] = ""
}
return ListEndpointGroupResults(r, cfg)
} else if selectedGroupType == "group" {
return ListSuperGroupResults(r, cfg)
}
code = http.StatusBadRequest
message := "The report " + vars["report_name"] + " does not define any group type: " + vars["group_type"]
output, err = createErrorMessage(message, format) //Render the response into XML or JSON
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", format, charset))
return code, h, output, err
}
// ListOne handles the listing of one specific profile based on its given id
func ListOne(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 := "text/xml"
charset := "utf-8"
//STANDARD DECLARATIONS END
// Content Negotiation
contentType, err = respond.ParseAcceptHeader(r)
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
vars := mux.Vars(r)
if err != nil {
code = http.StatusNotAcceptable
output, _ = respond.MarshalContent(respond.NotAcceptableContentType, contentType, "", " ")
return code, h, output, err
}
// Tenant Authentication
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
output, _ = respond.MarshalContent(respond.UnauthorizedMessage, contentType, "", " ")
code = http.StatusUnauthorized //If wrong api key is passed we return UNAUTHORIZED http status
return code, h, output, err
}
// Open session to tenant database
session, err := mongo.OpenSession(tenantDbConfig)
defer mongo.CloseSession(session)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
filter := bson.M{"id": vars["ID"]}
// Retrieve Results from database
results := []OpsProfile{}
err = mongo.Find(session, tenantDbConfig.Db, "operations_profiles", filter, "name", &results)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
// Check if nothing found
if len(results) < 1 {
output, _ = respond.MarshalContent(respond.NotFound, contentType, "", " ")
code = 404
return code, h, output, err
}
// Create view of the results
output, err = createListView(results, "Success", code) //Render the results into JSON
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
// Setup the Test Environment
// This function runs before any test and setups the environment
// A test configuration object is instantiated using a reference
// to testdb: argo_test_details. Also here is are instantiated some expected
// xml response validation messages (authorization,crud responses).
// Also the testdb is seeded with tenants,reports,metric_profiles and status_metrics
func (suite *StatusEndpointGroupsTestSuite) SetupTest() {
const testConfig = `
[server]
bindip = ""
port = 8080
maxprocs = 4
cache = false
lrucache = 700000000
gzip = true
[mongodb]
host = "127.0.0.1"
port = 27017
db = "argotest_egroups"
`
_ = gcfg.ReadStringInto(&suite.cfg, testConfig)
// Create router and confhandler for test
suite.confHandler = respond.ConfHandler{suite.cfg}
suite.router = mux.NewRouter().StrictSlash(true).PathPrefix("/api/v2/status").Subrouter()
HandleSubrouter(suite.router, &suite.confHandler)
// Connect to mongo testdb
session, _ := mongo.OpenSession(suite.cfg.MongoDB)
// Add authentication token to mongo testdb
seedAuth := bson.M{"api_key": "S3CR3T"}
_ = mongo.Insert(session, suite.cfg.MongoDB.Db, "authentication", seedAuth)
// seed mongo
session, err := mgo.Dial(suite.cfg.MongoDB.Host)
if err != nil {
panic(err)
}
defer session.Close()
// seed a tenant to use
c := session.DB(suite.cfg.MongoDB.Db).C("tenants")
c.Insert(bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50c",
"info": bson.M{
"name": "GUARDIANS",
"email": "email@something2",
"website": "www.gotg.com",
"created": "2015-10-20 02:08:04",
"updated": "2015-10-20 02:08:04"},
"db_conf": []bson.M{
bson.M{
"store": "main",
"server": "localhost",
"port": 27017,
"database": "argotest_egroups_egi",
"username": "",
"password": ""},
},
"users": []bson.M{
bson.M{
"name": "egi_user",
"email": "*****@*****.**",
"api_key": "KEY1"},
}})
c.Insert(bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50d",
"info": bson.M{
"name": "AVENGERS",
"email": "email@something2",
"website": "www.gotg.com",
"created": "2015-10-20 02:08:04",
"updated": "2015-10-20 02:08:04"},
"db_conf": []bson.M{
bson.M{
"store": "main",
"server": "localhost",
"port": 27017,
"database": "argotest_egroups_eudat",
"username": "",
"password": ""},
},
"users": []bson.M{
bson.M{
"name": "eudat_user",
"email": "*****@*****.**",
"api_key": "KEY2"},
}})
// get dbconfiguration based on the tenant
// Prepare the request object
request, _ := http.NewRequest("GET", "", strings.NewReader(""))
// add the content-type header to application/json
request.Header.Set("Content-Type", "application/json")
// add the authentication token which is seeded in testdb
request.Header.Set("x-api-key", "KEY1")
// authenticate user's api key and find corresponding tenant
suite.tenantDbConf, err = authentication.AuthenticateTenant(request.Header, suite.cfg)
// Now seed the report DEFINITIONS
c = session.DB(suite.tenantDbConf.Db).C("reports")
c.Insert(bson.M{
"id": "eba61a9e-22e9-4521-9e47-ecaa4a494364",
"info": bson.M{
"name": "Report_A",
"description": "report aaaaa",
"created": "2015-9-10 13:43:00",
"updated": "2015-10-11 13:43:00",
},
"topology_schema": bson.M{
"group": bson.M{
"type": "NGI",
"group": bson.M{
"type": "SITES",
},
},
},
"profiles": []bson.M{
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50b",
"type": "metric",
"name": "profile1"},
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e523",
"type": "operations",
"name": "profile2"},
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50q",
"type": "aggregation",
"name": "profile3"},
},
"filter_tags": []bson.M{
bson.M{
"name": "name1",
"value": "value1"},
bson.M{
"name": "name2",
"value": "value2"},
}})
// seed the status detailed metric data
c = session.DB(suite.tenantDbConf.Db).C("status_endpoint_groups")
c.Insert(bson.M{
"report": "eba61a9e-22e9-4521-9e47-ecaa4a494364",
"date_integer": 20150501,
"timestamp": "2015-05-01T00:00:00Z",
"endpoint_group": "HG-03-AUTH",
"status": "OK",
})
c.Insert(bson.M{
"report": "eba61a9e-22e9-4521-9e47-ecaa4a494364",
"date_integer": 20150501,
"timestamp": "2015-05-01T01:00:00Z",
"endpoint_group": "HG-03-AUTH",
"status": "CRITICAL",
})
c.Insert(bson.M{
"report": "eba61a9e-22e9-4521-9e47-ecaa4a494364",
"date_integer": 20150501,
"timestamp": "2015-05-01T05:00:00Z",
"endpoint_group": "HG-03-AUTH",
"status": "OK",
})
// get dbconfiguration based on the tenant
// Prepare the request object
request, _ = http.NewRequest("GET", "", strings.NewReader(""))
// add the content-type header to application/json
request.Header.Set("Content-Type", "application/json")
// add the authentication token which is seeded in testdb
request.Header.Set("x-api-key", "KEY2")
// authenticate user's api key and find corresponding tenant
suite.tenantDbConf, err = authentication.AuthenticateTenant(request.Header, suite.cfg)
// Now seed the reports DEFINITIONS
c = session.DB(suite.tenantDbConf.Db).C("reports")
c.Insert(bson.M{
"id": "eba61a9e-22e9-4521-9e47-ecaa4a494365",
"info": bson.M{
"name": "Report_B",
"description": "report aaaaa",
"created": "2015-9-10 13:43:00",
"updated": "2015-10-11 13:43:00",
},
"topology_schema": bson.M{
"group": bson.M{
"type": "EUDAT_GROUPS",
"group": bson.M{
"type": "EUDAT_SITES",
},
},
},
"profiles": []bson.M{
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50b",
"type": "metric",
"name": "eudat.CRITICAL"},
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e523",
"type": "operations",
"name": "profile2"},
bson.M{
"id": "6ac7d684-1f8e-4a02-a502-720e8f11e50q",
"type": "aggregation",
"name": "profile3"},
},
"filter_tags": []bson.M{
bson.M{
"name": "name1",
"value": "value1"},
bson.M{
"name": "name2",
"value": "value2"},
}})
// seed the status detailed metric data
c = session.DB(suite.tenantDbConf.Db).C("status_endpoint_groups")
c.Insert(bson.M{
"report": "eba61a9e-22e9-4521-9e47-ecaa4a494365",
"date_integer": 20150501,
"timestamp": "2015-05-01T00:00:00Z",
"endpoint_group": "EL-01-AUTH",
"status": "OK",
})
c.Insert(bson.M{
"report": "eba61a9e-22e9-4521-9e47-ecaa4a494365",
"date_integer": 20150501,
"timestamp": "2015-05-01T01:00:00Z",
"endpoint_group": "EL-01-AUTH",
"status": "CRITICAL",
})
c.Insert(bson.M{
"report": "eba61a9e-22e9-4521-9e47-ecaa4a494365",
"date_integer": 20150501,
"timestamp": "2015-05-01T05:00:00Z",
"endpoint_group": "EL-01-AUTH",
"status": "OK",
})
}
// GetMetricResult returns the detailed message from a probe
func GetMetricResult(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
tenantDbConfig, err := authentication.AuthenticateTenant(r.Header, cfg)
if err != nil {
if err.Error() == "Unauthorized" {
code = http.StatusUnauthorized
return code, h, output, err
}
code = http.StatusInternalServerError
return code, h, output, err
}
// Parse the request into the input
urlValues := r.URL.Query()
vars := mux.Vars(r)
input := metricResultQuery{
EndpointName: vars["endpoint_name"],
MetricName: vars["metric_name"],
Format: r.Header.Get("Accept"),
ExecTime: urlValues.Get("exec_time"),
}
// TODO: Decide which format (xml or json) should be the default
if input.Format == "application/xml" {
contentType = "application/xml"
} else if input.Format == "application/json" {
contentType = "application/json"
}
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
session, err := mongo.OpenSession(tenantDbConfig)
defer mongo.CloseSession(session)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
result := metricResultOutput{}
metricCol := session.DB(tenantDbConfig.Db).C("status_metrics")
// Query the detailed metric results
err = metricCol.Find(prepQuery(input)).One(&result)
output, err = createMetricResultView(result, input.Format)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
return code, h, output, err
}