release 1.2 + new tagging

Change-Id: I1e876451ec4a330f458dd57adadb15e39969b225
Signed-off-by: Koren Lev <korenlev@gmail.com>

4 files changed, 182 insertions, 44 deletions

diff --git a/app/api/responders/resource/clique_types.py b/app/api/responders/resource/clique_types.py
index ff42f8c..e2e9e71 100644
--- a/app/api/responders/resource/clique_types.py
+++ b/app/api/responders/resource/clique_types.py
@@ -21,31 +21,53 @@ class CliqueTypes(ResponderBase):
         "focal_point_type": True,
         "link_types": True,
         "environment": True,
-        "name": True
+        "name": True,
+        "distribution": True,
+        "distribution_version": True,
+        "mechanism_drivers": True,
+        "type_drivers": True,
+        "use_implicit_links": True
     }
     RESERVED_NAMES = ["ANY"]
 
+    def __init__(self):
+        super().__init__()
+        self.focal_point_types = self.get_constants_by_name("object_types")
+        self.link_types = self.get_constants_by_name("link_types")
+        self.mechanism_drivers = self.get_constants_by_name("mechanism_drivers")
+        self.type_drivers = self.get_constants_by_name("type_drivers")
+
     def on_get(self, req, resp):
         self.log.debug("Getting clique types")
 
         filters = self.parse_query_params(req)
-        focal_point_types = self.get_constants_by_name("object_types")
-        link_types = self.get_constants_by_name("link_types")
         filters_requirements = {
-            'env_name': self.require(str, mandatory=True),
+            'env_name': self.require(str),
             'id': self.require(ObjectId, convert_to_type=True),
+            'distribution': self.require(str),
+            'distribution_version': self.require(str),
+            'mechanism_drivers': self.require(str,
+                                              validate=DataValidate.LIST,
+                                              requirement=self.mechanism_drivers),
+            'type_drivers': self.require(str,
+                                         validate=DataValidate.LIST,
+                                         requirement=self.type_drivers),
             'focal_point_type': self.require(str,
                                              validate=DataValidate.LIST,
-                                             requirement=focal_point_types),
+                                             requirement=self.focal_point_types),
             'link_type': self.require([list, str],
                                       validate=DataValidate.LIST,
-                                      requirement=link_types),
+                                      requirement=self.link_types),
             '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)
+        if 'distribution_version' in filters and 'distribution' not in filters:
+            self.bad_request("Distribution version without distribution "
+                             "is not allowed")
+
         page, page_size = self.get_pagination(filters)
         query = self.build_query(filters)
         if self.ID in query:
@@ -64,40 +86,46 @@ class CliqueTypes(ResponderBase):
         error, clique_type = self.get_content_from_request(req)
         if error:
             self.bad_request(error)
-        focal_point_types = self.get_constants_by_name("object_types")
-        link_types = self.get_constants_by_name("link_types")
+
         clique_type_requirements = {
-            'environment': self.require(str, mandatory=True),
+            'environment': self.require(str),
             'focal_point_type': self.require(str,
                                              mandatory=True,
                                              validate=DataValidate.LIST,
-                                             requirement=focal_point_types),
+                                             requirement=self.focal_point_types),
             'link_types': self.require(list,
                                        mandatory=True,
                                        validate=DataValidate.LIST,
-                                       requirement=link_types),
-            'name': self.require(str, mandatory=True)
+                                       requirement=self.link_types),
+            'name': self.require(str, mandatory=True),
+            'distribution': self.require(str),
+            'distribution_version': self.require(str),
+            'mechanism_drivers': self.require(str,
+                                              validate=DataValidate.LIST,
+                                              requirement=self.mechanism_drivers),
+            'type_drivers': self.require(str,
+                                         validate=DataValidate.LIST,
+                                         requirement=self.type_drivers),
+            'use_implicit_links': self.require(bool)
         }
 
         self.validate_query_data(clique_type, clique_type_requirements)
