aboutsummaryrefslogtreecommitdiffstats
path: root/app/api/responders/resource
diff options
context:
space:
mode:
Diffstat (limited to 'app/api/responders/resource')
-rw-r--r--app/api/responders/resource/aggregates.py7
-rw-r--r--app/api/responders/resource/clique_constraints.py14
-rw-r--r--app/api/responders/resource/clique_types.py26
-rw-r--r--app/api/responders/resource/cliques.py16
-rw-r--r--app/api/responders/resource/connection_tests.py169
-rw-r--r--app/api/responders/resource/environment_configs.py160
-rw-r--r--app/api/responders/resource/inventory.py6
-rw-r--r--app/api/responders/resource/links.py12
-rw-r--r--app/api/responders/resource/messages.py10
-rw-r--r--app/api/responders/resource/monitoring_config_templates.py11
-rw-r--r--app/api/responders/resource/scans.py1
-rw-r--r--app/api/responders/resource/scheduled_scans.py32
12 files changed, 331 insertions, 133 deletions
diff --git a/app/api/responders/resource/aggregates.py b/app/api/responders/resource/aggregates.py
index 36fcfa4..d0b8031 100644
--- a/app/api/responders/resource/aggregates.py
+++ b/app/api/responders/resource/aggregates.py
@@ -31,10 +31,9 @@ class Aggregates(ResponderBase):
requirement=self.AGGREGATE_TYPES,
mandatory=True,
error_messages={"mandatory":
- "type must be specified: " +
- "environment/" +
- " message/" +
- "constant"})
+ "type must be specified: (" +
+ ",".join(self.AGGREGATE_TYPES) +
+ ")"})
}
self.validate_query_data(filters, filters_requirements)
query = self.build_query(filters)
diff --git a/app/api/responders/resource/clique_constraints.py b/app/api/responders/resource/clique_constraints.py
index eddead9..09fa782 100644
--- a/app/api/responders/resource/clique_constraints.py
+++ b/app/api/responders/resource/clique_constraints.py
@@ -26,12 +26,13 @@ class CliqueConstraints(ResponderBase):
filters = self.parse_query_params(req)
focal_point_types = self.get_constants_by_name("object_types")
filters_requirements = {
- 'id': self.require(ObjectId, True),
- 'focal_point_type': self.require(str, False, DataValidate.LIST,
- focal_point_types),
+ 'id': self.require(ObjectId, convert_to_type=True),
+ 'focal_point_type': self.require(str,
+ validate=DataValidate.LIST,
+ requirement=focal_point_types),
'constraint': self.require([list, str]),
- 'page': self.require(int, True),
- 'page_size': self.require(int, True)
+ 'page': self.require(int, convert_to_type=True),
+ 'page_size': self.require(int, convert_to_type=True)
}
self.validate_query_data(filters, filters_requirements)
page, page_size = self.get_pagination(filters)
@@ -44,7 +45,8 @@ class CliqueConstraints(ResponderBase):
else:
clique_constraints_ids = self.get_objects_list(self.COLLECTION,
query,
- page, page_size, self.PROJECTION)
+ page, page_size,
+ self.PROJECTION)
self.set_successful_response(
resp, {"clique_constraints": clique_constraints_ids}
)
diff --git a/app/api/responders/resource/clique_types.py b/app/api/responders/resource/clique_types.py
index 9a39dc8..a2bfa75 100644
--- a/app/api/responders/resource/clique_types.py
+++ b/app/api/responders/resource/clique_types.py
@@ -21,7 +21,8 @@ class CliqueTypes(ResponderBase):
self.ID: True,
"focal_point_type": True,
"link_types": True,
- "environment": True
+ "environment": True,
+ "name": True
}
def on_get(self, req, resp):
@@ -32,15 +33,16 @@ class CliqueTypes(ResponderBase):
link_types = self.get_constants_by_name("link_types")
filters_requirements = {
'env_name': self.require(str, mandatory=True),
- 'id': self.require(ObjectId, True),
+ 'id': self.require(ObjectId, convert_to_type=True),
'focal_point_type': self.require(str,
validate=DataValidate.LIST,
requirement=focal_point_types),
'link_type': self.require([list, str],
validate=DataValidate.LIST,
requirement=link_types),
- 'page': self.require(int, True),
- 'page_size': self.require(int, True)
+ 'name': self.require(str),
+ 'page': self.require(int, convert_to_type=True),
+ 'page_size': self.require(int, convert_to_type=True)
}
self.validate_query_data(filters, filters_requirements)
@@ -66,10 +68,14 @@ class CliqueTypes(ResponderBase):
link_types = self.get_constants_by_name("link_types")
clique_type_requirements = {
'environment': self.require(str, mandatory=True),
- 'focal_point_type': self.require(str, False, DataValidate.LIST,
- focal_point_types, True),
- 'link_types': self.require(list, False, DataValidate.LIST,
- link_types, True),
+ 'focal_point_type': self.require(str,
+ mandatory=True,
+ validate=DataValidate.LIST,
+ requirement=focal_point_types),
+ 'link_types': self.require(list,
+ mandatory=True,
+ validate=DataValidate.LIST,
+ requirement=link_types),
'name': self.require(str, mandatory=True)
}
@@ -77,7 +83,7 @@ class CliqueTypes(ResponderBase):
env_name = clique_type['environment']
if not self.check_environment_name(env_name):
- self.bad_request("unkown environment: " + env_name)
+ self.bad_request("unknown environment: " + env_name)
self.write(clique_type, self.COLLECTION)
self.set_successful_response(resp,
@@ -88,7 +94,7 @@ class CliqueTypes(ResponderBase):
def build_query(self, filters):
query = {}
- filters_keys = ['focal_point_type']
+ filters_keys = ['name', 'focal_point_type']
self.update_query_with_filters(filters, filters_keys, query)
link_types = filters.get('link_type')
if link_types:
diff --git a/app/api/responders/resource/cliques.py b/app/api/responders/resource/cliques.py
index ece347a..a81ab00 100644
--- a/app/api/responders/resource/cliques.py
+++ b/app/api/responders/resource/cliques.py
@@ -33,15 +33,17 @@ class Cliques(ResponderBase):
link_types = self.get_constants_by_name("link_types")
filters_requirements = {
'env_name': self.require(str, mandatory=True),
- 'id': self.require(ObjectId, True),
- 'focal_point': self.require(ObjectId, True),
- 'focal_point_type': self.require(str, validate=DataValidate.LIST,
+ 'id': self.require(ObjectId, convert_to_type=True),
+ 'focal_point': self.require(ObjectId, convert_to_type=True),
+ 'focal_point_type': self.require(str,
+ validate=DataValidate.LIST,
requirement=focal_point_types),
- 'link_type': self.require(str, validate=DataValidate.LIST,
+ 'link_type': self.require(str,
+ validate=DataValidate.LIST,
requirement=link_types),
- 'link_id': self.require(ObjectId, True),
- 'page': self.require(int, True),
- 'page_size': self.require(int, True)
+ 'link_id': self.require(ObjectId, convert_to_type=True),
+ 'page': self.require(int, convert_to_type=True),
+ 'page_size': self.require(int, convert_to_type=True)
}
self.validate_query_data(filters, filters_requirements)
page, page_size = self.get_pagination(filters)
diff --git a/app/api/responders/resource/connection_tests.py b/app/api/responders/resource/connection_tests.py
new file mode 100644
index 0000000..8f8ab94
--- /dev/null
+++ b/app/api/responders/resource/connection_tests.py
@@ -0,0 +1,169 @@
+###############################################################################
+# Copyright (c) 2017 Koren Lev (Cisco Systems), Yaron Yogev (Cisco Systems) #
+# and others #
+# #
+# All rights reserved. This program and the accompanying materials #
+# are made available under the terms of the Apache License, Version 2.0 #
+# which accompanies this distribution, and is available at #
+# http://www.apache.org/licenses/LICENSE-2.0 #
+###############################################################################
+import datetime
+
+from bson import ObjectId
+
+from api.responders.resource.environment_configs import EnvironmentConfigs
+from api.responders.responder_base import ResponderBase
+from api.validation.data_validate import DataValidate
+
+
+class ConnectionTests(ResponderBase):
+
+ COLLECTION = "connection_tests"
+ ID = "_id"
+ TARGETS = "test_targets"
+ RESULTS = "test_results"
+ CONFIGURATIONS = "targets_configuration"
+ STATUSES = ["request", "response"]
+
+ def __init__(self):
+ super().__init__()
+ self.PROJECTION = {
+ self.ID: True,
+ self.TARGETS: True,
+ self.RESULTS: True
+ }
+ self.allowed_targets = \
+ self.get_constants_by_name("configuration_targets")
+
+ def build_query(self, filters):
+ query = {}
+
+ self.update_query_with_filters(filters, ["status"], query)
+
+ if 'id' in filters:
+ query[self.ID] = filters['id']
+ elif 'env_name' in filters:
+ query['environment'] = filters['env_name']
+ else:
+ self.bad_request(message="Either 'id' or 'env_name' "
+ "field is required")
+
+ return query
+
+ def on_get(self, req, resp):
+ self.log.debug("Getting a connection test")
+ filters = self.parse_query_params(req)
+
+ filters_requirements = {
+ 'env_name': self.require(str, mandatory=True),
+ 'id': self.require(ObjectId, convert_to_type=True),
+ 'status': self.require(str,
+ requirement=self.STATUSES),
+ self.TARGETS: self.require([list, str],
+ validate=DataValidate.LIST,
+ requirement=self.allowed_targets),
+ self.RESULTS: self.require(bool, convert_to_type=True),
+ 'page': self.require(int, convert_to_type=True),
+ 'page_size': self.require(int, convert_to_type=True)
+ }
+
+ self.validate_query_data(filters, filters_requirements)
+
+ query = self.build_query(filters)
+
+ if self.ID in query:
+ result = self.get_object_by_id(collection=self.COLLECTION,
+ query=query,
+ stringify_types=[ObjectId,
+ datetime.datetime],
+ id=self.ID)
+
+ test_targets = result.get(self.TARGETS, [])
+ targets_config = result.get(self.CONFIGURATIONS, [])
+ test_results = result.get(self.RESULTS, {})
+
+ # Filter data by target names
+ targets_filter = filters.get(self.TARGETS)
+ if targets_filter:
+ test_targets = [target
+ for target in test_targets
+ if target in targets_filter]
+ targets_config = [config
+ for config in targets_config
+ if config['name'] in targets_filter]
+ test_results = {target: result
+ for target, result in test_results.items()
+ if target in targets_filter}
+
+ # Filter data by test results (success/failure)
+ results_filter = filters.get(self.RESULTS)
+ if results_filter is not None:
+ test_results = {target: result
+ for target, result in test_results.items()
+ if result == results_filter}
+
+ results_keys = test_results.keys()
+ test_targets = [target
+ for target in test_targets
+ if target in results_keys]
+ targets_config = [config
+ for config in targets_config
+ if config['name'] in results_keys]
+
+ result[self.TARGETS] = test_targets
+ result[self.CONFIGURATIONS] = targets_config
+ result[self.RESULTS] = test_results
+
+ self.set_successful_response(resp, result)
+ else:
+ page, page_size = self.get_pagination(filters)
+ tests_ids = self.get_objects_list(collection=self.COLLECTION,
+ query=query,
+ page=page,
+ page_size=page_size,
+ projection=self.PROJECTION)
+ self.set_successful_response(resp, {"connection_tests": tests_ids})
+
+ def on_post(self, req, resp):
+ self.log.debug("Posting a new connection test")
+ error, connection_test = self.get_content_from_request(req)
+ if error:
+ self.bad_request(error)
+
+ conn_test_requirements = {
+ "environment": self.require(str, mandatory=True),
+ self.TARGETS: self.require(list,
+ mandatory=True,
+ validate=DataValidate.LIST,
+ requirement=self.allowed_targets),
+ self.CONFIGURATIONS: self.require(list, mandatory=True)
+ }
+ self.validate_query_data(connection_test, conn_test_requirements)
+
+ test_targets = connection_test[self.TARGETS]
+ targets_configuration = connection_test[self.CONFIGURATIONS]
+ env_name = connection_test["environment"]
+
+ env_configs = EnvironmentConfigs()
+ config_validation = env_configs.validate_environment_config(
+ connection_test[self.CONFIGURATIONS],
+ require_mandatory=False
+ )
+ if not config_validation['passed']:
+ self.bad_request(config_validation['error_message'])
+
+ for test_target in test_targets:
+ if not env_configs.get_configuration_by_name(test_target,
+ targets_configuration):
+ self.bad_request("targets_configuration should contain "
+ "an entry for target '{}'".format(test_target))
+
+ connection_test['submit_timestamp'] = datetime.datetime.now()
+
+ result = self.write(connection_test, self.COLLECTION)
+ self.set_successful_response(resp,
+ {"id": str(result.inserted_id),
+ "message": "Created a new connection test"
+ " for environment {0}"
+ .format(env_name)},
+ "201")
diff --git a/app/api/responders/resource/environment_configs.py b/app/api/responders/resource/environment_configs.py
index 90a1adf..f54bea7 100644
--- a/app/api/responders/resource/environment_configs.py
+++ b/app/api/responders/resource/environment_configs.py
@@ -52,38 +52,38 @@ class EnvironmentConfigs(ResponderBase):
"mysql": {
"name": self.require(str, mandatory=True),
"host": self.require(str,
+ mandatory=True,
validate=DataValidate.REGEX,
- requirement=[regex.IP, regex.HOSTNAME],
- mandatory=True),
+ requirement=[regex.IP, regex.HOSTNAME]),
"pwd": self.require(str, mandatory=True),
"port": self.require(int,
- True,
- DataValidate.REGEX,
- regex.PORT,
- mandatory=True),
+ mandatory=True,
+ convert_to_type=True,
+ validate=DataValidate.REGEX,
+ requirement=regex.PORT),
"user": self.require(str, mandatory=True)
},
"OpenStack": {
"name": self.require(str, mandatory=True),
"admin_token": self.require(str, mandatory=True),
"host": self.require(str,
+ mandatory=True,
validate=DataValidate.REGEX,
- requirement=[regex.IP, regex.HOSTNAME],
- mandatory=True),
+ requirement=[regex.IP, regex.HOSTNAME]),
"port": self.require(int,
- True,
+ mandatory=True,
+ convert_to_type=True,
validate=DataValidate.REGEX,
- requirement=regex.PORT,
- mandatory=True),
+ requirement=regex.PORT),
"pwd": self.require(str, mandatory=True),
"user": self.require(str, mandatory=True)
},
"CLI": {
"name": self.require(str, mandatory=True),
"host": self.require(str,
+ mandatory=True,
validate=DataValidate.REGEX,
- requirement=[regex.IP, regex.HOSTNAME],
- mandatory=True),
+ requirement=[regex.IP, regex.HOSTNAME]),
"user": self.require(str, mandatory=True),
"pwd": self.require(str),
"key": self.require(str,
@@ -93,76 +93,78 @@ class EnvironmentConfigs(ResponderBase):
"AMQP": {
"name": self.require(str, mandatory=True),
"host": self.require(str,
+ mandatory=True,
validate=DataValidate.REGEX,
- requirement=[regex.IP, regex.HOSTNAME],
- mandatory=True),
+ requirement=[regex.IP, regex.HOSTNAME]),
"pwd": self.require(str, mandatory=True),
"port": self.require(int,
- True,
+ mandatory=True,
+ convert_to_type=True,
validate=DataValidate.REGEX,
- requirement=regex.PORT,
- mandatory=True),
+ requirement=regex.PORT),
"user": self.require(str, mandatory=True)
},
"Monitoring": {
"name": self.require(str, mandatory=True),
"config_folder": self.require(str,
+ mandatory=True,
validate=DataValidate.REGEX,
- requirement=regex.PATH,
- mandatory=True),
+ requirement=regex.PATH),
"provision": self.require(str,
+ mandatory=True,
validate=DataValidate.LIST,
- requirement=self.provision_types,
- mandatory=True),
+ requirement=self.provision_types),
"env_type": self.require(str,
+ mandatory=True,
validate=DataValidate.LIST,
- requirement=self.env_types,
- mandatory=True),
- "api_port": self.require(int, True, mandatory=True),
+ requirement=self.env_types),
+ "api_port": self.require(int,
+ mandatory=True,
+ convert_to_type=True),
"rabbitmq_pass": self.require(str, mandatory=True),
"rabbitmq_user": self.require(str, mandatory=True),
"rabbitmq_port": self.require(int,
- True,
+ mandatory=True,
+ convert_to_type=True,
validate=DataValidate.REGEX,
- requirement=regex.PORT,
- mandatory=True),
+ requirement=regex.PORT),
"ssh_port": self.require(int,
- True,
+ convert_to_type=True,
validate=DataValidate.REGEX,
requirement=regex.PORT),
"ssh_user": self.require(str),
"ssh_password": self.require(str),
"server_ip": self.require(str,
+ mandatory=True,
validate=DataValidate.REGEX,
- requirement=[regex.IP, regex.HOSTNAME],
- mandatory=True),
+ requirement=[regex.IP, regex.HOSTNAME]),
"server_name": self.require(str, mandatory=True),
"type": self.require(str,
+ mandatory=True,
validate=DataValidate.LIST,
- requirement=self.monitoring_types,
- mandatory=True)
+ requirement=self.monitoring_types)
},
"NFV_provider": {
"name": self.require(str, mandatory=True),
"host": self.require(str,
+ mandatory=True,
validate=DataValidate.REGEX,
- requirement=[regex.IP, regex.HOSTNAME],
- mandatory=True),
+ requirement=[regex.IP, regex.HOSTNAME]),
"nfv_token": self.require(str, mandatory=True),
"port": self.require(int,
- True,
- DataValidate.REGEX,
- regex.PORT,
- True),
+ mandatory=True,
+ convert_to_type=True,
+ validate=DataValidate.REGEX,
+ requirement=regex.PORT),
"user": self.require(str, mandatory=True),
"pwd": self.require(str, mandatory=True)
},
"ACI": {
"name": self.require(str, mandatory=True),
"host": self.require(str,
+ mandatory=True,
validate=DataValidate.REGEX,
- requirement=[regex.IP, regex.HOSTNAME],
- mandatory=True),
+ requirement=[regex.IP, regex.HOSTNAME]),
"user": self.require(str, mandatory=True),
"pwd": self.require(str, mandatory=True)
}
@@ -178,25 +180,24 @@ class EnvironmentConfigs(ResponderBase):
filters_requirements = {
"name": self.require(str),
- "distribution": self.require(str, False,
- DataValidate.LIST,
- self.distributions),
+ "distribution": self.require(str,
+ validate=DataValidate.LIST,
+ requirement=self.distributions),
"mechanism_drivers": self.require([str, list],
- False,
- DataValidate.LIST,
- self.mechanism_drivers),
- "type_drivers": self.require(str, False,
- DataValidate.LIST,
- self.type_drivers),
+ validate=DataValidate.LIST,
+ requirement=self.mechanism_drivers),
+ "type_drivers": self.require(str,
+ validate=DataValidate.LIST,
+ requirement=self.type_drivers),
"user": self.require(str),
- "listen": self.require(bool, True),
- "scanned": self.require(bool, True),
- "monitoring_setup_done": self.require(bool, True),
- "operational": self.require(str, False,
- DataValidate.LIST,
- self.operational_values),
- "page": self.require(int, True),
- "page_size": self.require(int, True)
+ "listen": self.require(bool, convert_to_type=True),
+ "scanned": self.require(bool, convert_to_type=True),
+ "monitoring_setup_done": self.require(bool, convert_to_type=True),
+ "operational": self.require(str,
+ validate=DataValidate.LIST,
+ requirement=self.operational_values),
+ "page": self.require(int, convert_to_type=True),
+ "page_size": self.require(int, convert_to_type=True)
}
self.validate_query_data(filters, filters_requirements)
@@ -237,24 +238,36 @@ class EnvironmentConfigs(ResponderBase):
environment_config_requirement = {
"app_path": self.require(str, mandatory=True),
"configuration": self.require(list, mandatory=True),
- "distribution": self.require(str, False, DataValidate.LIST,
- self.distributions, True),
+ "distribution": self.require(str,
+ mandatory=True,
+ validate=DataValidate.LIST,
+ requirement=self.distributions),
"distribution_version": self.require(str, mandatory=True),
- "listen": self.require(bool, True, mandatory=True),
+ "listen": self.require(bool,
+ mandatory=True,
+ convert_to_type=True),
"user": self.require(str),
- "mechanism_drivers": self.require(list, False, DataValidate.LIST,
- self.mechanism_drivers, True),
+ "mechanism_drivers": self.require(list,
+ mandatory=True,
+ validate=DataValidate.LIST,
+ requirement=self.mechanism_drivers),
"name": self.require(str, mandatory=True),
- "operational": self.require(str, True, DataValidate.LIST,
- self.operational_values, mandatory=True),
- "scanned": self.require(bool, True),
+ "operational": self.require(str,
+ mandatory=True,
+ convert_to_type=True,
+ validate=DataValidate.LIST,
+ requirement=self.operational_values),
+ "scanned": self.require(bool, convert_to_type=True),
"last_scanned": self.require(str),
"type": self.require(str, mandatory=True),
- "type_drivers": self.require(str, False, DataValidate.LIST,
- self.type_drivers, True),
- "enable_monitoring": self.require(bool, True),
- "monitoring_setup_done": self.require(bool, True),
- "auth": self.require(dict)
+ "type_drivers": self.require(str,
+ mandatory=True,
+ validate=DataValidate.LIST,
+ requirement=self.type_drivers),
+ "enable_monitoring": self.require(bool, convert_to_type=True),
+ "monitoring_setup_done": self.require(bool, convert_to_type=True),
+ "auth": self.require(dict),
+ "aci_enabled": self.require(bool, convert_to_type=True)
}
self.validate_query_data(env_config,
environment_config_requirement,
@@ -292,7 +305,8 @@ class EnvironmentConfigs(ResponderBase):
.format(env_config["name"])},
"201")
- def validate_environment_config(self, configurations):
+ def validate_environment_config(self, configurations,
+ require_mandatory=True):
configurations_of_names = {}
validation = {"passed": True}
if [config for config in configurations
@@ -319,7 +333,7 @@ class EnvironmentConfigs(ResponderBase):
"configuration for {0}".format(name)
return validation
configurations_of_names[name] = configs[0]
- else:
+ elif require_mandatory:
if name not in self.OPTIONAL_CONFIGURATIONS_NAMES:
validation["passed"] = False
validation['error_message'] = "configuration for {0} " \
diff --git a/app/api/responders/resource/inventory.py b/app/api/responders/resource/inventory.py
index 02bc486..6712197 100644
--- a/app/api/responders/resource/inventory.py
+++ b/app/api/responders/resource/inventory.py
@@ -33,9 +33,9 @@ class Inventory(ResponderBase):
'id_path': self.require(str),
'parent_id': self.require(str),
'parent_path': self.require(str),
- 'sub_tree': self.require(bool, True),
- 'page': self.require(int, True),
- 'page_size': self.require(int, True)
+ 'sub_tree': self.require(bool, convert_to_type=True),
+ 'page': self.require(int, convert_to_type=True),
+ 'page_size': self.require(int, convert_to_type=True)
}
self.validate_query_data(filters, filters_requirements)
page, page_size = self.get_pagination(filters)
diff --git a/app/api/responders/resource/links.py b/app/api/responders/resource/links.py
index 33fd432..bd0a022 100644
--- a/app/api/responders/resource/links.py
+++ b/app/api/responders/resource/links.py
@@ -34,17 +34,19 @@ class Links(ResponderBase):
link_states = self.get_constants_by_name("link_states")
filters_requirements = {
'env_name': self.require(str, mandatory=True),
- 'id': self.require(ObjectId, True),
+ 'id': self.require(ObjectId, convert_to_type=True),
'host': self.require(str),
- 'link_type': self.require(str, validate=DataValidate.LIST,
+ 'link_type': self.require(str,
+ validate=DataValidate.LIST,
requirement=link_types),
'link_name': self.require(str),
'source_id': self.require(str),
'target_id': self.require(str),
- 'state': self.require(str, validate=DataValidate.LIST,
+ 'state': self.require(str,
+ validate=DataValidate.LIST,
requirement=link_states),
- 'page': self.require(int, True),
- 'page_size': self.require(int, True)
+ 'page': self.require(int, convert_to_type=True),
+ 'page_size': self.require(int, convert_to_type=True)
}
self.validate_query_data(filters, filters_requirements, r'^attributes\:\w+$')
diff --git a/app/api/responders/resource/messages.py b/app/api/responders/resource/messages.py
index 0dda31b..367bd34 100644
--- a/app/api/responders/resource/messages.py
+++ b/app/api/responders/resource/messages.py
@@ -35,15 +35,17 @@ class Messages(ResponderBase):
'env_name': self.require(str, mandatory=True),
'source_system': self.require(str),
'id': self.require(str),
- 'level': self.require(str, validate=DataValidate.LIST,
+ 'level': self.require(str,
+ validate=DataValidate.LIST,
requirement=messages_severity),
'related_object': self.require(str),
- 'related_object_type': self.require(str, validate=DataValidate.LIST,
+ 'related_object_type': self.require(str,
+ validate=DataValidate.LIST,
requirement=object_types),
'start_time': self.require(str),
'end_time': self.require(str),
- 'page': self.require(int, True),
- 'page_size': self.require(int, True)
+ 'page': self.require(int, convert_to_type=True),
+ 'page_size': self.require(int, convert_to_type=True)
}
self.validate_query_data(filters, filters_requirements)
page, page_size = self.get_pagination(filters)
diff --git a/app/api/responders/resource/monitoring_config_templates.py b/app/api/responders/resource/monitoring_config_templates.py
index 42d3973..8980cc9 100644
--- a/app/api/responders/resource/monitoring_config_templates.py
+++ b/app/api/responders/resource/monitoring_config_templates.py
@@ -30,13 +30,14 @@ class MonitoringConfigTemplates(ResponderBase):
sides = self.get_constants_by_name("monitoring_sides")
filters_requirements = {
- "id": self.require(ObjectId, True),
- "order": self.require(int, True),
- "side": self.require(str, validate=DataValidate.LIST,
+ "id": self.require(ObjectId, convert_to_type=True),
+ "order": self.require(int, convert_to_type=True),
+ "side": self.require(str,
+ validate=DataValidate.LIST,
requirement=sides),
"type": self.require(str),
- "page": self.require(int, True),
- "page_size": self.require(int, True)
+ "page": self.require(int, convert_to_type=True),
+ "page_size": self.require(int, convert_to_type=True)
}
self.validate_query_data(filters, filters_requirements)
diff --git a/app/api/responders/resource/scans.py b/app/api/responders/resource/scans.py
index 7f2a947..6fc572d 100644
--- a/app/api/responders/resource/scans.py
+++ b/app/api/responders/resource/scans.py
@@ -34,7 +34,6 @@ class Scans(ResponderBase):
"id": self.require(ObjectId, convert_to_type=True),
"base_object": self.require(str),
"status": self.require(str,
- convert_to_type=False,
validate=DataValidate.LIST,
requirement=scan_statuses),
"page": self.require(int, convert_to_type=True),
diff --git a/app/api/responders/resource/scheduled_scans.py b/app/api/responders/resource/scheduled_scans.py
index 0588cd0..f8cf92c 100644
--- a/app/api/responders/resource/scheduled_scans.py
+++ b/app/api/responders/resource/scheduled_scans.py
@@ -38,11 +38,12 @@ class ScheduledScans(ResponderBase):
filters_requirements = {
"environment": self.require(str, mandatory=True),
- "id": self.require(ObjectId, True),
- "freq": self.require(str, False,
- DataValidate.LIST, self.SCAN_FREQ),
- "page": self.require(int, True),
- "page_size": self.require(int, True)
+ "id": self.require(ObjectId, convert_to_type=True),
+ "freq": self.require(str,
+ validate=DataValidate.LIST,
+ requirement=self.SCAN_FREQ),
+ "page": self.require(int, convert_to_type=True),
+ "page_size": self.require(int, convert_to_type=True)
}
self.validate_query_data(filters, filters_requirements)
@@ -71,16 +72,17 @@ class ScheduledScans(ResponderBase):
log_levels = self.get_constants_by_name("log_levels")
scheduled_scan_requirements = {
"environment": self.require(str, mandatory=True),
- "scan_only_links": self.require(bool, True),
- "scan_only_cliques": self.require(bool, True),
- "scan_only_inventory": self.require(bool, True),
- "freq": self.require(str, validate=DataValidate.LIST,
- requirement=self.SCAN_FREQ,
- mandatory=True),
+ "scan_only_links": self.require(bool, convert_to_type=True),
+ "scan_only_cliques": self.require(bool, convert_to_type=True),
+ "scan_only_inventory": self.require(bool, convert_to_type=True),
+ "freq": self.require(str,
+ mandatory=True,
+ validate=DataValidate.LIST,
+ requirement=self.SCAN_FREQ),
"log_level": self.require(str,
validate=DataValidate.LIST,
requirement=log_levels),
- "clear": self.require(bool, True),
+ "clear": self.require(bool, convert_to_type=True),
"submit_timestamp": self.require(str, mandatory=True)
}
self.validate_query_data(scheduled_scan, scheduled_scan_requirements)
@@ -93,12 +95,12 @@ class ScheduledScans(ResponderBase):
env_name = scheduled_scan["environment"]
if not self.check_environment_name(env_name):
- self.bad_request("unkown environment: " + env_name)
+ self.bad_request("unknown environment: " + env_name)
self.write(scheduled_scan, self.COLLECTION)
self.set_successful_response(resp,
- {"message": "created a new scheduled scan for "
- "environment {0}"
+ {"message": "created a new scheduled scan "
+ "for environment {0}"
.format(env_name)},
"201")