コード例 #1
0
def execute_app_orchestration():
    # Retrieve data from environment variables
    reservation_id = helpers.get_reservation_context_details().id
    resource_details = helpers.get_resource_context_details_dict()
    helpers.get_resource_context_details()
    app_name = resource_details["name"]
    deployment_service = resource_details["appData"]["deploymentService"][
        "name"]
    installation_service_data = resource_details["appData"][
        "installationService"]

    # Start api session
    api = helpers.get_api_session()

    # execute deploy app
    deployment_result = deploy_app(api, app_name, deployment_service,
                                   reservation_id)

    # if visual connector endpoints contains service with attribute "Virtual Network" execute connect command
    # TODO

    # TODO this is temporary until we move to drivers
    api.SetAttributesValues([
        ResourceAttributesUpdateRequest(
            deployment_result.LogicalResourceName, [
                AttributeNameValue("VM_UUID", deployment_result.VmUuid),
                AttributeNameValue("Cloud Provider",
                                   deployment_result.CloudProviderResourceName)
            ])
    ])

    # connect all
    connect_all(api, reservation_id)

    # "Power On"
    power_on_deployed_app(api, app_name, deployment_result, reservation_id)

    # if install service exists on app execute it
    execute_installation_if_exist(api, deployment_result,
                                  installation_service_data, reservation_id)

    # refresh ip
    #refresh_ip(api, deployment_result, reservation_id)

    # Set live status - deployment done
    api.SetResourceLiveStatus(deployment_result.LogicalResourceName, "Online",
                              "Active")

    logger.info("Deployed {0} Successfully".format(app_name))
コード例 #2
0
    def get_data_for_deployment(self):
        """ execute the command """
        resource_context = helpers.get_resource_context_details()

        # get vCenter resource name, template name, template folder
        template_model = self.cs_retriever_service.getVCenterTemplateAttributeData(resource_context)
        print "Template: {0}, Folder: {1}, vCenter: {2}".format(template_model.template_name, template_model.vm_folder, template_model.vCenter_resource_name)

        # get power state of the cloned VM
        power_on = self.cs_retriever_service.getPowerStateAttributeData(resource_context)
        print "Power On: {0}".format(power_on)

        # get cluster and resource pool
        vm_cluster_model = self.cs_retriever_service.getVMClusterAttributeData(resource_context)
        print "Cluster: {0}, Resource Pool: {1}".format(vm_cluster_model.cluster_name, vm_cluster_model.resource_pool)

        # get datastore
        datastore_name = self.cs_retriever_service.getVMStorageAttributeData(resource_context)
        print "Datastore: {0}".format(datastore_name)

        connection_details = self.resource_connection_details_retriever.connection_details(
            template_model.vCenter_resource_name)
        print "Connecting to: {0}, As: {1}, Pwd: {2}, Port: {3}".format(connection_details.host,
                                                                        connection_details.username,
                                                                        connection_details.password,
                                                                        connection_details.port)

        return DataHolder(resource_context,
                          connection_details,
                          template_model,
                          datastore_name,
                          vm_cluster_model,
                          power_on)
コード例 #3
0
def main():
    # get vlan auto resource model
    resource_context = helpers.get_resource_context_details()
    resource_model_parser = ResourceModelParser()
    vlan_auto_resource_model = resource_model_parser.convert_to_resource_model(resource_context)
    # get reservation details
    reservation_context = helpers.get_reservation_context_details()
    # Start api session
    api = helpers.get_api_session()

    vlan_service_provider = VlanResolverProvider(vlan_resource_model=vlan_auto_resource_model,
                                                 pool_id=reservation_context.domain,
                                                 reservation_id=reservation_context.id,
                                                 owner_id=resource_context.name,
                                                 api=api)

    if not vlan_service_provider.is_vlan_resolved():
        # resolve vlan id
        vlan_id = vlan_service_provider.resolve_vlan_auto()
        vlan_id = str(vlan_id)
        # set resolved vlan id to virtual network attribute
        api.SetServiceAttributesValues(reservation_context.id,
                                       resource_context.name,
                                       [AttributeNameValue(
                                               vlan_auto_resource_model.virtual_network_attribute,
                                               vlan_id)])
        _logger.info("{0} resolved vlan id {1} successfully".format(resource_context.name, vlan_id))

    else:
        vlan_id = str(vlan_auto_resource_model.virtual_network)
        _logger.info("{0} already has a resolved vlan id: {1}".format(resource_context.name, vlan_id))

    # command result for programmatic use
    set_command_result(vlan_id)
