Merge pull request #116 from QualiSystems/feature/borismod_40_save_vnic

Feature/borismod 40 save vnic

Author: alexazarh

.gitignore

@@ -65,8 +65,8 @@ tests/config.ini
 *.cache
 *.whl
 *.tar.gz
-vCenterShell/vCenterShell/vCenterShell.zip
 *.orig
 vCenterShell.zip
 vCenterShellPackage/Resource Scripts/*
+vCenterShellPackage/Topology Scripts/*.*
 debug.txt

common/logger/service.py

@@ -5,11 +5,10 @@
 from common.logger import getLogger, configure_loglevel
 
 _logger = getLogger("vCenterCommon")
-DEFAULT_LOG_FILE = "./logs/vCenterShell.log"
 
 
 class LoggingService(object):
-    def __init__(self, log_level_console, log_level_file=None, filename=DEFAULT_LOG_FILE):
+    def __init__(self, log_level_console, log_level_file, filename):
         from common.utilites.io import extract_folder_name, compose_folder_if_not_existed
 
         log_level_file = log_level_file or log_level_console

common/wrappers/command_wrapper.py

@@ -6,7 +6,7 @@
 COMMA = ','
 EXECUTING_COMMAND = 'executing command: {0}'
 CONNECTED_TO_CENTER = 'connected to vcenter: {0}'
-DEBUG_CONNECTION_INFO = 'connection params: host: {0} username: {1} password: {2} port: {3}'
+DEBUG_CONNECTION_INFO = 'connection params: host: {0} username: {1} port: {2}'
 LOGGER_CANNOT_BE_NONE = 'logger cannot be None'
 COMMAND_CANNOT_BE_NONE = 'command cannot be None'
 INFO_CONNECTING_TO_VCENTER = 'connecting to vcenter: {0}'
@@ -43,7 +43,6 @@ def execute_command_with_connection(self, connection_details, command, *args):
                 logger.debug(
                         DEBUG_CONNECTION_INFO.format(connection_details.host,
                                                      connection_details.username,
-                                                     connection_details.password,
                                                      connection_details.port))
 
                 si = self.pv_service.connect(connection_details.host,

deployed_app_service/__init__.py

@@ -0,0 +1,24 @@
+import qualipy.scripts.cloudshell_scripts_helpers as helpers
+
+from common.model_factory import ResourceModelParser
+from deployed_app_service.connect import DeployedAppService
+
+
+def main():
+    resource_model_parser = ResourceModelParser()
+    deployed_app_service = DeployedAppService(resource_model_parser)
+
+    vlan_spec_type = helpers.get_user_param('VLAN_SPEC_TYPE')
+
+    if not vlan_spec_type:
+        raise ValueError('VLAN_SPEC_TYPE is missing')
+
+    vlan_id = helpers.get_user_param('VLAN_ID')
+    if not vlan_id:
+        raise ValueError('VLAN_ID is missoing')
+
+    deployed_app_service.connect(vlan_spec_type, vlan_id)
+
+
+if __name__ == "__main__":
+    main()

deployed_app_service/__main__.py

@@ -0,0 +1,38 @@
+import qualipy.scripts.cloudshell_scripts_helpers as helpers
+from qualipy.api.cloudshell_api import InputNameValue
+
+
+class DeployedAppService(object):
+    def __init__(self, resource_model_parser):
+        self.resource_model_parser = resource_model_parser
+
+    def connect(self, access_mode, virtual_network):
+        """
+        Connect method should be executed on Deployed App
+        It executes connect command on vCenter resource for each connected VLAN
+        :param virtual_network: virtual network to connect to
+        :param access_mode: Access mode: Access or Trunk
+        """
+        resource_context = helpers.get_resource_context_details()
+        generic_deployed_app_resource_model = self.resource_model_parser.convert_to_resource_model(resource_context)
+
+        if not generic_deployed_app_resource_model.vm_uuid:
+            raise ValueError('VM _UUID is not set on Generic Deployed App')
+
+        if not generic_deployed_app_resource_model.cloud_provider:
+            raise ValueError('Cloud Provider is not set on Generic Deployed App')
+
+        self.execute_command_on_vcenter_resource(access_mode, generic_deployed_app_resource_model, virtual_network)
+
+    @staticmethod
+    def execute_command_on_vcenter_resource(access_mode, generic_deployed_app_resource_model, virtual_network):
+        session = helpers.get_api_session()
+        reservation_id = helpers.get_reservation_context_details().id
+        session.ExecuteCommand(reservation_id, generic_deployed_app_resource_model.cloud_provider,
+                               'Resource',
+                               'Connect VM',
+                               [InputNameValue('COMMAND', "connect"),
+                                InputNameValue('VLAN_ID', virtual_network),
+                                InputNameValue('VLAN_SPEC_TYPE', access_mode),
+                                InputNameValue('VM_UUID', generic_deployed_app_resource_model.vm_uuid)],
+                               True)

deployed_app_service/connect.py

@@ -1,13 +1,15 @@
 import os
 import sys
 import zipfile
+import ConfigParser
 
-DRIVER_FILE_NAME_FORMAT = 'vCenterShellPackage/Resource Scripts/{0}.zip'
+DRIVER_FILE_BASE_DIR = 'vCenterShellPackage'
 STRIPING_CHARS = ' \t\n\r'
 DRIVER_FOLDER = 'driver_folder'
 INCLUDE_DIRS = 'include_dirs'
 TARGET_NAME = 'target_name'
 VERSION_FILENAME = 'version.txt'
+TARGET_DIR = 'target_dir'
 
 
 def zip_dir(path, zip_handler, include_dir=True):
@@ -42,21 +44,17 @@ def add_version_file_to_zip(ziph, driver_path=None):
 def main(args):
     config_file_name = args[1]
 
-    with open(config_file_name) as f_config:
-        if f_config is None:
-            raise Exception('no packager config file found')
-        config = dict()
-        config_raw = f_config.read().splitlines()
-        for att in config_raw:
-            cnf_att = att.split(':')
-            config[cnf_att[0].strip(' \t\n\r')] = cnf_att[1].strip(STRIPING_CHARS).split(',')
+    config = ConfigParser.ConfigParser()
+    config.readfp(open(config_file_name))
 
-    target_name = config[TARGET_NAME][0]
-    driver = config[DRIVER_FOLDER][0]
+    driver = config.get('Packaging', DRIVER_FOLDER)
+    include_dirs = config.get('Packaging', INCLUDE_DIRS).split(',')
+    target_name = config.get('Packaging', TARGET_NAME)
+    target_dir = config.get('Packaging', TARGET_DIR)
 
-    print 'packing driver: {0}'.format(target_name)
+    zip_name = os.path.join(DRIVER_FILE_BASE_DIR, target_dir, target_name + '.zip')
 
-    zip_name = DRIVER_FILE_NAME_FORMAT.format(target_name)
+    print 'Packing driver {0} into {1}'.format(target_name, zip_name)
 
     ensure_dir(zip_name)
 
@@ -80,13 +78,10 @@ def main(args):
 
     add_version_file_to_zip(zip_file)
 
-    for dir_to_include in config[INCLUDE_DIRS]:
+    for dir_to_include in include_dirs:
         zip_dir(dir_to_include, zip_file)
 
     zip_file.close()
 
-    print 'done!'
-
-
 if __name__ == "__main__":
     main(sys.argv)

driver_packager.py

@@ -0,0 +1,10 @@
+from environment_scripts.connect_all import EnvironmentConnector
+
+
+def main():
+    environment_connector = EnvironmentConnector()
+    environment_connector.connect_all()
+
+
+if __name__ == "__main__":
+    main()

environment_scripts/__main__.py

@@ -1,23 +1,77 @@
 import qualipy.scripts.cloudshell_scripts_helpers as helpers
 from qualipy.api.cloudshell_api import InputNameValue
+from common.utilites.common_utils import first_or_default
 
-session = helpers.get_api_session()
-reservation_id = helpers.get_reservation_context_details().id
-connectors = session.GetReservationDetails(reservation_id).ReservationDescription.Connectors
-attributes = helpers.get_resource_context_details().attributes
-vlan = attributes['VLAN Id']
-access_mode = attributes['Access Mode']
-resource_name = helpers.get_resource_context_details().name
-
-connectedResources = [connector.Target for connector in connectors if connector.Source == resource_name] + \
-             [connector.Source for connector in connectors if connector.Target == resource_name]
-
-if not connectedResources:
-    raise Exception('There is no visual connectors connected to this VLAN')
-
-for connectedResource in connectedResources:
-    session.ExecuteCommand(reservation_id, connectedResource, 'Resource', 'Connect',
-                           [InputNameValue('COMMAND', "connect"),
-                            InputNameValue('VLAN_ID', vlan),
-                            InputNameValue('VLAN_SPEC_TYPE', access_mode)],
-                           True)
+from common.model_factory import ResourceModelParser
+
+
+class EnvironmentConnector(object):
+
+    def connect_all(self):
+        """
+        Connects all the VLAN Auto services to all the Deployed Apps in the same Environment
+        :return:
+        """
+        session = helpers.get_api_session()
+        reservation_id = helpers.get_reservation_context_details().id
+
+        # GetReservationDetails is performance heavy operation
+        reservation_details = session.GetReservationDetails(reservation_id)
+        vlan_services = self._get_vlan_auto_services(reservation_details)
+
+        connectors = self._get_connectors(reservation_details)
+
+        if not vlan_services or not connectors:
+            return
+
+        for vlan_service in vlan_services:
+
+            if not len(vlan_service.Attributes):
+                raise ValueError('No attributes on service {0}'.format(vlan_service.ServiceName))
+
+            access_mode = self._get_attribute(vlan_service.Attributes, 'Access Mode')
+            virtual_network = self._get_attribute(vlan_service.Attributes, 'Virtual Network')
+
+            # Get Deployed App connected to VLAN Auto service
+            connected_resources = self._get_connected_resources(connectors, vlan_service)
+
+            if not connected_resources:
+                continue
+
+            for connected_resource in connected_resources:
+                self._execute_connect_command_on_connected_resource(access_mode, connected_resource, reservation_id,
+                                                                    session, virtual_network)
+
+    @staticmethod
+    def _get_attribute(attributes, attribute_name):
+        attribute = next(item for item in attributes if item.Name == attribute_name)
+        if not attribute or not attribute.Value:
+            raise ValueError('Attribute {0} is missing'.format(attribute_name))
+        return attribute.Value
+
+    @staticmethod
+    def _get_connectors(reservation_details):
+        connectors = [connector for connector in reservation_details.ReservationDescription.Connectors]
+        return connectors
+
+    @staticmethod
+    def _get_vlan_auto_services(reservation_details):
+        vlan_services = [service for service in reservation_details.ReservationDescription.Services
+                         if service.ServiceName == 'VLAN Auto']
+        return vlan_services
+
+    @staticmethod
+    def _execute_connect_command_on_connected_resource(access_mode, connected_resource, reservation_id, session,
+                                                       virtual_network):
+        session.ExecuteCommand(reservation_id, connected_resource, 'Resource', 'Connect',
+                               [InputNameValue('VLAN_ID', virtual_network),
+                                InputNameValue('VLAN_SPEC_TYPE', access_mode)],
+                               True)
+
+    @staticmethod
+    def _get_connected_resources(connectors, vlan_service):
+        connected_resources = [connector.Target for connector in connectors if
+                               connector.Source == vlan_service.ServiceName] + \
+                              [connector.Source for connector in connectors if
+                               connector.Target == vlan_service.ServiceName]
+        return connected_resources

environment_scripts/connect_all.py

@@ -26,7 +26,7 @@ def execute_app_orchestration():
     api.SetAttributesValues(
             [ResourceAttributesUpdateRequest(
                     deployment_result.LogicalResourceName,
-                    [AttributeNameValue("VM UUID", deployment_result.VmUuid),
+                    [AttributeNameValue("VM_UUID", deployment_result.VmUuid),
                      AttributeNameValue("Cloud Provider", deployment_result.CloudProviderResourceName)])])
 
     # logical resource execute "Power On"
@@ -63,3 +63,6 @@ def deploy_app(api, app_name, deployment_service, reservation_id):
     except Exception as exc:
         logger.error("Error deploying app {0}. Error: {1}".format(app_name, str(exc)))
         exit(1)
+
+
+