Ejemplo n.º 1
0
def add_endpoint_to_network_config(network_config, public_endpoints, private_endpoints):
    """
    Return a new network config
    :param network_config:
    :param public_endpoints: a list of int or str
    :param private_endpoints: a list of int or str
    :return:
    """
    endpoints = zip(map(str, public_endpoints), map(str, private_endpoints))
    new_network_config = ConfigurationSet()
    new_network_config.configuration_set_type = network_config.configuration_set_type
    if network_config.input_endpoints is not None:
        for input_endpoint in network_config.input_endpoints.input_endpoints:
            new_network_config.input_endpoints.input_endpoints.append(
                ConfigurationSetInputEndpoint(input_endpoint.name,
                                              input_endpoint.protocol,
                                              input_endpoint.port,
                                              input_endpoint.local_port)
            )
    for endpoint in endpoints:
        new_network_config.input_endpoints.input_endpoints.append(
            ConfigurationSetInputEndpoint(ENDPOINT_PREFIX + endpoint[0],
                                          ENDPOINT_PROTOCOL,
                                          endpoint[0],
                                          endpoint[1])
        )
    return new_network_config
Ejemplo n.º 2
0
def get_network_config(network_config, assigned_endpoints):
    """A helper to generate network config from azure_template_unit's network config

    decouple from azure_template_unit.get_network_config
    Public endpoint should be assigned in real time
    """

    nc = network_config

    network_config = ConfigurationSet()
    network_config.configuration_set_type = nc[
        AZURE_UNIT.NETWORK_CONFIG_CONFIGURATION_SET_TYPE]
    input_endpoints = nc[AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS]
    # avoid duplicate endpoint under same cloud service
    endpoints = map(
        lambda i: i[AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS_LOCAL_PORT],
        input_endpoints)
    unassigned_endpoints = map(
        str, find_unassigned_endpoints(endpoints, assigned_endpoints))
    map(
        lambda
        (i, u): i.update({AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS_PORT: u}),
        zip(input_endpoints, unassigned_endpoints))

    for input_endpoint in input_endpoints:
        network_config.input_endpoints.input_endpoints.append(
            ConfigurationSetInputEndpoint(
                input_endpoint[AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS_NAME],
                input_endpoint[
                    AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS_PROTOCOL],
                input_endpoint[AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS_PORT],
                input_endpoint[
                    AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS_LOCAL_PORT]))

    return network_config
Ejemplo n.º 3
0
def add_endpoint_to_network_config(network_config, public_endpoints,
                                   private_endpoints):
    """
    Return a new network config
    :param network_config:
    :param public_endpoints: a list of int or str
    :param private_endpoints: a list of int or str
    :return:
    """
    endpoints = zip(map(str, public_endpoints), map(str, private_endpoints))
    new_network_config = ConfigurationSet()
    new_network_config.configuration_set_type = network_config.configuration_set_type
    if network_config.input_endpoints is not None:
        for input_endpoint in network_config.input_endpoints.input_endpoints:
            new_network_config.input_endpoints.input_endpoints.append(
                ConfigurationSetInputEndpoint(input_endpoint.name,
                                              input_endpoint.protocol,
                                              input_endpoint.port,
                                              input_endpoint.local_port))
    for endpoint in endpoints:
        new_network_config.input_endpoints.input_endpoints.append(
            ConfigurationSetInputEndpoint(ENDPOINT_PREFIX + endpoint[0],
                                          ENDPOINT_PROTOCOL, endpoint[0],
                                          endpoint[1]))
    return new_network_config
Ejemplo n.º 4
0
 def get_network_config(self, service, update):
     """
     Return None if image type is vm and not update
     Public endpoint should be assigned in real time
     :param service:
     :return:
     """
     if self.is_vm_image() and not update:
         return None
     cs = self.virtual_environment[self.T_CS]
     nc = self.virtual_environment[self.T_NC]
     network_config = ConfigurationSet()
     network_config.configuration_set_type = nc[self.T_NC_CST]
     input_endpoints = nc[self.T_NC_IE]
     # avoid duplicate endpoint under same cloud service
     assigned_endpoints = service.get_assigned_endpoints(cs[self.T_CS_SN])
     endpoints = map(lambda i: i[self.T_NC_IE_LP], input_endpoints)
     unassigned_endpoints = map(
         str, find_unassigned_endpoints(endpoints, assigned_endpoints))
     map(lambda (i, u): i.update({self.T_NC_IE_PO: u}),
         zip(input_endpoints, unassigned_endpoints))
     for input_endpoint in input_endpoints:
         network_config.input_endpoints.input_endpoints.append(
             ConfigurationSetInputEndpoint(input_endpoint[self.T_NC_IE_N],
                                           input_endpoint[self.T_NC_IE_PR],
                                           input_endpoint[self.T_NC_IE_PO],
                                           input_endpoint[self.T_NC_IE_LP]))
     return network_config