コード例 #4
0
def execute_app_orchestration():
    # Retrieve data from environment variables
    reservation_id = helpers.get_reservation_context_details().id
    resource_details = helpers.get_resource_context_details_dict()
    helpers.get_resource_context_details()
    app_name = resource_details["name"]
    deployment_service = resource_details["appData"]["deploymentService"]["name"]
    installation_service_data = resource_details["appData"]["installationService"]

    # Start api session
    api = helpers.get_api_session()

    # execute deploy app
    deployment_result = deploy_app(api, app_name, deployment_service, reservation_id)

    # if visual connector endpoints contains service with attribute "Virtual Network" execute connect command
    # TODO

    # TODO this is temporary until we move to drivers
    api.SetAttributesValues(
            [ResourceAttributesUpdateRequest(
                    deployment_result.LogicalResourceName,
                    [AttributeNameValue("VM_UUID", deployment_result.VmUuid),
                     AttributeNameValue("Cloud Provider", deployment_result.CloudProviderResourceName)])])

    # connect all
    connect_all(api, reservation_id)

    # "Power On"
    power_on_deployed_app(api, app_name, deployment_result, reservation_id)

    # if install service exists on app execute it
    execute_installation_if_exist(api, deployment_result, installation_service_data, reservation_id)

    # refresh ip
    #refresh_ip(api, deployment_result, reservation_id)

    # Set live status - deployment done
    api.SetResourceLiveStatus(deployment_result.LogicalResourceName, "Online", "Active")

    logger.info("Deployed {0} Successfully".format(app_name))
    def execute(self):
        resource_att = helpers.get_resource_context_details()

        inventory_path_data = self.csRetrieverService.getVCenterInventoryPathAttributeData(resource_att)
        vcenter_resource_name = inventory_path_data["vCenter_resource_name"]
        vcenter_resource_path = inventory_path_data["vm_folder"]

        connection_details = self.resourceConnectionDetailsRetriever.get_connection_details(vcenter_resource_name)
        message_details = u"'{}:{}' User: '******'".format(connection_details.host, connection_details.port,
                                                       connection_details.user)
        try:
            si = self.pvService.connect(connection_details.host, connection_details.user, connection_details.password,
                                        connection_details.port)
        except Exception, ex:
            _logger.warn(u"Cannot connect {} Reason: {}".format(message_details, ex))
            raise ConnectionException(message_details)