-
-        env_name = clique_type['environment']
-        if not self.check_environment_name(env_name):
-            self.bad_request("Unknown environment: {}".format(env_name))
-        elif env_name.upper() in self.RESERVED_NAMES:
-            self.bad_request("Environment name '{}' is reserved".format(env_name))
+        self.validate_required_fields(clique_type)
+        self.validate_focal_point_type(clique_type)
+        self.validate_duplicate_configuration(clique_type)
 
         self.write(clique_type, self.COLLECTION)
         self.set_successful_response(resp,
-                                     {"message": "created a new clique_type "
-                                                 "for environment {0}"
-                                                 .format(env_name)},
+                                     {"message": "created a new clique_type"},
                                      "201")
 
     def build_query(self, filters):
         query = {}
-        filters_keys = ['name', 'focal_point_type']
+        filters_keys = ['name', 'focal_point_type',
+                        'distribution', 'distribution_version',
+                        'mechanism_drivers', 'type_drivers']
         self.update_query_with_filters(filters, filters_keys, query)
+
         link_types = filters.get('link_type')
         if link_types:
             if type(link_types) != list:
@@ -107,5 +135,71 @@ class CliqueTypes(ResponderBase):
         if _id:
             query[self.ID] = _id
 
-        query['environment'] = filters['env_name']
+        env_name = filters.get('env_name')
+        if env_name:
+            query['environment'] = filters['env_name']
         return query
+
+    def validate_required_fields(self, clique_type):
+        env_name = clique_type.get('environment')
+        distribution = clique_type.get('distribution')
+        distribution_version = clique_type.get('distribution_version')
+        if distribution_version and not distribution:
+            self.bad_request("Distribution version without distribution "
+                             "is not allowed")
+
+        configuration_specified = ((distribution and distribution_version)
+                                   or clique_type.get('mechanism_drivers')
+                                   or clique_type.get('type_drivers'))
+        if env_name:
+            if configuration_specified:
+                self.bad_request("Either environment or configuration "
+                                 "should be specified (not both).")
+
+            if not self.check_environment_name(env_name):
+                self.bad_request("Unknown environment: {}".format(env_name))
+            elif env_name.upper() in self.RESERVED_NAMES:
+                self.bad_request(
+                    "Environment name '{}' is reserved".format(env_name))
+        elif not configuration_specified:
+            self.bad_request("Either environment or configuration "
+                             "should be specified.")
+
+    def validate_focal_point_type(self, clique_type):
+        focal_point_type = clique_type['focal_point_type']
+        environment = clique_type.get('environment')
+        if environment:
+            env_match = self.read(
+                matches={"environment": environment,
+                         "focal_point_type": focal_point_type},
+                collection="clique_types"
+            )
+            if env_match:
+                self.bad_request("Clique type with focal point {} "
+                                 "is already registered for environment {}"
+                                 .format(focal_point_type, environment))
+        else:
+            pass
+
+    def validate_duplicate_configuration(self, clique_type):
+        if clique_type.get('environment'):
+            return
+
+        search = {'focal_point_type': clique_type['focal_point_type']}
+        for field in ['distribution', 'mechanism_drivers', 'type_drivers']:
+            value = clique_type.get(field)
+            if value:
+                search[field] = value
+                if field == 'distribution':
+                    dv = clique_type.get('distribution_version')
+                    if dv:
+                        search['distribution_version'] = dv
+                # Got a match with higher score, no need to look further
+                break
+
+        env_match = self.read(matches=search,
+                              collection="clique_types")
+        if env_match:
+            self.bad_request("Clique type with configuration '{}' "
+                             "is already registered"
+                             .format(search))
diff --git a/app/api/responders/resource/environment_configs.py b/app/api/responders/resource/environment_configs.py
index c24aec8..76cc8a9 100644
--- a/app/api/responders/resource/environment_configs.py
+++ b/app/api/responders/resource/environment_configs.py
@@ -13,7 +13,6 @@ from api.responders.responder_base import ResponderBase
 from bson.objectid import ObjectId
 from datetime import datetime
 from utils.constants import EnvironmentFeatures