Ejemplo n.º 5
0
 def get_network_config(self, service, update):
     """
     Return None if image type is vm and not update
     Public endpoint should be assigned in real time
     :param service:
     :return:
     """
     if self.is_vm_image() and not update:
         return None
     cs = self.virtual_environment[self.T_CS]
     nc = self.virtual_environment[self.T_NC]
     network_config = ConfigurationSet()
     network_config.configuration_set_type = nc[self.T_NC_CST]
     input_endpoints = nc[self.T_NC_IE]
     # avoid duplicate endpoint under same cloud service
     assigned_endpoints = service.get_assigned_endpoints(cs[self.T_CS_SN])
     endpoints = map(lambda i: i[self.T_NC_IE_LP], input_endpoints)
     unassigned_endpoints = map(str, find_unassigned_endpoints(endpoints, assigned_endpoints))
     map(lambda (i, u): i.update({self.T_NC_IE_PO: u}), zip(input_endpoints, unassigned_endpoints))
     for input_endpoint in input_endpoints:
         network_config.input_endpoints.input_endpoints.append(
             ConfigurationSetInputEndpoint(
                 input_endpoint[self.T_NC_IE_N],
                 input_endpoint[self.T_NC_IE_PR],
                 input_endpoint[self.T_NC_IE_PO],
                 input_endpoint[self.T_NC_IE_LP]
             )
         )
     return network_config
Ejemplo n.º 6
0
def get_network_config(network_config, assigned_endpoints):
    """A helper to generate network config from azure_template_unit's network config

    decouple from azure_template_unit.get_network_config
    Public endpoint should be assigned in real time
    """

    nc = network_config

    network_config = ConfigurationSet()
    network_config.configuration_set_type = nc[AZURE_UNIT.NETWORK_CONFIG_CONFIGURATION_SET_TYPE]
    input_endpoints = nc[AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS]
    # avoid duplicate endpoint under same cloud service
    endpoints = map(lambda i: i[AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS_LOCAL_PORT], input_endpoints)
    unassigned_endpoints = map(str, __find_unassigned_endpoints(endpoints, assigned_endpoints))
    map(lambda (i, u): i.update({AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS_PORT: u}), zip(input_endpoints, unassigned_endpoints))

    for input_endpoint in input_endpoints:
        network_config.input_endpoints.input_endpoints.append(
            ConfigurationSetInputEndpoint(
                input_endpoint[AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS_NAME],
                input_endpoint[AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS_PROTOCOL],
                input_endpoint[AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS_PORT],
                input_endpoint[AZURE_UNIT.NETWORK_CONFIG_INPUT_ENDPOINTS_LOCAL_PORT]
            )
        )

    return network_config
Ejemplo n.º 7
0
    def get_network_config(self, azure_key_id, update):
        """
        Return None if image type is vm and not update
        Public endpoint should be assigned in real time
        :param service:
        :return:
        """
        azure_service = RequiredFeature("azure_service")

        if self.is_vm_image() and not update:
            return None
        cs = self.virtual_environment[self.T_CLOUD_SERVICE]
        nc = self.virtual_environment[self.T_NETWORK_CONFIG]
        network_config = ConfigurationSet()
        network_config.configuration_set_type = nc[self.T_CONFIGURATION_SET_TYPE]
        input_endpoints = nc[self.T_INPUT_ENDPOINTS]
        # avoid duplicate endpoint under same cloud service
        assigned_endpoints = azure_service.get_assigned_endpoints(azure_key_id, cs[self.SERVICE_NAME])
        endpoints = map(lambda i: i[self.T_LOCAL_PORT], input_endpoints)
        unassigned_endpoints = map(str, find_unassigned_endpoints(endpoints, assigned_endpoints))
        map(lambda (i, u): i.update({self.PORT: u}), zip(input_endpoints, unassigned_endpoints))
        for input_endpoint in input_endpoints:
            network_config.input_endpoints.input_endpoints.append(
                ConfigurationSetInputEndpoint(
                    input_endpoint[self.NAME],
                    input_endpoint[self.PROTOCOL],
                    input_endpoint[self.PORT],
                    input_endpoint[self.T_LOCAL_PORT]
                )
            )
        return network_config
Ejemplo n.º 8
0
 def create_network_configuration(self, network_endpoints):
     """
         create a network configuration
     """
     network_config = ConfigurationSet()
     for endpoint in network_endpoints:
         network_config.input_endpoints.input_endpoints.append(endpoint)
     network_config.configuration_set_type = 'NetworkConfiguration'
     return network_config