コード例 #6
0
    def _get_data_holder(self):
        resource_context = helpers.get_resource_context_details()

        # get vCenter resource name, template name, template folder
        template_model = self.cs_retriever_service.getVCenterTemplateAttributeData(resource_context)
        # get power state of the cloned VM
        power_on = self.cs_retriever_service.getPowerStateAttributeData(resource_context)
        # get cluster and resource pool
        vm_cluster_model = self.cs_retriever_service.getVMClusterAttributeData(resource_context)
        # get datastore
        datastore_name = self.cs_retriever_service.getVMStorageAttributeData(resource_context)

        return DeployDataHolder.create_from_params(template_model=template_model,
                                                   datastore_name=datastore_name,
                                                   vm_cluster_model=vm_cluster_model,
                                                   power_on=power_on)
    def integrationtest_get_auto_vlan_specific_id(self):

        dev_helpers.attach_to_cloudshell_as(
            "admin", "admin", "Global", "4255fc8b-f964-444d-aa0c-96ae58659a52")

        requested_vlan_id = "24"
        os.environ["RESOURCECONTEXT"] = \
            '{' \
            ' "name":"VLAN Auto", ' \
            ' "address":"Service",' \
            ' "model":"VLAN Auto", ' \
            ' "family":"Virtual Network", ' \
            ' "description":"", ' \
            ' "fullname":"", ' \
            ' "attributes":{"Access Mode":"trunk",' \
                            '"Allocation Ranges":"2-4098",' \
                            '"Isolation Level":"Shared", ' \
                            '"Virtual Network":"", ' \
                            '"VLAN Id":"' + requested_vlan_id + '"}}'

        resource_context = helpers.get_resource_context_details()

        vlan_auto_resource_model = VLANAutoResourceModel()
        vlan_auto_resource_model.access_mode = resource_context.attributes[
            "Access Mode"]
        vlan_auto_resource_model.allocation_ranges = resource_context.attributes[
            "Allocation Ranges"]
        vlan_auto_resource_model.isolation_level = resource_context.attributes[
            "Isolation Level"]
        vlan_auto_resource_model.vlan_id = resource_context.attributes[
            "VLAN Id"]
        vlan_auto_resource_model.virtual_network = resource_context.attributes[
            "Virtual Network"]
        vlan_auto_resource_model.virtual_network_attribute = "Virtual Network"

        # get reservation details
        reservation_details = helpers.get_reservation_context_details()

        # Start api session
        api = helpers.get_api_session()

        vlan_service_provider = VlanResolverProvider(
            vlan_auto_resource_model, reservation_details.domain,
            reservation_details.id, resource_context.name, api)
        vlan_id = vlan_service_provider.resolve_vlan_auto()

        assert (vlan_id, requested_vlan_id)
    def integrationtest_get_auto_vlan_specific_id(self):

        dev_helpers.attach_to_cloudshell_as("admin", "admin", "Global", "4255fc8b-f964-444d-aa0c-96ae58659a52")

        requested_vlan_id = "24"
        os.environ["RESOURCECONTEXT"] = \
            '{' \
            ' "name":"VLAN Auto", ' \
            ' "address":"Service",' \
            ' "model":"VLAN Auto", ' \
            ' "family":"Virtual Network", ' \
            ' "description":"", ' \
            ' "fullname":"", ' \
            ' "attributes":{"Access Mode":"trunk",' \
                            '"Allocation Ranges":"2-4098",' \
                            '"Isolation Level":"Shared", ' \
                            '"Virtual Network":"", ' \
                            '"VLAN Id":"' + requested_vlan_id + '"}}'

        resource_context = helpers.get_resource_context_details()

        vlan_auto_resource_model = VLANAutoResourceModel()
        vlan_auto_resource_model.access_mode = resource_context.attributes["Access Mode"]
        vlan_auto_resource_model.allocation_ranges = resource_context.attributes["Allocation Ranges"]
        vlan_auto_resource_model.isolation_level = resource_context.attributes["Isolation Level"]
        vlan_auto_resource_model.vlan_id = resource_context.attributes["VLAN Id"]
        vlan_auto_resource_model.virtual_network = resource_context.attributes["Virtual Network"]
        vlan_auto_resource_model.virtual_network_attribute = "Virtual Network"

        # get reservation details
        reservation_details = helpers.get_reservation_context_details()

        # Start api session
        api = helpers.get_api_session()

        vlan_service_provider = VlanResolverProvider(vlan_auto_resource_model,
                                                     reservation_details.domain,
                                                     reservation_details.id,
                                                     resource_context.name,
                                                     api)
        vlan_id = vlan_service_provider.resolve_vlan_auto()

        assert(vlan_id, requested_vlan_id)
コード例 #9
0
    def execute(self):
        resource_att = helpers.get_resource_context_details()

        inventory_path_data = self.csRetrieverService.getVCenterInventoryPathAttributeData(
            resource_att)
        vcenter_resource_name = inventory_path_data["vCenter_resource_name"]
        vcenter_resource_path = inventory_path_data["vm_folder"]

        connection_details = self.resourceConnectionDetailsRetriever.get_connection_details(
            vcenter_resource_name)
        message_details = u"'{}:{}' User: '******'".format(connection_details.host,
                                                       connection_details.port,
                                                       connection_details.user)
        try:
            si = self.pvService.connect(connection_details.host,
                                        connection_details.user,
                                        connection_details.password,
                                        connection_details.port)
        except Exception, ex:
            _logger.warn(u"Cannot connect {} Reason: {}".format(
                message_details, ex))
            raise ConnectionException(message_details)
