// HasResourceRoles returns if a resource has the roles given
func HasResourceRoles(cfg config.Config, resource string, roles []string) bool {
session, err := mongo.OpenSession(cfg.MongoDB)
defer mongo.CloseSession(session)
if err != nil {
panic(err)
}
var results []QRole
query := bson.M{"resource": resource, "roles": bson.M{"$in": roles}}
err = mongo.Find(session, cfg.MongoDB.Db, "roles", query, "resource", &results)
if err != nil {
log.Fatal(err)
}
if len(results) > 0 {
return true
}
return false
}
// This function is actually called in the end of all tests
// and clears the test environment.
// Mainly it's purpose is to drop the testdb
func (suite *AvProfileTestSuite) TearDownTest() {
session, _ := mongo.OpenSession(suite.cfg)
session.DB("AR_test").DropDatabase()
}
// TestListFactors will run unit tests against the List function
func (suite *FactorsTestSuite) TestListFactors() {
suite.respFactorsList = `<root>
<Factor site="CETA-GRID" weight="5406"></Factor>
<Factor site="CFP-IST" weight="1019"></Factor>
<Factor site="CIEMAT-LCG2" weight="14595"></Factor>
</root>`
// Prepare the request object
request, _ := http.NewRequest("GET", "/api/v2/factors", strings.NewReader(""))
// add the authentication token which is seeded in testdb
request.Header.Set("x-api-key", "secret")
request.Header.Set("Accept", "application/xml")
// Execute the request in the controller
response := httptest.NewRecorder()
suite.router.ServeHTTP(response, request)
code := response.Code
output := response.Body.String()
suite.Equal(200, code, "Something went wrong")
suite.Equal(suite.respFactorsList, string(output), "Response body mismatch")
// Prepare new request object
request, _ = http.NewRequest("GET", "/api/v2/factors", strings.NewReader(""))
// add the authentication token which is seeded in testdb
request.Header.Set("x-api-key", "wrongkey")
request.Header.Set("Accept", "application/xml")
// Execute the request in the controller
response = httptest.NewRecorder()
suite.router.ServeHTTP(response, request)
code = response.Code
output = response.Body.String()
suite.Equal(401, code, "Should have gotten return code 401 (Unauthorized)")
suite.Equal(suite.respUnauthorized, string(output), "Should have gotten reply Unauthorized")
// Remove the test data from core db not to contaminate other tests
// Open session to core mongo
session, err := mongo.OpenSession(suite.cfg.MongoDB)
if err != nil {
panic(err)
}
defer mongo.CloseSession(session)
// Open collection authentication
c := session.DB(suite.cfg.MongoDB.Db).C("authentication")
// Remove the specific entries inserted during this test
c.Remove(bson.M{"name": "John Doe"})
// Remove the test data from tenant db not to contaminate other tests
// Open session to tenant mongo
session, err = mgo.Dial(suite.tenantcfg.Host)
if err != nil {
panic(err)
}
defer mongo.CloseSession(session)
// Open collection authentication
c = session.DB(suite.tenantcfg.Db).C("weights")
// Remove the specific entries inserted during this test
c.Remove(bson.M{"name": "CIEMAT-LCG2"})
c.Remove(bson.M{"name": "CFP-IST"})
c.Remove(bson.M{"name": "CETA-GRID"})
}
// AuthenticateTenant is used to find which tenant the user making the requests
// belongs to and return the database configuration for that specific tenant.
// If the api-key in the request is not found in any tenant an empty configuration is
// returned along with an error
func AuthenticateTenant(h http.Header, cfg config.Config) (config.MongoConfig, error) {
session, err := mongo.OpenSession(cfg.MongoDB)
if err != nil {
return config.MongoConfig{}, err
}
defer mongo.CloseSession(session)
apiKey := h.Get("x-api-key")
query := bson.M{"users.api_key": apiKey}
projection := bson.M{"_id": 0, "name": 1, "db_conf": 1, "users": 1}
var results []map[string][]config.MongoConfig
mongo.FindAndProject(session, cfg.MongoDB.Db, "tenants", query, projection, "server", &results)
if len(results) == 0 {
return config.MongoConfig{}, errors.New("Unauthorized")
}
mongoConf := results[0]["db_conf"][0]
// mongoConf := config.MongoConfig{
// Host: conf["server"].(string),
// Port: conf["port"].(int),
// Db: conf["database"].(string),
// Username: conf["username"].(string),
// Password: conf["password"].(string),
// Store: conf["store"].(string),
// }
for _, user := range results[0]["users"] {
if user.ApiKey == apiKey {
mongoConf.User = user.User
mongoConf.Email = user.Email
}
}
return mongoConf, nil
}
// SetupTest will bootstrap and provide the testing environment
func (suite *FactorsTestSuite) SetupTest() {
// Connect to mongo coredb
session, err := mongo.OpenSession(suite.cfg.MongoDB)
defer mongo.CloseSession(session)
if err != nil {
panic(err)
}
// Add authentication token to mongo coredb
seedAuth := bson.M{"name": "TEST",
"db_conf": []bson.M{bson.M{"server": "127.0.0.1", "port": 27017, "database": "AR_test"}},
"users": []bson.M{bson.M{"name": "Jack Doe", "email": "*****@*****.**", "api_key": "secret", "roles": []string{"viewer"}}}}
_ = mongo.Insert(session, suite.cfg.MongoDB.Db, "tenants", seedAuth)
// Add a few factors in collection
c := session.DB(suite.tenantcfg.Db).C("weights")
c.Insert(bson.M{"hepspec": 14595, "name": "CIEMAT-LCG2"})
c.Insert(bson.M{"hepspec": 1019, "name": "CFP-IST"})
c.Insert(bson.M{"hepspec": 5406, "name": "CETA-GRID"})
c = session.DB(suite.cfg.MongoDB.Db).C("roles")
c.Insert(
bson.M{
"resource": "factors.list",
"roles": []string{"editor", "viewer"},
})
}
func Authenticate(h http.Header, cfg config.Config) bool {
session, err := mongo.OpenSession(cfg.MongoDB)
defer mongo.CloseSession(session)
if err != nil {
panic(err)
}
query := bson.M{
"apiKey": h.Get("x-api-key"),
}
results := []Auth{}
err = mongo.Find(session, cfg.MongoDB.Db, "authentication", query, "apiKey", &results)
if err != nil {
return false
}
if len(results) > 0 {
return true
}
return false
}
// This function is actually called in the end of all tests
// and clears the test environment.
// Mainly it's purpose is to drop the testdb
func (suite *metricResultTestSuite) TearDownTest() {
session, _ := mongo.OpenSession(suite.cfg.MongoDB)
session.DB("ARGO_test_metric_result").DropDatabase()
session.DB("ARGO_test_metric_result_egi").DropDatabase()
}
// 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)
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))
vars := mux.Vars(r)
// Grab Tenant DB configuration from context
tenantDbConfig := context.Get(r, "tenant_conf").(config.MongoConfig)
// 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 := []MongoInterface{}
err = mongo.Find(session, tenantDbConfig.Db, "metric_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
}
// This function is actually called in the end of all tests
// and clears the test environment.
// Mainly it's purpose is to drop the testdb
func (suite *StatusMetricsTestSuite) TearDownTest() {
session, _ := mongo.OpenSession(suite.cfg.MongoDB)
session.DB("argotest_metrics").DropDatabase()
session.DB("argotest_metrics_tenant2").DropDatabase()
session.DB("argotest_metrics_egi").DropDatabase()
}
// This function is actually called in the end of all tests
// and clears the test environment.
// Mainly it's purpose is to drop the testdb
func (suite *StatusEndpointGroupsTestSuite) TearDownTest() {
session, _ := mongo.OpenSession(suite.cfg.MongoDB)
session.DB("argotest_egroups").DropDatabase()
session.DB("argotest_egroups_eudat").DropDatabase()
session.DB("argotest_egroups_egi").DropDatabase()
}
// This function is actually called in the end of all tests
// and clears the test environment.
// Mainly it's purpose is to drop the testdb
func (suite *StatusServicesTestSuite) TearDownTest() {
session, _ := mongo.OpenSession(suite.cfg.MongoDB)
session.DB("argotest_services").DropDatabase()
session.DB("argotest_services_eudat").DropDatabase()
session.DB("argotest_services_egi").DropDatabase()
}
// 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)
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))
// Grab Tenant DB configuration from context
tenantDbConfig := context.Get(r, "tenant_conf").(config.MongoConfig)
//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 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)
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))
urlValues := r.URL.Query()
// Grab Tenant DB configuration from context
tenantDbConfig := context.Get(r, "tenant_conf").(config.MongoConfig)
// 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
}
// 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
}
// ListOne function implement an http GET request that accepts
// a name parameter urlvar and retrieves information only for the
// specific tenant
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)
charset := "utf-8"
//STANDARD DECLARATIONS END
vars := mux.Vars(r)
// Set Content-Type response Header value
contentType := r.Header.Get("Accept")
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
// 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
}
// Create structure to hold query results
results := []Tenant{}
// Create a simple query object to query by id
query := bson.M{"id": vars["ID"]}
// Query collection tenants for the specific tenant id
err = mongo.Find(session, cfg.MongoDB.Db, "tenants", query, "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 = http.StatusNotFound
return code, h, output, err
}
// After successfully retrieving the db results
// call the createView function to render them into idented xml
output, err = createListView(results, "Success", code)
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
}
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)
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 {
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.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
}
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.StatusNotFound
message := "The report " + vars["report_name"] + " does not define any group type: " + vars["group_type"]
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
}
// 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)
charset := "utf-8"
//STANDARD DECLARATIONS END
urlValues := r.URL.Query()
// Set Content-Type response Header value
contentType := r.Header.Get("Accept")
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
// Grab Tenant DB configuration from context
tenantDbConfig := context.Get(r, "tenant_conf").(config.MongoConfig)
// 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
}
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
//Read the search values
urlValues := r.URL.Query()
//Searchig is based on name and namespace
input := AvailabilityProfileSearch{
urlValues["name"],
urlValues["namespace"],
}
results := []AvailabilityProfileOutput{}
session, err := mongo.OpenSession(cfg)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
query := readOne(input)
if len(input.Name) == 0 {
query = nil //If no name and namespace is provided then we have to retrieve all profiles thus we send nil into db query
}
err = mongo.Find(session, cfg.MongoDB.Db, "aps", query, "_id", &results)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
mongo.CloseSession(session)
output, err = createView(results) //Render the results into XML format
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
// Set Content-Type response Header value
contentType := r.Header.Get("Accept")
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
// 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
}
incoming := MongoInterface{}
// 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
}
// Generate new id
incoming.ID = mongo.NewUUID()
err = mongo.Insert(session, tenantDbConfig.Db, "metric_profiles", incoming)
if err != nil {
panic(err)
}
// Create view of the results
output, err = createRefView(incoming, "Metric Profile successfully created", 201, r) //Render the results into JSON
code = 201
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
}
// Grab Tenant DB configuration from context
tenantDbConfig := context.Get(r, "tenant_conf").(config.MongoConfig)
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
}
// 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)
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))
// Grab Tenant DB configuration from context
tenantDbConfig := context.Get(r, "tenant_conf").(config.MongoConfig)
// Parse the request into the input
urlValues := r.URL.Query()
vars := mux.Vars(r)
input := metricResultQuery{
EndpointName: vars["endpoint_name"],
MetricName: vars["metric_name"],
ExecTime: urlValues.Get("exec_time"),
}
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, contentType)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
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)
}
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)
}
// 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)
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))
urlValues := r.URL.Query()
// Grab Tenant DB configuration from context
tenantDbConfig := context.Get(r, "tenant_conf").(config.MongoConfig)
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 function that implements the http GET request that retrieves
// all avaiable tenant 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)
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))
// 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
}
// Create structure for storing query results
results := []Tenant{}
// Query tenant collection for all available documents.
// nil query param == match everything
err = mongo.Find(session, cfg.MongoDB.Db, "tenants", nil, "name", &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 = createListView(results, "Success", code)
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
}
// ListOne lists a single recomputation according to the 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 := "application/json"
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))
vars := mux.Vars(r)
// Grab Tenant DB configuration from context
tenantDbConfig := context.Get(r, "tenant_conf").(config.MongoConfig)
filter := IncomingRecomputation{
ID: vars["ID"],
}
session, err := mongo.OpenSession(tenantDbConfig)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
result := MongoInterface{}
err = mongo.FindOne(session, tenantDbConfig.Db, recomputationsColl, filter, &result)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
output, err = createListView(result, contentType)
return code, h, output, err
}
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
session, err := mongo.OpenSession(cfg)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
results := []FactorsOutput{}
err = mongo.Find(session, "AR", "hepspec", nil, "p", &results)
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
output, err = createView(results) //Render the results into XML format
if err != nil {
code = http.StatusInternalServerError
return code, h, output, err
}
mongo.CloseSession(session)
h.Set("Content-Type", fmt.Sprintf("%s; charset=%s", contentType, charset))
return code, h, output, err
}
// AuthenticateAdmin is used to authenticate and administrator of ARGO
// and allow further CRUD ops wrt the argo_core database (i.e. add a new
// tenant, modify another tenant's configuration etc)
func AuthenticateAdmin(h http.Header, cfg config.Config) bool {
session, err := mongo.OpenSession(cfg.MongoDB)
defer mongo.CloseSession(session)
if err != nil {
panic(err)
}
query := bson.M{"api_key": h.Get("x-api-key")}
projection := bson.M{"_id": 0, "name": 0, "email": 0}
results := []Auth{}
err = mongo.FindAndProject(session, cfg.MongoDB.Db, "authentication", query, projection, "api_key", &results)
if err != nil {
return false
}
if len(results) > 0 {
return true
}
return false
}
// 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",
})
}