Ejemplo n.º 9
0
    def _ensureBuildMachineExists(self):
        """
        Creates the VM for the build server.
        """
        service_name = self.config.getBuildServiceName()
        service_storage_name = self.config.getStorageAccountName()
        cert_thumbprint = self.config.getServiceCertificateThumbprint()
        vm_username = self.config.getVirtualMachineLogonUsername()
        vm_password = self.config.getVirtualMachineLogonPassword()
        vm_hostname = service_name

        role_instances = self._getRoleInstances(service_name)
        if vm_hostname in role_instances:
            logger.warn("Role instance %s already exists: skipping creation.", vm_hostname)
        else:
            logger.info("Role instance %s provisioning begins.", vm_hostname)
            self._assertOsImageExists(self.config.getBuildOSImageName())

            vm_diskname = '{0}.vhd'.format(vm_hostname)
            vm_disk_media_link = 'http://{0}.blob.core.windows.net/vhds/{1}'.format(service_storage_name, vm_diskname)
            os_hd = OSVirtualHardDisk(self.config.getBuildOSImageName(),
                                      vm_disk_media_link,
                                      disk_name=vm_diskname,
                                      disk_label=vm_diskname)
            linux_config = LinuxConfigurationSet(vm_hostname, vm_username, vm_password, True)
            linux_config.ssh.public_keys.public_keys.append(
                PublicKey(cert_thumbprint, u'/home/{0}/.ssh/authorized_keys'.format(vm_username))
            )
            linux_config.ssh.key_pairs.key_pairs.append(
                KeyPair(cert_thumbprint, u'/home/{0}/.ssh/id_rsa'.format(vm_username))
            )
            network_config = ConfigurationSet()
            network_config.configuration_set_type = 'NetworkConfiguration'
            ssh_endpoint = ConfigurationSetInputEndpoint(name='SSH',
                                                         protocol='TCP',
                                                         port=u'22',
                                                         local_port=u'22')
            network_config.input_endpoints.input_endpoints.append(ssh_endpoint)

            result = self.sms.create_virtual_machine_deployment(service_name=service_name,
                                                                deployment_name=service_name,
                                                                deployment_slot='Production',
                                                                label=vm_hostname,
                                                                role_name=vm_hostname,
                                                                system_config=linux_config,
                                                                os_virtual_hard_disk=os_hd,
                                                                network_config=network_config,
                                                                availability_set_name=None,
                                                                data_virtual_hard_disks=None,
                                                                role_size=self.config.getBuildInstanceRoleSize())
            self._wait_for_operation_success(result.request_id, timeout=self.config.getAzureOperationTimeout())
            self._wait_for_role_instance_status(vm_hostname, service_name, 'ReadyRole',
                                                self.config.getAzureOperationTimeout())
            logger.info("Role instance %s has been created.", vm_hostname)
Ejemplo n.º 10
0
    def _ensureBuildMachineExists(self):
        """
        Creates the VM for the build server.
        """
        service_name = self.config.getBuildServiceName()
        service_storage_name = self.config.getStorageAccountName()
        cert_thumbprint = self.config.getServiceCertificateThumbprint()
        vm_username = self.config.getVirtualMachineLogonUsername()
        vm_password = self.config.getVirtualMachineLogonPassword()
        vm_hostname = service_name

        role_instances = self._getRoleInstances(service_name)
        if vm_hostname in role_instances:
            logger.warn("Role instance %s already exists: skipping creation.", vm_hostname)
        else:
            logger.info("Role instance %s provisioning begins.", vm_hostname)
            self._assertOsImageExists(self.config.getBuildOSImageName())

            vm_diskname = '{0}.vhd'.format(vm_hostname)
            vm_disk_media_link = 'http://{0}.blob.core.windows.net/vhds/{1}'.format(service_storage_name, vm_diskname)
            os_hd = OSVirtualHardDisk(self.config.getBuildOSImageName(),
                                      vm_disk_media_link,
                                      disk_name=vm_diskname,
                                      disk_label=vm_diskname)
            linux_config = LinuxConfigurationSet(vm_hostname, vm_username, vm_password, True)
            linux_config.ssh.public_keys.public_keys.append(
                PublicKey(cert_thumbprint, u'/home/{0}/.ssh/authorized_keys'.format(vm_username))
            )
            linux_config.ssh.key_pairs.key_pairs.append(
                KeyPair(cert_thumbprint, u'/home/{0}/.ssh/id_rsa'.format(vm_username))
            )
            network_config = ConfigurationSet()
            network_config.configuration_set_type = 'NetworkConfiguration'
            ssh_endpoint = ConfigurationSetInputEndpoint(name='SSH',
                                                         protocol='TCP',
                                                         port=u'22',
                                                         local_port=u'22')
            network_config.input_endpoints.input_endpoints.append(ssh_endpoint)

            result = self.sms.create_virtual_machine_deployment(service_name=service_name,
                                                                deployment_name=service_name,
                                                                deployment_slot='Production',
                                                                label=vm_hostname,
                                                                role_name=vm_hostname,
                                                                system_config=linux_config,
                                                                os_virtual_hard_disk=os_hd,
                                                                network_config=network_config,
                                                                availability_set_name=None,
                                                                data_virtual_hard_disks=None,
                                                                role_size=self.config.getBuildInstanceRoleSize())
            self._wait_for_operation_success(result.request_id, timeout=self.config.getAzureOperationTimeout())
            self._wait_for_role_instance_status(vm_hostname, service_name, 'ReadyRole',
                                                self.config.getAzureOperationTimeout())
            logger.info("Role instance %s has been created.", vm_hostname)