コード例 #10
0
def main():
    # get vlan auto resource model
    resource_context = helpers.get_resource_context_details()
    resource_model_parser = ResourceModelParser()
    vlan_auto_resource_model = resource_model_parser.convert_to_resource_model(
        resource_context)
    # get reservation details
    reservation_context = helpers.get_reservation_context_details()
    # Start api session
    api = helpers.get_api_session()

    vlan_service_provider = VlanResolverProvider(
        vlan_resource_model=vlan_auto_resource_model,
        pool_id=reservation_context.domain,
        reservation_id=reservation_context.id,
        owner_id=resource_context.name,
        api=api)

    if not vlan_service_provider.is_vlan_resolved():
        # resolve vlan id
        vlan_id = vlan_service_provider.resolve_vlan_auto()
        vlan_id = str(vlan_id)
        # set resolved vlan id to virtual network attribute
        api.SetServiceAttributesValues(
            reservation_context.id, resource_context.name, [
                AttributeNameValue(
                    vlan_auto_resource_model.virtual_network_attribute,
                    vlan_id)
            ])
        _logger.info("{0} resolved vlan id {1} successfully".format(
            resource_context.name, vlan_id))

    else:
        vlan_id = str(vlan_auto_resource_model.virtual_network)
        _logger.info("{0} already has a resolved vlan id: {1}".format(
            resource_context.name, vlan_id))

    # command result for programmatic use
    set_command_result(vlan_id)
コード例 #11
0
    def execute(self):
        """ execute the command """

        resource_att = helpers.get_resource_context_details()

        # get vCenter resource name
        inventory_path_data = self.csRetrieverService.getVCenterInventoryPathAttributeData(resource_att)
        vCenter_resource_name = inventory_path_data.vCenter_resource_name
        vm_folder = inventory_path_data.vm_folder

        print "Folder: {0}, vCenter: {1}".format(vm_folder, vCenter_resource_name)

        reservation_id = helpers.get_reservation_context_details().id
        session = helpers.get_api_session()
        vCenter_details = session.GetResourceDetails(vCenter_resource_name)

        # get vCenter connection details from vCenter resource
        vCenterConn = self.csRetrieverService.getVCenterConnectionDetails(session, vCenter_details)

        print "Connecting to: {0}, As: {1}, Pwd: {2}".format(vCenterConn["vCenter_url"], vCenterConn["user"],
                                                             vCenterConn["password"])

        # connect
        si = self.pvService.connect(vCenterConn["vCenter_url"], vCenterConn["user"], vCenterConn["password"])
        content = si.RetrieveContent()

        # destroy the vm
        vm_name = resource_att.name
        self.pvService.destroy_vm_by_name(content, si, vm_name)

        # disconnect
        self.pvService.disconnect(si)

        # delete resource 
        helpers.get_api_session() \
            .DeleteResource(resource_att.fullname)
コード例 #12
0
 def __init__(self, resource_model_parser):
     self.resource_model_parser = resource_model_parser
     self.resource_context = helpers.get_resource_context_details()
     self.generic_deployed_app_resource_model = self.resource_model_parser.convert_to_resource_model(
         self.resource_context)
コード例 #13
0
 def __init__(self, resource_model_parser):
     self.resource_model_parser = resource_model_parser
     self.resource_context = helpers.get_resource_context_details()
     self.generic_deployed_app_resource_model = self.resource_model_parser.convert_to_resource_model(
             self.resource_context)
