// 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", }) }