Ejemplo n.º 11
0
def delete_endpoint_from_network_config(network_config, private_endpoints):
    """
    Return a new network config
    :param network_config:
    :param private_endpoints: a list of int or str
    :return:
    """
    private_endpoints = map(str, private_endpoints)
    new_network_config = ConfigurationSet()
    new_network_config.configuration_set_type = network_config.configuration_set_type
    if network_config.input_endpoints is not None:
        for input_endpoint in network_config.input_endpoints.input_endpoints:
            if input_endpoint.local_port not in private_endpoints:
                new_network_config.input_endpoints.input_endpoints.append(
                    ConfigurationSetInputEndpoint(input_endpoint.name,
                                                  input_endpoint.protocol,
                                                  input_endpoint.port,
                                                  input_endpoint.local_port))
    return new_network_config
Ejemplo n.º 12
0
def delete_endpoint_from_network_config(network_config, private_endpoints):
    """
    Return a new network config
    :param network_config:
    :param private_endpoints: a list of int or str
    :return:
    """
    private_endpoints = map(str, private_endpoints)
    new_network_config = ConfigurationSet()
    new_network_config.configuration_set_type = network_config.configuration_set_type
    if network_config.input_endpoints is not None:
        for input_endpoint in network_config.input_endpoints.input_endpoints:
            if input_endpoint.local_port not in private_endpoints:
                new_network_config.input_endpoints.input_endpoints.append(
                    ConfigurationSetInputEndpoint(
                        input_endpoint.name, input_endpoint.protocol, input_endpoint.port, input_endpoint.local_port
                    )
                )
    return new_network_config
Ejemplo n.º 13
0
    def __set_endpoint_config(self, service_name, hackathon_id):
        """
        Set endpoint configuration which is need in creating Azure VM

        :param service_name: the name of cloud service
        :type service_name: str|unicode

        :param hackathon_id: the id of hackathon
        :type hackathon_id: integer

        :return: the endpoint configuration set
        :rtype: class 'azure.servicemanagement.ConfigurationSet'
        """
        used_port_set = self.__get_used_public_port_set(
            service_name, hackathon_id)
        docker_port = 4243
        ssh_port = 9000
        while docker_port in used_port_set:
            docker_port += 1
        while ssh_port in used_port_set:
            ssh_port += 1
        assert docker_port < 40000 and ssh_port < 40000
        endpoint_config = ConfigurationSet()
        endpoint_config.configuration_set_type = AzureVMEnpointConfigType.NETWORK
        endpoint1 = ConfigurationSetInputEndpoint(
            name=AzureVMEndpointName.DOCKER,
            protocol=TCPProtocol.TCP,
            port=str(docker_port),
            local_port=str(AzureVMEndpointDefaultPort.DOCKER),
            load_balanced_endpoint_set_name=None,
            enable_direct_server_return=False)
        endpoint2 = ConfigurationSetInputEndpoint(
            name=AzureVMEndpointName.SSH,
            protocol=TCPProtocol.TCP,
            port=str(ssh_port),
            local_port=str(AzureVMEndpointDefaultPort.SSH),
            load_balanced_endpoint_set_name=None,
            enable_direct_server_return=False)
        endpoint_config.input_endpoints.input_endpoints.append(endpoint1)
        endpoint_config.input_endpoints.input_endpoints.append(endpoint2)
        return endpoint_config
Ejemplo n.º 14
0
 def test_get_virtual_machine_network_config(self):
     cs_name = 'grtit3'
     dm_name = 'fdjhfr'
     vm_name = 'grt65g'
     self.service.get_virtual_machine = Mock()
     self.service.get_virtual_machine.return_value = None
     self.assertIsNone(self.service.get_virtual_machine_network_config(cs_name, dm_name, vm_name))
     c = ConfigurationSet()
     p = PersistentVMRole()
     p.configuration_sets.configuration_sets = [c]
     self.service.get_virtual_machine.return_value = p
     self.assertEqual(self.service.get_virtual_machine_network_config(cs_name, dm_name, vm_name), c)