コード例 #14
0
def run(pvService, cloudshellConnectData):
    """
    Create a VM, sleep, and destroy the VM

    pvService:              pyVmomiService Instance
    cloudshellConnectData:  dictionary with cloudshell connection data
    """

    csRetrieverService = CloudshellDataRetrieverService()

    dev_helpers.attach_to_cloudshell_as(cloudshellConnectData["user"],
                                        cloudshellConnectData["password"],
                                        cloudshellConnectData["domain"],
                                        cloudshellConnectData["reservationId"])
    resource_att = helpers.get_resource_context_details()

    # get vCenter resource name, template name, template folder
    vCenterTemplateAttData = csRetrieverService.getVCenterTemplateAttributeData(
        resource_att)
    template_name = vCenterTemplateAttData["template_name"]
    vCenter_resource_name = vCenterTemplateAttData["vCenter_resource_name"]
    vm_folder = vCenterTemplateAttData["vm_folder"]
    print "Template: {0}, Folder: {1}, vCenter: {2}".format(
        template_name, vm_folder, vCenter_resource_name)

    # get power state of the cloned VM
    power_on = csRetrieverService.getPowerStateAttributeData(resource_att)
    print "Power On: {0}".format(power_on)

    # get cluster and resource pool
    vmClusterAttData = csRetrieverService.getVMClusterAttributeData(
        resource_att)
    cluster_name = vmClusterAttData["cluster_name"]
    resource_pool = vmClusterAttData["resource_pool"]
    print "Cluster: {0}, Resource Pool: {1}".format(cluster_name,
                                                    resource_pool)

    # get datastore
    datastore_name = csRetrieverService.getVMStorageAttributeData(resource_att)
    print "Datastore: {0}".format(datastore_name)

    reservation_id = helpers.get_reservation_context_details().id
    session = helpers.get_api_session()
    vCenter_details = session.GetResourceDetails(vCenter_resource_name)

    # get vCenter connection details from vCenter resource
    vCenterConn = csRetrieverService.getVCenterConnectionDetails(
        session, vCenter_details)
    print "Connecting to: {0}, As: {1}, Pwd: {2}".format(
        vCenterConn["vCenter_url"], vCenterConn["user"],
        vCenterConn["password"])

    # connect
    si = pvService.connect(vCenterConn["vCenter_url"], vCenterConn["user"],
                           vCenterConn["password"])
    content = si.RetrieveContent()
    template = pvService.get_obj(content, [vim.VirtualMachine], template_name)

    if template:
        # generate unique name
        vm_name = generate_unique_name(template_name)

        vm = pvService.clone_vm(content=content,
                                si=si,
                                template=template,
                                vm_name=vm_name,
                                datacenter_name=None,
                                vm_folder=vm_folder,
                                datastore_name=datastore_name,
                                cluster_name=cluster_name,
                                resource_pool=resource_pool,
                                power_on=power_on)

        helpers.get_api_session() \
            .CreateResource("Virtual Machine",
                            "Virtual Machine", vm_name,
                            vm.summary.config.instanceUuid)
        helpers.get_api_session() \
            .AddResourcesToReservation(reservation_id, [vm_name])
        helpers.get_api_session() \
            .SetAttributeValue(vm_name,
                               "vCenter Inventory Path",
                               attributeValue = vCenter_resource_name + "/" + vm_folder)

        sleep_sec = 5
        print "Sleep for {0} sec".format(sleep_sec)
        time.sleep(sleep_sec)

        # delete the VM and delete resource
        pvService.destroy_vm(content, si, vm)
        helpers.get_api_session().DeleteResource(vm_name)

    else:
        print "template not found"

    pvService.disconnect(si)