-from utils.inventory_mgr import InventoryMgr
 
 
 class EnvironmentConfigs(ResponderBase):
@@ -27,9 +26,13 @@ class EnvironmentConfigs(ResponderBase):
         "distribution": True
     }
     CONFIGURATIONS_NAMES = ["mysql", "OpenStack", "CLI", "AMQP",
-                            "Monitoring", "NFV_provider", "ACI"]
-    OPTIONAL_CONFIGURATIONS_NAMES = ["AMQP", "Monitoring",
-                                     "NFV_provider", "ACI"]
+                            "Monitoring", "NFV_provider", "ACI",
+                            "Kubernetes", "VMware", "Bare-metal"]
+    REQUIRED_CONFIGURATIONS_NAMES = {
+        "OpenStack": ["OpenStack", "mysql", "CLI"],
+        "Kubernetes": ["Kubernetes", "CLI"],
+    }
+    DEFAULT_ENV_TYPE = "OpenStack"
 
     def __init__(self):
         super().__init__()
@@ -49,6 +52,8 @@ class EnvironmentConfigs(ResponderBase):
             get_constants_by_name("environment_operational_status")
         self.type_drivers = self.\
             get_constants_by_name("type_drivers")
+        self.environment_types = self.\
+            get_constants_by_name("environment_types")
 
         self.CONFIGURATIONS_REQUIREMENTS = {
             "mysql": {
@@ -108,6 +113,7 @@ class EnvironmentConfigs(ResponderBase):
             },
             "Monitoring": {
                 "name": self.require(str, mandatory=True),
+                "install_monitoring_client": self.require(bool),
                 "config_folder": self.require(str,
                                               mandatory=True,
                                               validate=DataValidate.REGEX,
@@ -169,6 +175,20 @@ class EnvironmentConfigs(ResponderBase):
                                      requirement=[regex.IP, regex.HOSTNAME]),
                 "user": self.require(str, mandatory=True),
                 "pwd": self.require(str, mandatory=True)
+            },
+            "Kubernetes": {
+                "name": self.require(str, mandatory=True),
+                "host": self.require(str,
+                                     mandatory=True,
+                                     validate=DataValidate.REGEX,
+                                     requirement=[regex.IP, regex.HOSTNAME]),
+                "port": self.require(int,
+                                     mandatory=True,
+                                     convert_to_type=True,
+                                     validate=DataValidate.REGEX,
+                                     requirement=regex.PORT),
+                "user": self.require(str, mandatory=True),
+                "token": self.require(str, mandatory=True)
             }
         }
         self.AUTH_REQUIREMENTS = {
@@ -201,6 +221,9 @@ class EnvironmentConfigs(ResponderBase):
             "operational": self.require(str,
                                         validate=DataValidate.LIST,
                                         requirement=self.operational_values),
+            "environment_type": self.require(str,
+                                             validate=DataValidate.LIST,
+                                             requirement=self.environment_types),
             "page": self.require(int, convert_to_type=True),
             "page_size": self.require(int, convert_to_type=True)
         }
@@ -223,7 +246,8 @@ class EnvironmentConfigs(ResponderBase):
         query = {}
         filters_keys = ["name", "distribution", "distribution_version",
                         "type_drivers", "user", "listen",
-                        "monitoring_setup_done", "scanned", "operational"]
+                        "monitoring_setup_done", "scanned", "operational",
+                        "environment_type"]
         self.update_query_with_filters(filters, filters_keys, query)
         mechanism_drivers = filters.get("mechanism_drivers")
         if mechanism_drivers:
@@ -272,16 +296,26 @@ class EnvironmentConfigs(ResponderBase):
             "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)
+            "aci_enabled": self.require(bool, convert_to_type=True),
+            "environment_type": self.require(str,
+                                             validate=DataValidate.LIST,
+                                             requirement=self.environment_types),
         }
         self.validate_query_data(env_config,
                                  environment_config_requirement,
-                                 can_be_empty_keys=["last_scanned"]
-                                 )
+                                 can_be_empty_keys=["last_scanned",
+                                                    "environment_type"])
         self.check_and_convert_datetime("last_scanned", env_config)