Ejemplo n.º 15
0
 def test_get_assigned_endpoints(self):
     cs_name = 'dsfsd'
     self.service.get_hosted_service_properties = Mock()
     i = ConfigurationSetInputEndpoint('http', 'tcp', '80', '80')
     c = ConfigurationSet()
     c.input_endpoints.input_endpoints = [i]
     r = Role()
     r.configuration_sets.configuration_sets = [c]
     d = Deployment()
     d.role_list.roles = [r]
     h = HostedService()
     h.deployments.deployments = [d]
     self.service.get_hosted_service_properties.return_value = h
     self.assertEqual(len(self.service.get_assigned_endpoints(cs_name)), 1)
Ejemplo n.º 16
0
    def __set_endpoint_config(self, service_name, hackathon_id):
        """
        Set endpoint configuration which is need in creating Azure VM

        :param service_name: the name of cloud service
        :type service_name: str|unicode

        :param hackathon_id: the id of hackathon
        :type hackathon_id: integer

        :return: the endpoint configuration set
        :rtype: class 'azure.servicemanagement.ConfigurationSet'
        """
        used_port_set = self.__get_used_public_port_set(service_name, hackathon_id)
        docker_port = 4243
        ssh_port = 9000
        while docker_port in used_port_set:
            docker_port += 1
        while ssh_port in used_port_set:
            ssh_port += 1
        assert docker_port < 40000 and ssh_port < 40000
        endpoint_config = ConfigurationSet()
        endpoint_config.configuration_set_type = AzureVMEnpointConfigType.NETWORK
        endpoint1 = ConfigurationSetInputEndpoint(name=AzureVMEndpointName.DOCKER, protocol=TCPProtocol.TCP,
                                                  port=str(docker_port),
                                                  local_port=str(AzureVMEndpointDefaultPort.DOCKER),
                                                  load_balanced_endpoint_set_name=None,
                                                  enable_direct_server_return=False)
        endpoint2 = ConfigurationSetInputEndpoint(name=AzureVMEndpointName.SSH, protocol=TCPProtocol.TCP,
                                                  port=str(ssh_port),
                                                  local_port=str(AzureVMEndpointDefaultPort.SSH),
                                                  load_balanced_endpoint_set_name=None,
                                                  enable_direct_server_return=False)
        endpoint_config.input_endpoints.input_endpoints.append(endpoint1)
        endpoint_config.input_endpoints.input_endpoints.append(endpoint2)
        return endpoint_config
