Merge branch 'develop' into feature/alex_339_automated_events_attribu…

…tes_in_setup_and_teardown

# Conflicts:
#	models/DeployResultModel.py

common/utilites/common_utils.py

@@ -65,3 +65,13 @@ def fixurl(url):
     # put it back together
     netloc = ''.join((user, colon1, pass_, at, host, colon2, port))
     return urlparse.urlunsplit((scheme, netloc, path, query, fragment))
+
+
+def str2bool(boolean_as_string):
+    if isinstance(boolean_as_string, bool):
+        return boolean_as_string
+    if boolean_as_string.lower() == 'true':
+        return True
+    if boolean_as_string.lower() == 'false':
+        return False
+    raise ValueError('{0} should be True or False '.format(boolean_as_string))

common/vcenter/data_model_retriever.py

@@ -1,11 +1,23 @@
-from models import VMwarevCenterResourceModel
+from models.VMwarevCenterResourceModel import VMwarevCenterResourceModel
 
 
 class VCenterDataModelRetriever(object):
-    def __init__(self, quali_helpers, resource_parser):
-        self.quali_helpers = quali_helpers
-        self.resource_parser = resource_parser
+    def __init__(self, resource_model_parser):
+        """
+        :param ResourceModelParser resource_model_parser:
+        :return:
+        """
+        self.resource_model_parser = resource_model_parser
 
-    def get_vcenter_data_model(self):
-        resource_context = self.quali_helpers.get_resource_context_details()
-        return self.resource_parser.convert_to_resource_model(resource_context, VMwarevCenterResourceModel)
+    def get_vcenter_data_model(self, api, vcenter_name):
+        """
+        :param api:
+        :param str vcenter_name:
+        :rtype:  VMwarevCenterResourceModel
+        """
+        if not vcenter_name:
+            raise ValueError('VMWare vCenter name is empty')
+        vcenter_instance = api.GetResourceDetails(vcenter_name)
+        vcenter_resource_model = self.resource_model_parser.convert_to_resource_model(vcenter_instance,
+                                                                                      VMwarevCenterResourceModel)
+        return vcenter_resource_model

common/vcenter/deployment_details.py

@@ -0,0 +1,6 @@
+class DeploymentDetails(object):
+    def __init__(self, vm_cluster, vm_storage, vm_resource_pool, vm_location):
+        self.vm_cluster = vm_cluster
+        self.vm_storage = vm_storage
+        self.vm_resource_pool = vm_resource_pool
+        self.vm_location = vm_location

common/vcenter/deployment_details_factory.py

@@ -0,0 +1,26 @@
+from common.vcenter.deployment_details import DeploymentDetails
+from models.VMwarevCenterResourceModel import VMwarevCenterResourceModel
+
+
+class DeploymentDetailsFactory(object):
+    @staticmethod
+    def create_deployment_details(vcenter_resource_model, vm_cluster, vm_storage, vm_resource_pool, vm_location):
+        """
+        :type vcenter_resource_model: VMwarevCenterResourceModel
+        :type vm_cluster: str
+        :type vm_storage: str
+        :type vm_resource_pool: str
+        :type vm_location: str
+        :rtype: DeploymentDetails
+        """
+        vm_cluster = vm_cluster or vcenter_resource_model.vm_cluster
+        vm_storage = vm_storage or vcenter_resource_model.vm_storage
+        vm_resource_pool = vm_resource_pool or vcenter_resource_model.vm_resource_pool
+        vm_location = vm_location or vcenter_resource_model.vm_location
+
+        return DeploymentDetails(
+            vm_cluster=vm_cluster,
+            vm_storage=vm_storage,
+            vm_resource_pool=vm_resource_pool,
+            vm_location=vm_location
+        )

common/vcenter/vmomi_service.py

@@ -5,6 +5,7 @@
 from datetime import datetime
 from pyVmomi import vim
 from common.logger import getLogger