コード例 #15
0
def run(pvService, cloudshellConnectData):
    """
    Create a VM, sleep, and destroy the VM

    pvService:              pyVmomiService Instance
    cloudshellConnectData:  dictionary with cloudshell connection data
    """

    csRetrieverService = CloudshellDataRetrieverService()

    dev_helpers.attach_to_cloudshell_as(cloudshellConnectData["user"], 
                                        cloudshellConnectData["password"], 
                                        cloudshellConnectData["domain"], 
                                        cloudshellConnectData["reservationId"])
    resource_att = helpers.get_resource_context_details()
        

    # get vCenter resource name, template name, template folder
    vCenterTemplateAttData = csRetrieverService.getVCenterTemplateAttributeData(resource_att)
    template_name = vCenterTemplateAttData["template_name"]
    vCenter_resource_name = vCenterTemplateAttData["vCenter_resource_name"]
    vm_folder = vCenterTemplateAttData["vm_folder"]
    print "Template: {0}, Folder: {1}, vCenter: {2}".format(template_name,vm_folder,vCenter_resource_name)
    

    # get power state of the cloned VM
    power_on = csRetrieverService.getPowerStateAttributeData(resource_att)
    print "Power On: {0}".format(power_on)


    # get cluster and resource pool
    vmClusterAttData = csRetrieverService.getVMClusterAttributeData(resource_att)
    cluster_name = vmClusterAttData["cluster_name"]
    resource_pool = vmClusterAttData["resource_pool"]
    print "Cluster: {0}, Resource Pool: {1}".format(cluster_name, resource_pool)


    # get datastore
    datastore_name = csRetrieverService.getVMStorageAttributeData(resource_att)
    print "Datastore: {0}".format(datastore_name)


    reservation_id = helpers.get_reservation_context_details().id
    session = helpers.get_api_session()
    vCenter_details = session.GetResourceDetails(vCenter_resource_name)
    
    # get vCenter connection details from vCenter resource
    vCenterConn = csRetrieverService.getVCenterConnectionDetails(session, vCenter_details)
    print "Connecting to: {0}, As: {1}, Pwd: {2}".format(vCenterConn["vCenter_url"] , vCenterConn["user"], vCenterConn["password"])
 
    # connect
    si = pvService.connect(vCenterConn["vCenter_url"] , vCenterConn["user"], vCenterConn["password"])
    content = si.RetrieveContent()
    template = pvService.get_obj(content, [vim.VirtualMachine], template_name)
    
    if template:
        # generate unique name
        vm_name = generate_unique_name(template_name)

        vm = pvService.clone_vm(
            content = content, 
            si = si,
            template = template, 
            vm_name = vm_name,
            datacenter_name = None, 
            vm_folder = vm_folder, 
            datastore_name = datastore_name, 
            cluster_name = cluster_name,
            resource_pool = resource_pool,
            power_on = power_on)

        helpers.get_api_session() \
            .CreateResource("Virtual Machine",
                            "Virtual Machine", vm_name,
                            vm.summary.config.instanceUuid)
        helpers.get_api_session() \
            .AddResourcesToReservation(reservation_id, [vm_name])
        helpers.get_api_session() \
            .SetAttributeValue(vm_name,
                               "vCenter Inventory Path",
                               attributeValue = vCenter_resource_name + "/" + vm_folder)


        sleep_sec = 5
        print "Sleep for {0} sec".format(sleep_sec)
        time.sleep( sleep_sec )

        
        # delete the VM and delete resource
        pvService.destroy_vm(content, si, vm)
        helpers.get_api_session().DeleteResource(vm_name)

    else:
        print "template not found"

    pvService.disconnect(si)
コード例 #16
0
import time
import qualipy.api.cloudshell_api as CA
import json
import os
import errno
import qualipy.scripts.cloudshell_scripts_helpers as CS

serverAddress = CS.get_connectivity_context_details().server_address
adminUser = CS.get_connectivity_context_details().admin_user
adminPass = CS.get_connectivity_context_details().admin_pass
domain = CS.get_reservation_context_details().domain

#get the reservation id
resID = CS.get_reservation_context_details().id
#Set the ip of the host from the resource
host = CS.get_resource_context_details().address
#Set the user name of the user from the resource
atts = CS.get_resource_context_details().attributes
# Get the username out of the resource attributes
username = atts['User']

# Get the password out of the resource attributes
passwEn = atts['Password']

#Decrypt the password
session = CA.CloudShellAPISession(serverAddress, adminUser, adminPass, domain)
password = session.DecryptPassword(passwEn).Value


class TelnetManager:
    def __init__(self,
コード例 #17
0
import time
import qualipy.api.cloudshell_api as CA
import json
import os
import errno
import qualipy.scripts.cloudshell_scripts_helpers as CS

serverAddress = CS.get_connectivity_context_details().server_address
adminUser = CS.get_connectivity_context_details().admin_user
adminPass = CS.get_connectivity_context_details().admin_pass
domain = CS.get_reservation_context_details().domain

#get the reservation id
resID = CS.get_reservation_context_details().id
#Set the ip of the host from the resource
host = CS.get_resource_context_details().address
#Set the user name of the user from the resource
atts = CS.get_resource_context_details().attributes
# Get the username out of the resource attributes
username = atts['User']

# Get the password out of the resource attributes
passwEn = atts['Password']

#Decrypt the password
session = CA.CloudShellAPISession(serverAddress,adminUser,adminPass,domain)
password = session.DecryptPassword(passwEn).Value

class TelnetManager:
    def __init__(self, username, password, host, port=23,
                 timeout=60, newline='\r'):