Ejemplo n.º 17
0
    def _ensureVirtualMachinesExist(self):
        """
        Creates the VMs for the web site.
        """
        service_name = self.config.getServiceName()
        cert_thumbprint = self.config.getServiceCertificateThumbprint()
        vm_username = self.config.getVirtualMachineLogonUsername()
        vm_password = self.config.getVirtualMachineLogonPassword()
        vm_role_size = self.config.getServiceInstanceRoleSize()
        vm_numbers = self.config.getServiceInstanceCount()
        if vm_numbers < 1:
            raise Exception(
                "Detected an invalid number of instances: {0}.".format(
                    vm_numbers))

        self._assertOsImageExists(self.config.getServiceOSImageName())

        role_instances = self._getRoleInstances(service_name)
        for vm_number in range(1, vm_numbers + 1):
            vm_hostname = '{0}-{1}'.format(service_name, vm_number)
            if vm_hostname in role_instances:
                logger.warn(
                    "Role instance %s already exists: skipping creation.",
                    vm_hostname)
                continue

            logger.info("Role instance %s provisioning begins.", vm_hostname)
            vm_diskname = '{0}.vhd'.format(vm_hostname)
            vm_disk_media_link = 'http://{0}.blob.core.windows.net/vhds/{1}'.format(
                self.config.getServiceStorageAccountName(), vm_diskname)
            ssh_port = str(self.config.getServiceInstanceSshPort() + vm_number)

            os_hd = OSVirtualHardDisk(self.config.getServiceOSImageName(),
                                      vm_disk_media_link,
                                      disk_name=vm_diskname,
                                      disk_label=vm_diskname)
            linux_config = LinuxConfigurationSet(vm_hostname, vm_username,
                                                 vm_password, True)
            linux_config.ssh.public_keys.public_keys.append(
                PublicKey(
                    cert_thumbprint,
                    u'/home/{0}/.ssh/authorized_keys'.format(vm_username)))
            linux_config.ssh.key_pairs.key_pairs.append(
                KeyPair(cert_thumbprint,
                        u'/home/{0}/.ssh/id_rsa'.format(vm_username)))
            network_config = ConfigurationSet()
            network_config.configuration_set_type = 'NetworkConfiguration'
            ssh_endpoint = ConfigurationSetInputEndpoint(name='SSH',
                                                         protocol='TCP',
                                                         port=ssh_port,
                                                         local_port=u'22')
            network_config.input_endpoints.input_endpoints.append(ssh_endpoint)
            http_endpoint = ConfigurationSetInputEndpoint(
                name='HTTP',
                protocol='TCP',
                port=u'80',
                local_port=u'80',
                load_balanced_endpoint_set_name=service_name)
            http_endpoint.load_balancer_probe.port = '80'
            http_endpoint.load_balancer_probe.protocol = 'TCP'
            network_config.input_endpoints.input_endpoints.append(
                http_endpoint)

            if vm_number == 1:
                result = self.sms.create_virtual_machine_deployment(
                    service_name=service_name,
                    deployment_name=service_name,
                    deployment_slot='Production',
                    label=vm_hostname,
                    role_name=vm_hostname,
                    system_config=linux_config,
                    os_virtual_hard_disk=os_hd,
                    network_config=network_config,
                    availability_set_name=service_name,
                    data_virtual_hard_disks=None,
                    role_size=vm_role_size)
                self._wait_for_operation_success(
                    result.request_id,
                    timeout=self.config.getAzureOperationTimeout())
                self._wait_for_role_instance_status(
                    vm_hostname, service_name, 'ReadyRole',
                    self.config.getAzureOperationTimeout())
            else:
                result = self.sms.add_role(service_name=service_name,
                                           deployment_name=service_name,
                                           role_name=vm_hostname,
                                           system_config=linux_config,
                                           os_virtual_hard_disk=os_hd,
                                           network_config=network_config,
                                           availability_set_name=service_name,
                                           role_size=vm_role_size)
                self._wait_for_operation_success(
                    result.request_id,
                    timeout=self.config.getAzureOperationTimeout())
                self._wait_for_role_instance_status(
                    vm_hostname, service_name, 'ReadyRole',
                    self.config.getAzureOperationTimeout())

            logger.info("Role instance %s has been created.", vm_hostname)
Ejemplo n.º 18
0
    def create_instance(self, image_id=None, key_name=None, security_groups=None, instancetype_id="ExtraSmall", name=None, zone=None, subnet_id=None, private_ips=None, user_data=None, storage_name=None, username=None, password=None):
        '''
        service_account = None
        '''
        storage_account = None
        service_name = name

        result = self.__SMS.check_hosted_service_name_availability(service_name)
        if result is False:
            msg = "Hosted service with name:{} exists. please use different name".format(name)
            raise Exception(msg)

        azure_storages = self.__SMS.list_storage_accounts()
        if storage_name is None:
            # storage name not provided,pick any storage account as stroage
            # account is an expensive operation
            for azure_storage in azure_storages:
                storage_account = azure_storage
                storage_name = storage_account.service_name
                break
        else:
            for azure_storage in azure_storages:
                if azure_storage.service_name == storage_name:
                    storage_account = azure_storage
                    break
        if storage_account is None:
            if storage_name is None:
                storage_name = service_name

            response = self.__SMS.create_storage_account(storage_name, service_name, service_name, location=self._credentials['region_name'])
            import time
            for i in range(60):
                status = self.__SMS.get_operation_status(response.request_id)
                time.sleep(2)
                if not status == "InProgress":
                    break

        keys = self.__SMS.get_storage_account_keys(storage_name)
        blob_service = BlobService(account_name=storage_name, account_key=keys.storage_service_keys.primary)

        blob_service.create_container(service_name)
        target_blob_name = name + ".vhd"
        os_image_url = "http://{}.blob.core.windows.net/{}/{}".format(storage_name, service_name, target_blob_name)

        azure_images = self.__SMS.list_os_images()
        image = None
        for azure_image in azure_images:
            if azure_image.name == image_id:
                image = azure_image
                break

        os_config = None
        endpoint_config = ConfigurationSet()
        endpoint_config.configuration_set_type = 'NetworkConfiguration'

        if image.os == 'Windows':
            os_config = WindowsConfigurationSet(computer_name=name, admin_username=username, admin_password=password)
            os_config.domain_join = None

            endpoint1 = ConfigurationSetInputEndpoint(name='rdp', protocol='tcp', port='3389', local_port='3389', load_balanced_endpoint_set_name=None, enable_direct_server_return=False)

            endpoint2 = ConfigurationSetInputEndpoint(name='web', protocol='tcp', port='80', local_port='80', load_balanced_endpoint_set_name=None, enable_direct_server_return=False)

            endpoint_config.input_endpoints.input_endpoints.append(endpoint1)
            endpoint_config.input_endpoints.input_endpoints.append(endpoint2)

            from azure.servicemanagement import WinRM
            from azure.servicemanagement import Listener
            endpoint_config.win_rm = WinRM()
            listner = Listener(protocol='http')
            os_config.win_rm.listeners.listeners.append(listner)
        if image.os == 'Linux':
            os_config = LinuxConfigurationSet(host_name=name, user_name=username,
                                              user_password=password,
                                              disable_ssh_password_authentication=False)

            os_config.domain_join = None
            endpoint1 = ConfigurationSetInputEndpoint(name='ssh', protocol='tcp', port='22', local_port='22', load_balanced_endpoint_set_name=None, enable_direct_server_return=False)
            endpoint_config.input_endpoints.input_endpoints.append(endpoint1)

        os_hd = OSVirtualHardDisk(image_id, os_image_url, disk_label=target_blob_name)

        self.__SMS.create_hosted_service(service_name, service_name, location=self._credentials['region_name'])
        # service_account = self.__SMS.get_hosted_service_properties(service_name)

        self.__SMS.create_virtual_machine_deployment(service_name=service_name, deployment_name=service_name, deployment_slot='production', label=service_name, role_name=service_name, system_config=os_config, os_virtual_hard_disk=os_hd, role_size=instancetype_id, network_config=endpoint_config)

        new_service = self.__SMS.get_hosted_service_properties(service_name)
        azure_instance = AzureInstancecls(new_service, credentials=self._credentials)
        return azure_instance