+from common.utilites.common_utils import str2bool
 from common.utilites.io import get_path_and_name
 from common.vcenter.vm_location import VMLocation
 
@@ -345,7 +346,7 @@ def __init__(self,
             self.datastore_name = datastore_name
             self.cluster_name = cluster_name
             self.resource_pool = resource_pool
-            self.power_on = power_on
+            self.power_on = str2bool(power_on)
 
     class CloneVmResult:
         """

deployment_drivers/deploy_from_image/requirements.txt

@@ -1,3 +1,2 @@
 jsonpickle
-cloudshell-automation-api
-pydevd
+cloudshell-automation-api==7.0.0.66

deployment_drivers/deploy_from_template/driver.py

@@ -1,14 +1,9 @@
 import jsonpickle
-import time
 from cloudshell.api.cloudshell_api import InputNameValue
 from common.cloud_shell.driver_helper import CloudshellDriverHelper
 from common.model_factory import ResourceModelParser
-from common.vcenter.vm_location import VMLocation
-from models.VCenterTemplateModel import VCenterTemplateModel
+from models.DeployFromTemplateDetails import DeployFromTemplateDetails
 from models.vCenterVMFromTemplateResourceModel import vCenterVMFromTemplateResourceModel
-from models.VMwarevCenterResourceModel import VMwarevCenterResourceModel
-from models.DeployDataHolder import DeployDataHolder
-from models.VMClusterModel import VMClusterModel
 
 
 class DeployFromTemplateDriver(object):
@@ -20,86 +15,28 @@ def Deploy(self, context, Name=None):
         """
         Deploys app from template
         :type context: models.QualiDriverModels.ResourceCommandContext
+        :param Name: Name of the Deployment
+        :type Name: str
+        :rtype: str
         """
         session = self.cs_helper.get_session(context.connectivity.server_address,
                                              context.connectivity.admin_auth_token,
                                              context.reservation.domain)
 
-        data_holder = self._get_data_holder(context.resource, session, Name)
+        vcenter_template_resource_model = \
+            self.resource_model_parser.convert_to_resource_model(context.resource,
+                                                                 vCenterVMFromTemplateResourceModel)
 
-        params = [InputNameValue('deploy_data', jsonpickle.encode(data_holder, unpicklable=False))]
+        deploy_from_template_details = DeployFromTemplateDetails(vcenter_template_resource_model, Name)
+
+        params = [InputNameValue('deploy_data', jsonpickle.encode(deploy_from_template_details, unpicklable=False))]
 
         reservation_id = context.reservation.reservation_id
         result = session.ExecuteCommand(reservation_id,
-                                        data_holder.template_model.vCenter_resource_name,
+                                        vcenter_template_resource_model.vcenter_name,
                                         "Resource",
                                         "deploy_from_template",
                                         params,
                                         False)
 
         return result.Output
-
-    def _get_data_holder(self, resource, session, name):
-
-        resource_context = resource
-
-        # get vCenter resource name, template name, template folder
-        vcenter_template_resource_model = \
-            self.resource_model_parser.convert_to_resource_model(resource_context,
-                                                                 vCenterVMFromTemplateResourceModel)
-        vcenter_resource_model = self._get_vcenter(session, vcenter_template_resource_model.vcenter_name)
-        template_model = self._create_vcenter_template_model(vcenter_resource_model, vcenter_template_resource_model,
-                                                             name)
-        vm_cluster_model = VMClusterModel(vcenter_resource_model.vm_cluster, vcenter_resource_model.vm_resource_pool)
-
-        # get power state of the cloned VM
-        power_on = False
-        datastore_name = vcenter_template_resource_model.vm_storage
-
-        return DeployDataHolder.create_from_params(template_model=template_model,
-                                                   datastore_name=datastore_name,
-                                                   vm_cluster_model=vm_cluster_model,
-                                                   power_on=power_on,
-                                                   ip_regex=vcenter_template_resource_model.ip_regex,
-                                                   refresh_ip_timeout=vcenter_template_resource_model.refresh_ip_timeout,
-                                                   auto_power_on=vcenter_template_resource_model.auto_power_on,
-                                                   auto_power_off=vcenter_template_resource_model.auto_power_off,
-                                                   wait_for_ip=vcenter_template_resource_model.wait_for_ip,
-                                                   auto_delete=vcenter_template_resource_model.auto_delete)
-
-    def _get_vcenter(self, api, vcenter_name):
-        if not vcenter_name:
-            raise ValueError('VMWare vCenter name is empty')
-        vcenter_instance = api.GetResourceDetails(vcenter_name)
-        vcenter_resource_model = self.resource_model_parser.convert_to_resource_model(vcenter_instance,
-                                                                                      VMwarevCenterResourceModel)
-        return vcenter_resource_model
-
-    def _create_vcenter_template_model(self, vcenter_resource_model, vcenter_template_resource_model, name):
-        vcenter_name = vcenter_template_resource_model.vcenter_name
-        if not vcenter_name:
-            raise ValueError('VCenter Name is empty')
-        vm_location = vcenter_template_resource_model.vm_location or vcenter_resource_model.vm_location
-        if not vm_location:
-            raise ValueError('VM Location is empty')
-        vcenter_template = vcenter_template_resource_model.vcenter_template or vcenter_resource_model.vcenter_template
-        if not vcenter_template:
-            raise ValueError('VCenter Template is empty')
-        app_name = name
-        if not app_name:
-            raise ValueError('Name input parameter is empty')
-
-        default_datacenter = vcenter_resource_model.default_datacenter
-        if not default_datacenter:
-            raise ValueError('Default Datacenter attribute on VMWare vCenter is empty')
-
-        vcenter_template = VMLocation.combine([default_datacenter, vcenter_template])
-
-        template_model = VCenterTemplateModel(
-            vcenter_resource_name=vcenter_name,
-            vm_folder=vm_location,
-            template_name=vcenter_template,
-            app_name=app_name,
-            default_datacenter=default_datacenter
-        )
-        return template_model

deployment_drivers/deploy_from_template/requirements.txt

@@ -1,2 +1,2 @@
 jsonpickle
-cloudshell-automation-api
+cloudshell-automation-api==7.0.0.66

models/DeployDataHolder.py

@@ -26,13 +26,12 @@ def _is_primitive(thing):
         return isinstance(thing, primitive)
 
     @classmethod
-    def create_from_params(cls, template_model, datastore_name, vm_cluster_model, power_on, ip_regex, refresh_ip_timeout,
+    def create_from_params(cls, template_model, datastore_name, vm_cluster_model, ip_regex, refresh_ip_timeout,
                            auto_power_on, auto_power_off, wait_for_ip, auto_delete):
         """
         :param VCenterTemplateModel template_model:
         :param str datastore_name:
         :param VMClusterModel vm_cluster_model:
-        :param bool power_on:
         :param str ip_regex: Custom regex to filter IP addresses
         :param refresh_ip_timeout:
         :param bool auto_power_on:
@@ -44,7 +43,6 @@ def create_from_params(cls, template_model, datastore_name, vm_cluster_model, po
             'template_model': template_model,
             'datastore_name': datastore_name,
             'vm_cluster_model': vm_cluster_model,
-            'power_on': power_on,
             'ip_regex': ip_regex,
             'refresh_ip_timeout': refresh_ip_timeout,
             'auto_power_on': auto_power_on,

models/DeployFromTemplateDetails.py

@@ -0,0 +1,12 @@
+from models.vCenterVMFromTemplateResourceModel import vCenterVMFromTemplateResourceModel
+
+
+class DeployFromTemplateDetails(object):
+    def __init__(self, template_resource_model, app_name):
+        """
+        :type template_resource_model:  vCenterVMFromTemplateResourceModel
+        :type app_name: str
+        :return:
+        """
+        self.template_resource_model = template_resource_model
+        self.app_name = app_name

models/DeployResultModel.py

@@ -1,3 +1,6 @@
+from common.utilites.common_utils import str2bool
+
+
 class DeployResult(object):
     def __init__(self, vm_name, vm_uuid, cloud_provider_resource_name, ip_regex, refresh_ip_timeout, auto_power_on,
                  auto_power_off, wait_for_ip, auto_delete):

models/VCenterDetails.py

@@ -0,0 +1,7 @@
+class VCenterDetails(object):
+    def __init__(self, vm_cluster, vm_storage, vm_resource_pool, vm_location, default_datacenter):
+        self.vm_cluster = vm_cluster
+        self.vm_storage = vm_storage
+        self.vm_resource_pool = vm_resource_pool
+        self.vm_location = vm_location
+        self.default_datacenter = default_datacenter

orchestration_service/requirements.txt

@@ -1,2 +1,2 @@
 jsonpickle
-cloudshell-automation-api
+cloudshell-automation-api==7.0.0.66

tests/test_commands/test_deploy_vm.py

@@ -1,10 +1,9 @@
 import os
 import sys
 import unittest
-
 from mock import Mock
-
-from models.DeployDataHolder import DeployDataHolder
+from models.DeployFromTemplateDetails import DeployFromTemplateDetails
+from models.vCenterVMFromTemplateResourceModel import vCenterVMFromTemplateResourceModel
 from vCenterShell.commands.deploy_vm import DeployCommand
 
 sys.path.append(os.path.join(os.path.dirname(__file__), '../vCenterShell/vCenterShell'))
@@ -26,25 +25,23 @@ def test_deploy_execute(self):
         template_model.vm_folder = 'temp folder'
         deployer.deploy_from_template = Mock(return_value=deploy_res)
 
-        deploy_params = DeployDataHolder.create_from_params(template_model,
-                                                            'datastore_name',
-                                                            'vm_cluster_model',
-                                                            power_on=True,
-                                                            ip_regex='',
-                                                            refresh_ip_timeout=20,
-                                                            auto_power_on=True,
-                                                            auto_power_off=True,
-                                                            wait_for_ip=True,
-                                                            auto_delete=True)
+        template_resource_model = vCenterVMFromTemplateResourceModel()
+
+        deploy_params = DeployFromTemplateDetails(template_resource_model, 'VM Deployment')
 
         deploy_command = DeployCommand(deployer)
 
+        resource_context = Mock()
+
         # act
-        result = deploy_command.execute_deploy_from_template(si, deploy_params)
+        result = deploy_command.execute_deploy_from_template(
+            si=si,
+            deployment_params= deploy_params,
+            resource_context=resource_context)
 
         # assert
         self.assertTrue(result)
-        self.assertTrue(deployer.deploy_from_template.called_with(si, deploy_params))
+        self.assertTrue(deployer.deploy_from_template.called_with(si, deploy_params, resource_context))
 
     def test_deploy_image_execute(self):
         deployer = Mock()

tests/test_common/test_utilities/test_common_utils.py

@@ -1,5 +1,5 @@
 import unittest
-from common.utilites.common_utils import get_object_as_string
+from common.utilites.common_utils import get_object_as_string, str2bool
 
 
 class TestCommonUtils(unittest.TestCase):
@@ -14,3 +14,22 @@ def test_get_object_as_string_string(self):
         result = get_object_as_string('value')
 
         self.assertEqual(result, 'value')
+
+    def test_str2bool_True(self):
+        result = str2bool(True)
+        self.assertTrue(result)
+
+    def test_str2bool_False(self):
+        result = str2bool(False)
+        self.assertFalse(result)
+
+    def test_str2bool_True_as_string(self):
+        result = str2bool('True')
+        self.assertTrue(result)
+
+    def test_str2bool_False_as_string(self):
+        result = str2bool('False')
+        self.assertFalse(result)
+
+    def test_str2bool_unknown_error(self):
+        self.assertRaises(Exception, str2bool, 'unknown')