+
         # validate the configurations
+        environment_type = env_config.get("environment_type")
+        if not environment_type:
+            environment_type = self.DEFAULT_ENV_TYPE
         configurations = env_config['configuration']
-        config_validation = self.validate_environment_config(configurations)
+        config_validation = (
+            self.validate_environment_config(configurations=configurations,
+                                             environment_type=environment_type)
+        )
 
         if not config_validation['passed']:
             self.bad_request(config_validation['error_message'])
@@ -310,12 +344,11 @@ class EnvironmentConfigs(ResponderBase):
                                                  .format(env_config["name"])},
                                      "201")
 
-    def validate_environment_config(self, configurations,
+    def validate_environment_config(self, configurations, environment_type=None,
                                     require_mandatory=True):
         configurations_of_names = {}
         validation = {"passed": True}
-        if [config for config in configurations
-            if 'name' not in config]:
+        if any('name' not in config for config in configurations):
             validation['passed'] = False
             validation['error_message'] = "configuration must have name"
             return validation
@@ -338,12 +371,19 @@ class EnvironmentConfigs(ResponderBase):
                                                   "configuration for {0}".format(name)
                     return validation
                 configurations_of_names[name] = configs[0]
-            elif require_mandatory:
-                if name not in self.OPTIONAL_CONFIGURATIONS_NAMES:
-                    validation["passed"] = False
-                    validation['error_message'] = "configuration for {0} " \
-                                                  "is mandatory".format(name)
-                    return validation
+
+        if require_mandatory:
+            required_list = (
+                self.REQUIRED_CONFIGURATIONS_NAMES.get(environment_type, [])
+            )
+            if any(required_conf not in configurations_of_names
+                   for required_conf
+                   in required_list):
+                validation["passed"] = False
+                validation['error_message'] = ("configurations for ({})"
+                                               "are mandatory for "
+                                               "this environment type"
+                                               .format(", ".join(required_list)))
 
         for name, config in configurations_of_names.items():
             error_message = self.validate_configuration(name, config)
diff --git a/app/api/responders/responder_base.py b/app/api/responders/responder_base.py
index e59f4cf..0ac08d6 100644
--- a/app/api/responders/responder_base.py
+++ b/app/api/responders/responder_base.py
@@ -71,7 +71,7 @@ class ResponderBase(DataValidate, DictNamingConverter):
 
     def validate_query_data(self, data, data_requirements,
                             additional_key_reg=None,
-                            can_be_empty_keys=[]):
+                            can_be_empty_keys=None):
         error_message = self.validate_data(data, data_requirements,
                                            additional_key_reg,
                                            can_be_empty_keys)
@@ -197,7 +197,9 @@ class ResponderBase(DataValidate, DictNamingConverter):
                                ': no "value" key for data: ' + str(d))
         return consts
 
-    def read(self, collection, matches={}, projection=None, skip=0, limit=1000):
+    def read(self, collection, matches=None, projection=None, skip=0, limit=1000):
+        if matches is None:
+            matches = {}
         collection = self.get_collection_by_name(collection)
         skip *= limit
         query = collection.find(matches, projection).skip(skip).limit(limit)
diff --git a/app/api/validation/data_validate.py b/app/api/validation/data_validate.py
index 6928c4b..4dfb214 100644
--- a/app/api/validation/data_validate.py
+++ b/app/api/validation/data_validate.py
@@ -75,7 +75,9 @@ class DataValidate:
 
     def validate_data(self, data, requirements,
                       additional_key_re=None,
-                      can_be_empty_keys=[]):
+                      can_be_empty_keys=None):
+        if can_be_empty_keys is None:
+            can_be_empty_keys = []
 
         illegal_keys = [key for key in data.keys()
                         if key not in requirements.keys()]