Ejemplo n.º 19
0
linux_config = LinuxConfigurationSet(vm_name, 'rohan', 'qwerty12#', True)

SERVICE_CERT_THUMBPRINT = config_params["vm_cert_thumbprint"]

vm_public_key_path = config_params["vm_pub_key_path"]

pk = PublicKey(SERVICE_CERT_THUMBPRINT, vm_public_key_path)

pair = KeyPair(SERVICE_CERT_THUMBPRINT, vm_public_key_path)

linux_config.ssh = SSH()

linux_config.ssh.key_pairs.key_pairs.append(pair)
linux_config.ssh.public_keys.public_keys.append(pk)

endpoint_config = ConfigurationSet()
endpoint_config.configuration_set_type = 'NetworkConfiguration'

ssh_endpoint = ConfigurationSetInputEndpoint(
    name='ssh',
    protocol='tcp',
    port='22',
    local_port='22',
    load_balanced_endpoint_set_name=None,
    enable_direct_server_return=False)
http_endpoint = ConfigurationSetInputEndpoint(
    name='http',
    protocol='tcp',
    port='80',
    local_port='80',
    load_balanced_endpoint_set_name=None,
Ejemplo n.º 20
0
            else:
                self.sms.create_storage_account(
                    service_name=storage,
                    description=storage + " made from libcloud",
                    label=storage,
                    affinity_group=affinity_group,
                    account_type='Standard_LRS')

        # check configuration from image extra["os"]
        if (image.extra["os"] == u'Linux'):
            vm_conf = LinuxConfigurationSet(
                name,
                vm_user,
                vm_password,
                True)
            network = ConfigurationSet()
            network.configuration_set_type = 'NetworkConfiguration'
            network.input_endpoints.input_endpoints.append(
                ConfigurationSetInputEndpoint('ssh', 'tcp', '22', '22'))
        else:
            vm_conf = WindowsConfigurationSet(
                computer_name=name,
                admin_username=vm_user,
                admin_password=vm_password)
            vm_conf.domain_join = None
            vm_conf.win_rm = None
            network = ConfigurationSet()
            network.configuration_set_type = 'NetworkConfiguration'
            network.input_endpoints.input_endpoints.append(
                ConfigurationSetInputEndpoint('ssh', 'tcp', '3389', '3389'))
Ejemplo n.º 21
0
SERVICE_CERT_THUMBPRINT = config_params["vm_cert_thumbprint"]

vm_public_key_path = config_params["vm_pub_key_path"]

pk = PublicKey(SERVICE_CERT_THUMBPRINT, vm_public_key_path)

pair = KeyPair(SERVICE_CERT_THUMBPRINT, vm_public_key_path)


linux_config.ssh = SSH()

linux_config.ssh.key_pairs.key_pairs.append(pair)
linux_config.ssh.public_keys.public_keys.append(pk)

endpoint_config = ConfigurationSet()
endpoint_config.configuration_set_type = 'NetworkConfiguration'

ssh_endpoint = ConfigurationSetInputEndpoint(name='ssh', protocol='tcp',
                                             port='22', local_port='22',
                                             load_balanced_endpoint_set_name=None,
                                             enable_direct_server_return=False)
http_endpoint = ConfigurationSetInputEndpoint(name='http', protocol='tcp',
                                              port='80', local_port='80',
                                              load_balanced_endpoint_set_name=None,
                                              enable_direct_server_return=False)
endpoint_config.input_endpoints.input_endpoints.append(ssh_endpoint)
endpoint_config.input_endpoints.input_endpoints.append(http_endpoint)

result = sms.create_virtual_machine_deployment(service_name=hosted_service_name,
                                               deployment_name=hosted_service_name,
Ejemplo n.º 22
0
    def _ensureVirtualMachinesExist(self):
        """
        Creates the VMs for the web site.
        """
        service_name = self.config.getServiceName()
        cert_thumbprint = self.config.getServiceCertificateThumbprint()
        vm_username = self.config.getVirtualMachineLogonUsername()
        vm_password = self.config.getVirtualMachineLogonPassword()
        vm_role_size = self.config.getServiceInstanceRoleSize()
        vm_numbers = self.config.getServiceInstanceCount()
        if vm_numbers < 1:
            raise Exception("Detected an invalid number of instances: {0}.".format(vm_numbers))

        self._assertOsImageExists(self.config.getServiceOSImageName())

        role_instances = self._getRoleInstances(service_name)
        for vm_number in range(1, vm_numbers+1):
            vm_hostname = '{0}-{1}'.format(service_name, vm_number)
            if vm_hostname in role_instances:
                logger.warn("Role instance %s already exists: skipping creation.", vm_hostname)
                continue

            logger.info("Role instance %s provisioning begins.", vm_hostname)
            vm_diskname = '{0}.vhd'.format(vm_hostname)
            vm_disk_media_link = 'http://{0}.blob.core.windows.net/vhds/{1}'.format(
                self.config.getServiceStorageAccountName(), vm_diskname
            )
            ssh_port = str(self.config.getServiceInstanceSshPort() + vm_number)

            os_hd = OSVirtualHardDisk(self.config.getServiceOSImageName(),
                                      vm_disk_media_link,
                                      disk_name=vm_diskname,
                                      disk_label=vm_diskname)
            linux_config = LinuxConfigurationSet(vm_hostname, vm_username, vm_password, True)
            linux_config.ssh.public_keys.public_keys.append(
                PublicKey(cert_thumbprint, u'/home/{0}/.ssh/authorized_keys'.format(vm_username))
            )
            linux_config.ssh.key_pairs.key_pairs.append(
                KeyPair(cert_thumbprint, u'/home/{0}/.ssh/id_rsa'.format(vm_username))
            )
            network_config = ConfigurationSet()
            network_config.configuration_set_type = 'NetworkConfiguration'
            ssh_endpoint = ConfigurationSetInputEndpoint(name='SSH',
                                                         protocol='TCP',
                                                         port=ssh_port,
                                                         local_port=u'22')
            network_config.input_endpoints.input_endpoints.append(ssh_endpoint)
            http_endpoint = ConfigurationSetInputEndpoint(name='HTTP',
                                                          protocol='TCP',
                                                          port=u'80',
                                                          local_port=u'80',
                                                          load_balanced_endpoint_set_name=service_name)
            http_endpoint.load_balancer_probe.port = '80'
            http_endpoint.load_balancer_probe.protocol = 'TCP'
            network_config.input_endpoints.input_endpoints.append(http_endpoint)

            if vm_number == 1:
                result = self.sms.create_virtual_machine_deployment(service_name=service_name,
                                                                    deployment_name=service_name,
                                                                    deployment_slot='Production',
                                                                    label=vm_hostname,
                                                                    role_name=vm_hostname,
                                                                    system_config=linux_config,
                                                                    os_virtual_hard_disk=os_hd,
                                                                    network_config=network_config,
                                                                    availability_set_name=service_name,
                                                                    data_virtual_hard_disks=None,
                                                                    role_size=vm_role_size)
                self._wait_for_operation_success(result.request_id,
                                                 timeout=self.config.getAzureOperationTimeout())
                self._wait_for_role_instance_status(vm_hostname, service_name, 'ReadyRole',
                                                    self.config.getAzureOperationTimeout())
            else:
                result = self.sms.add_role(service_name=service_name,
                                           deployment_name=service_name,
                                           role_name=vm_hostname,
                                           system_config=linux_config,
                                           os_virtual_hard_disk=os_hd,
                                           network_config=network_config,
                                           availability_set_name=service_name,
                                           role_size=vm_role_size)
                self._wait_for_operation_success(result.request_id,
                                                 timeout=self.config.getAzureOperationTimeout())
                self._wait_for_role_instance_status(vm_hostname, service_name, 'ReadyRole',
                                                    self.config.getAzureOperationTimeout())

            logger.info("Role instance %s has been created.", vm_hostname)