def update_static_route(self, network=None, next_hop=None, mtu=None, description=None, vnic=None): """Update the Static Route. param network str: vApp/Org vDC Network in CIDR format e.g. 192.169.1.0/24 param next_hop str: IP address of next hop param mtu int: Maximum Transmission Units (MTU) e.g 1500 MTU param description str: static route description param vnic int: interface of gateway """ static_resource = self._get_resource() for static_route in static_resource.staticRoutes.route: if static_route.network == self.resource_id: if network: static_route.network = E.network(network) if next_hop: static_route.nextHop = E.nextHop(next_hop) if mtu: static_route.mtu = E.mtu(mtu) if description: static_route.description = E.description(description) if vnic: static_route.vnic = E.vnic(vnic) break self.client.put_resource(self.href, static_resource, EntityType.DEFAULT_CONTENT_TYPE.value)
def update_nat_rule(self, original_address=None, translated_address=None, description=None, protocol=None, original_port=None, translated_port=None, icmp_type=None, logging_enabled=None, enabled=None, vnic=None): """Update a Nat Rule. param original_address str: original IP address param translated_address str: translated IP address param description str: nat rule description param protocol str: protocol such as tcp/udp/icmp param original_port: port no. such as FTP(21) param translated_port: port no. such as HTTP(80) param icmp_type str: icmp type such as "Echo-request" param logging_enabled bool: enable logging param enable bool: enable nat rule param int vnic: interface of gateway """ nat_rule = self.get_resource() if original_address is not None: nat_rule.originalAddress = E.originalAddress(original_address) if translated_address is not None: nat_rule.translatedAddress = \ E.translatedAddress(translated_address) if description is not None: nat_rule.description = E.description(description) if protocol is not None: nat_rule.protocol = E.protocol(protocol) if original_port is not None: nat_rule.originalPort = E.originalPort(original_port) if translated_port is not None: nat_rule.translatedPort = E.translatedPort(translated_port) if icmp_type is not None: nat_rule.icmpType = E.icmpType(icmp_type) if logging_enabled is not None: nat_rule.loggingEnabled = E.loggingEnabled(logging_enabled) if enabled is not None: nat_rule.enabled = E.enabled(enabled) if vnic is not None: nat_rule.vnic = E.vnic(vnic) return self.client.put_resource( self.href, nat_rule, EntityType.DEFAULT_CONTENT_TYPE.value)
def create_provider_vdc(self, vim_server_name, resource_pool_names, storage_profiles, pvdc_name, is_enabled=None, description=None, highest_hw_vers=None, vxlan_network_pool=None, nsxt_manager_name=None): """Create a Provider Virtual Datacenter. :param str vim_server_name: vim_server_name (VC name). :param list resource_pool_names: list of resource_pool_names. :param list storage_profiles: (list): list of storageProfile namespace. :param str pvdc_name: name of PVDC to be created. :param bool is_enabled: flag, True to enable and False to disable. :param str description: description of pvdc. :param str highest_hw_vers: highest supported hw version number. :param str vxlan_network_pool: name of vxlan_network_pool. :param str nsxt_manager_name: name of nsx-t manager. :return: an object containing vmext:VMWProviderVdc XML element that represents the new provider VDC. :rtype: lxml.objectify.ObjectifiedElement """ vc_record = self.get_vcenter(vim_server_name) vc_href = vc_record.get('href') rp_morefs = self.get_resource_pool_morefs(vim_server_name, vc_href, resource_pool_names) vmw_prov_vdc_params = E_VMEXT.VMWProviderVdcParams(name=pvdc_name) if description is not None: vmw_prov_vdc_params.append(E.Description(description)) resource_pool_refs = E_VMEXT.ResourcePoolRefs() for rp_moref in rp_morefs: vim_object_ref = E_VMEXT.VimObjectRef() vim_object_ref.append(E_VMEXT.VimServerRef(href=vc_href)) vim_object_ref.append(E_VMEXT.MoRef(rp_moref)) vim_object_ref.append(E_VMEXT.VimObjectType('RESOURCE_POOL')) resource_pool_refs.append(vim_object_ref) vmw_prov_vdc_params.append(resource_pool_refs) vmw_prov_vdc_params.append(E_VMEXT.VimServer(href=vc_href)) if vxlan_network_pool is not None: network_pool_rec = self.get_res_by_name(ResourceType.NETWORK_POOL, vxlan_network_pool) vx_href = network_pool_rec.get('href') vmw_prov_vdc_params.append(E_VMEXT.VxlanNetworkPool(href=vx_href)) if nsxt_manager_name is not None: nsxt_manager_rec = self.get_res_by_name(ResourceType.NSXT_MANAGER, nsxt_manager_name) nsxt_href = nsxt_manager_rec.get('href') vmw_prov_vdc_params.append( E_VMEXT.NsxTManagerReference(href=nsxt_href)) if highest_hw_vers is not None: vmw_prov_vdc_params.append( E_VMEXT.HighestSupportedHardwareVersion(highest_hw_vers)) if is_enabled is not None: vmw_prov_vdc_params.append(E_VMEXT.IsEnabled(is_enabled)) for storage_profile in storage_profiles: vmw_prov_vdc_params.append(E_VMEXT.StorageProfile(storage_profile)) random_username_suffix = uuid.uuid4().hex default_user = '******' + random_username_suffix[:8] default_pwd = 'PWD' + random_username_suffix[:8] vmw_prov_vdc_params.append(E_VMEXT.DefaultPassword(default_pwd)) vmw_prov_vdc_params.append(E_VMEXT.DefaultUsername(default_user)) return self.client.post_linked_resource( self.extension.get_resource(), rel=RelationType.ADD, media_type=EntityType.PROVIDER_VDC_PARAMS.value, contents=vmw_prov_vdc_params)
def to_instantiate_vm_template_params(self, spec): source_vapp = VApp(self.client, resource=spec['vapp']) vm_template = source_vapp.get_vm(spec['source_vm_name']) params = E.InstantiateVmTemplateParams( E.SourcedVmTemplateItem( E.Source( href=vm_template.get('href'), id=vm_template.get('id'), type=vm_template.get('type'), name=vm_template.get('name'), )), name=spec['target_vm_name'], powerOn='true' if spec['power_on'] else 'false') vm_general_params = E.VmGeneralParams() vm_instantiation_param = E.VmTemplateInstantiationParams() if spec.get('network'): primary_index = int(vm_template.NetworkConnectionSection. PrimaryNetworkConnectionIndex.text) vm_instantiation_param.append( E.NetworkConnectionSection( E_OVF.Info(), E.NetworkConnection( E.NetworkConnectionIndex(primary_index), E.IsConnected(True), E.IpAddressAllocationMode( spec['ip_allocation_mode'].upper()), network=spec['network']))) needs_customization = 'disk_size' in spec or 'password' in spec or \ 'cust_script' in spec or 'hostname' in spec if needs_customization: guest_customization_param = E.GuestCustomizationSection( E_OVF.Info(), E.Enabled(True), ) if spec.get('password'): guest_customization_param.append(E.AdminPasswordEnabled(True)) guest_customization_param.append(E.AdminPasswordAuto(False)) guest_customization_param.append( E.AdminPassword(spec['password'])) else: if spec.get('password_auto'): guest_customization_param.append( E.AdminPasswordEnabled(True)) guest_customization_param.append(E.AdminPasswordAuto(True)) else: guest_customization_param.append( E.AdminPasswordEnabled(False)) if spec.get('password_reset'): guest_customization_param.append( E.ResetPasswordRequired(spec['password_reset'])) if spec.get('cust_script'): guest_customization_param.append( E.CustomizationScript(spec['cust_script'])) if spec.get('hostname'): guest_customization_param.append( E.ComputerName(spec['hostname'])) vm_instantiation_param.append(guest_customization_param) vm_general_params.append(E.NeedsCustomization(needs_customization)) params.SourcedVmTemplateItem.append(vm_general_params) params.SourcedVmTemplateItem.append(vm_instantiation_param) if spec.get('storage_profile'): sp = spec['storage_profile'] storage_profile = E.StorageProfile( href=sp.get('href'), id=sp.get('href').split('/')[-1], type=sp.get('type'), name=sp.get('name')) params.SourcedVmTemplateItem.append(storage_profile) return params
def update_ipsec_vpn(self, name=None, peer_id=None, peer_ip_address=None, local_id=None, local_ip_address=None, local_subnet=None, peer_subnet=None, shared_secret_encrypted=None, encryption_protocol=None, authentication_mode=None, dh_group=None, description=None, mtu=None, is_enabled=None, enable_pfs=None): """Update IPsec VPN of the gateway. param str name: new name of IPSec VPN param str description: new description of IPSec VPN param str peer_id: new peer id param str peer_ip_address: new peer IP address param str local_id: new local id param str local_ip_address: new local IP address param str local_subnet: new local subnet in CIDR format param str peer_subnet: new peer subnet in CIDR format param str shared_secret_encrypted: new shared secret encrypted param str encryption_protocol: new encryption protocol param str authentication_mode: new authentication mode param str dh_group: new dh group param str mtu: new MTU param bool is_enabled: new enabled status Default : false param bool enable_pfs: new enabled pfs status Default : false :return: Ipsec Vpn object :rtype: lxml.objectify.ObjectifiedElement """ end_points = self.end_point.split('-') local_ip = end_points[0] peer_ip = end_points[1] ipsec_vpn = self.resource vpn_sites = ipsec_vpn.sites for site in vpn_sites.site: if site.localIp == local_ip and site.peerIp == peer_ip: if is_enabled is not None: site.enabled = E.enabled(is_enabled) if name is not None: site.name = E.name(name) if description is not None: site.description = E.description(description) if local_id is not None: site.localId = E.localId(local_id) if local_ip_address is not None: site.localIp = E.localIp(local_ip_address) if peer_id is not None: site.peerId = E.peerId(peer_id) if peer_ip_address is not None: site.peerIp = E.peerIp(peer_ip_address) if encryption_protocol is not None: site.encryptionAlgorithm = \ E.encryptionAlgorithm(encryption_protocol) if mtu is not None: site.mtu = E.mtu(mtu) if enable_pfs is not None: site.enablePfs = E.enablePfs(enable_pfs) if local_subnet is not None: local_subnets = E.localSubnets() if ',' in local_subnet: subnet_list = local_subnet.split(",") for subnet in subnet_list: local_subnets.append(E.subnet(subnet)) else: local_subnets.append(E.subnet(local_subnet)) site.localSubnets = local_subnets if peer_subnet is not None: peer_subnets = E.peerSubnets() if ',' in peer_subnet: subnet_list = peer_subnet.split(",") for subnet in subnet_list: peer_subnets.append(E.subnet(subnet)) else: peer_subnets.append(E.subnet(peer_subnet)) site.peerSubnets = peer_subnets if shared_secret_encrypted is not None: site.psk = E.psk(shared_secret_encrypted) if authentication_mode is not None: site.authenticationMode = \ E.authenticationMode(authentication_mode) if dh_group is not None: site.dhGroup = E.dhGroup(dh_group) break self.client.put_resource(self.href, ipsec_vpn, EntityType.DEFAULT_CONTENT_TYPE.value)
def to_sourced_item(self, spec): """Creates a VM SourcedItem from a VM specification. :param spec: (dict) containing: vapp: (resource): (required) source vApp or vAppTemplate resource source_vm_name: (str): (required) source VM name target_vm_name: (str): (optional) target VM name hostname: (str): (optional) target guest hostname password: (str): (optional) set the administrator password of this machine to this value password_auto: (bool): (optional) autogenerate administrator password password_reset: (bool): (optional) True if the administrator password for this virtual machine must be reset after first use cust_script: (str): (optional) script to run on guest customization network: (str): (optional) Name of the vApp network to connect. If omitted, the VM won't be connected to any network storage_profile: (str): (optional) the name of the storage profile to be used for this VM :return: SourcedItem: (:class:`lxml.objectify.StringElement`): object representing the 'SourcedItem' xml object created from the specification. """ source_vapp = VApp(self.client, resource=spec['vapp']) source_vm_resource = source_vapp.get_vm(spec['source_vm_name']) sourced_item = E.SourcedItem( E.Source( href=source_vm_resource.get('href'), id=source_vm_resource.get('id'), name=source_vm_resource.get('name'), type=source_vm_resource.get('type'))) vm_general_params = E.VmGeneralParams() if 'target_vm_name' in spec: vm_general_params.append(E.Name(spec['target_vm_name'])) vm_instantiation_param = E.InstantiationParams() if 'network' in spec: primary_index = int(source_vm_resource.NetworkConnectionSection. PrimaryNetworkConnectionIndex.text) if 'ip_allocation_mode' in spec: ip_allocation_mode = spec['ip_allocation_mode'] else: ip_allocation_mode = 'DHCP' vm_instantiation_param.append( E.NetworkConnectionSection( E_OVF.Info(), E.NetworkConnection( E.NetworkConnectionIndex(primary_index), E.IsConnected(True), E.IpAddressAllocationMode(ip_allocation_mode.upper()), network=spec['network']))) needs_customization = 'disk_size' in spec or 'password' in spec or \ 'cust_script' in spec or 'hostname' in spec if needs_customization: guest_customization_param = E.GuestCustomizationSection( E_OVF.Info(), E.Enabled(True), ) if 'password' in spec: guest_customization_param.append(E.AdminPasswordEnabled(True)) guest_customization_param.append(E.AdminPasswordAuto(False)) guest_customization_param.append( E.AdminPassword(spec['password'])) else: if 'password_auto' in spec: guest_customization_param.append( E.AdminPasswordEnabled(True)) guest_customization_param.append(E.AdminPasswordAuto(True)) else: guest_customization_param.append( E.AdminPasswordEnabled(False)) if 'password_reset' in spec: guest_customization_param.append( E.ResetPasswordRequired(spec['password_reset'])) if 'cust_script' in spec: guest_customization_param.append( E.CustomizationScript(spec['cust_script'])) if 'hostname' in spec: guest_customization_param.append( E.ComputerName(spec['hostname'])) vm_instantiation_param.append(guest_customization_param) vm_general_params.append(E.NeedsCustomization(needs_customization)) sourced_item.append(vm_general_params) sourced_item.append(vm_instantiation_param) if 'storage_profile' in spec: sp = spec['storage_profile'] storage_profile = E.StorageProfile( href=sp.get('href'), id=sp.get('href').split('/')[-1], type=sp.get('type'), name=sp.get('name')) sourced_item.append(storage_profile) return sourced_item
def create_user(self, user_name, password, role_href, full_name='', description='', email='', telephone='', im='', alert_email='', alert_email_prefix='', stored_vm_quota=0, deployed_vm_quota=0, is_group_role=False, is_default_cached=False, is_external=False, is_alert_enabled=False, is_enabled=False): """Create User in the current Org :param user_name: The username of the user :param password: The password of the user :param role_href: The href of the user role :param full_name: The full name of the user :param description: The description for the User :param email: The email of the user :param telephone: The telephone of the user :param im: The im address of the user :param alert_email: The alert email address :param alert_email_prefix: The string to prepend to the alert message subject line :param stored_vm_quota: The quota of vApps that this user can store :param deployed_vm_quota: The quota of vApps that this user can deploy concurrently :param is_group_role: Indicates if the user has a group role :param is_default_cached: Indicates if user should be cached :param is_external: Indicates if user is imported from an external source :param is_alert_enabled: The alert email address :param is_enabled: Enable user :return: (UserType) Created user object """ resource_admin = self.client.get_resource(self.href_admin) user = E.User(E.Description(description), E.FullName(full_name), E.EmailAddress(email), E.Telephone(telephone), E.IsEnabled(is_enabled), E.IM(im), E.IsAlertEnabled(is_alert_enabled), E.AlertEmailPrefix(alert_email_prefix), E.AlertEmail(alert_email), E.IsExternal(is_external), E.IsDefaultCached(is_default_cached), E.IsGroupRole(is_group_role), E.StoredVmQuota(stored_vm_quota), E.DeployedVmQuota(deployed_vm_quota), E.Role(href=role_href), E.Password(password), name=user_name) return self.client.post_linked_resource(resource_admin, RelationType.ADD, EntityType.USER.value, user)
def to_sourced_item(self, spec): """Creates a vm SourcedItem from a vm specification. :param dict spec: a dictionary containing - vapp: (resource): (required) source vApp or vAppTemplate resource. - source_vm_name: (str): (required) source vm name. - target_vm_name: (str): (optional) target vm name. - hostname: (str): (optional) target guest hostname. - password: (str): (optional) the administrator password of the vm. - password_auto: (bool): (optional) auto generate administrator password. - password_reset: (bool): (optional) True, if the administrator password for this vm must be reset after first use. - cust_script: (str): (optional) script to run on guest customization. - network: (str): (optional) name of the vApp network to connect. If omitted, the vm won't be connected to any network. - storage_profile: (str): (optional) the name of the storage profile to be used for this vm. :return: an object containing SourcedItem XML element. :rtype: lxml.objectify.ObjectifiedElement """ source_vapp = VApp(self.client, resource=spec['vapp']) source_vm_resource = source_vapp.get_vm(spec['source_vm_name']) sourced_item = E.SourcedItem( E.Source(href=source_vm_resource.get('href'), id=source_vm_resource.get('id'), name=source_vm_resource.get('name'), type=source_vm_resource.get('type'))) vm_general_params = E.VmGeneralParams() if 'target_vm_name' in spec: vm_general_params.append(E.Name(spec['target_vm_name'])) vm_instantiation_param = E.InstantiationParams() if 'network' in spec: primary_index = int(source_vm_resource.NetworkConnectionSection. PrimaryNetworkConnectionIndex.text) if 'ip_allocation_mode' in spec: ip_allocation_mode = spec['ip_allocation_mode'] else: ip_allocation_mode = 'DHCP' vm_instantiation_param.append( E.NetworkConnectionSection( E_OVF.Info(), E.NetworkConnection( E.NetworkConnectionIndex(primary_index), E.IsConnected(True), E.IpAddressAllocationMode(ip_allocation_mode.upper()), network=spec['network']))) needs_customization = 'disk_size' in spec or 'password' in spec or \ 'cust_script' in spec or 'hostname' in spec if needs_customization: guest_customization_param = E.GuestCustomizationSection( E_OVF.Info(), E.Enabled(True), ) if 'password' in spec: guest_customization_param.append(E.AdminPasswordEnabled(True)) guest_customization_param.append(E.AdminPasswordAuto(False)) guest_customization_param.append( E.AdminPassword(spec['password'])) else: if 'password_auto' in spec: guest_customization_param.append( E.AdminPasswordEnabled(True)) guest_customization_param.append(E.AdminPasswordAuto(True)) else: guest_customization_param.append( E.AdminPasswordEnabled(False)) if 'password_reset' in spec: guest_customization_param.append( E.ResetPasswordRequired(spec['password_reset'])) if 'cust_script' in spec: guest_customization_param.append( E.CustomizationScript(spec['cust_script'])) if 'hostname' in spec: guest_customization_param.append( E.ComputerName(spec['hostname'])) vm_instantiation_param.append(guest_customization_param) vm_general_params.append(E.NeedsCustomization(needs_customization)) sourced_item.append(vm_general_params) sourced_item.append(vm_instantiation_param) if 'storage_profile' in spec: sp = spec['storage_profile'] storage_profile = E.StorageProfile( href=sp.get('href'), id=sp.get('href').split('/')[-1], type=sp.get('type'), name=sp.get('name')) sourced_item.append(storage_profile) return sourced_item
def add_firewall_rule(self, name, is_enabled=False, policy='drop', protocols=['Any'], source_port_range='Any', source_ip='Any', destination_port_range='Any', destination_ip='Any', enable_logging=False): """Add firewall rule on firewall services to vApp network. :param str name: name of firewall rule. :param str policy: policy on firewall rule. :param list protocols: list of protocols on firewall rule. :param str source_port_range: source port range for firewall rule. :param str source_ip: source IP. :param str destination_port_range:destination port range for firewall rule. :param str destination_ip: destination IP. :param str enable_logging: enable logging on firewall rule. :return: an object containing EntityType.TASK XML data which represents the asynchronous task that is updating the vApp network. :rtype: lxml.objectify.ObjectifiedElement :raises: InvalidParameterException: Enable firewall service failed as given network's connection is not routed """ self._get_resource() fence_mode = self.resource.Configuration.FenceMode if fence_mode != 'natRouted': raise InvalidParameterException( "Enable firewall service failed as given network's connection " "is not routed") firewall_service = self.resource.Configuration.Features.FirewallService firewall_rule = E.FirewallRule() firewall_rule.append(E.IsEnabled(is_enabled)) firewall_rule.append(E.Description(name)) firewall_rule.append(E.Policy(policy)) protocol = E.Protocols() for proto in protocols: if proto == 'Any': protocol.append(E.Any(True)) elif proto == 'Icmp': protocol.append(E.Icmp(True)) elif proto == 'Tcp': protocol.append(E.Tcp(True)) elif proto == 'Udp': protocol.append(E.Udp(True)) firewall_rule.append(protocol) firewall_rule.append(E.DestinationPortRange(destination_port_range)) firewall_rule.append(E.DestinationIp(destination_ip)) firewall_rule.append(E.SourcePortRange(source_port_range)) firewall_rule.append(E.SourceIp(source_ip)) firewall_rule.append(E.EnableLogging(enable_logging)) firewall_service.append(firewall_rule) return self.client.put_linked_resource(self.resource, RelationType.EDIT, EntityType.vApp_Network.value, self.resource)
def update(self, status, namespace, operation, operation_name, details, progress, owner_href, owner_name, owner_type, user_href, user_name, org_href=None, task_href=None, error_message=None, stack_trace=''): """Update a task in vCD. :param str status: new status of the task. :param str namespace: identifier of the service that created the task. It must not start with com.vmware.vcloud and the length must be between 1 and 128 symbols. :param str operation: new message describing the operation that is being tracked by this task. :param str operation_name: new short name of the operation that is being tracked by the task. :param details: new detailed message about the task. :param str progress: read-only indicator of task progress as an approximate percentage between 0 and 100. Not available for all tasks. :param str owner_href: href of the owner of the task. This is typically the object that the task is creating or updating. :param str owner_name: name of the owner of the task. :param str owner_type: XML type of the owner object :param str user_href: href of the user who started the task. :param str user_name: name of the user who started the task. :param str org_href: href of the organization, which the user mentioned above belongs to. :param str task_href: href of the task. :param str error_message: represents error information from a failed task. :param str stack_trace: stack trace of the error message from a failed task. :return: an object containing EntityType.TASK XML data representing the updated task. :rtype: lxml.objectify.ObjectifiedElement """ t = E.Task(status=status, serviceNamespace=namespace, type=EntityType.TASK.value, operation=operation, operationName=operation_name, name='task') t.append(E.Owner(href=owner_href, name=owner_name, type=owner_type)) if error_message is not None: t.append( E.Error(stackTrace=stack_trace, majorErrorCode='500', message=error_message, minorErrorCode='INTERNAL_SERVER_ERROR')) t.append( E.User(href=user_href, name=user_name, type=EntityType.USER.value)) if progress is not None: t.append(E.Progress(progress)) t.append(E.Details(details)) if task_href is None: org_resource = self.client.get_resource(org_href) link = find_link(org_resource, RelationType.DOWN, EntityType.TASKS_LIST.value) return self.client.post_resource(link.href, t, EntityType.TASK.value) else: return self.client.put_resource(task_href, t, EntityType.TASK.value)
def _makeStaticRouteServiceAttr(features): route_service = E.StaticRoutingService() route_service.append(E.IsEnabled(True)) features.append(route_service)
def test_0000_setup(self): """Setup the gateway required for the other tests in this module. Create a gateway as per the configuration stated above. This test passes if the gateway is created successfully. """ TestGateway._client = Environment.get_sys_admin_client() TestGateway._vdc = Environment.get_test_vdc(TestGateway._client) TestGateway._org_client = Environment.get_client_in_default_org( CommonRoles.ORGANIZATION_ADMINISTRATOR) TestGateway._config = Environment.get_config() TestGateway._api_version = TestGateway._config['vcd']['api_version'] external_network = Environment.get_test_external_network( TestGateway._client) ext_net_resource = external_network.get_resource() ip_scopes = ext_net_resource.xpath( 'vcloud:Configuration/vcloud:IpScopes/vcloud:IpScope', namespaces=NSMAP) first_ipscope = ip_scopes[0] gateway_ip = first_ipscope.Gateway.text prefix_len = netmask_to_cidr_prefix_len(gateway_ip, first_ipscope.Netmask.text) subnet_addr = gateway_ip + '/' + str(prefix_len) ext_net_to_participated_subnet_with_ip_settings = { ext_net_resource.get('name'): { subnet_addr: self._ip_address_for_config_ip_setting } } ext_net_to_subnet_with_ip_range = { ext_net_resource.get('name'): { subnet_addr: [self._ip_address_for_ip_range] } } ext_net_to_rate_limit = {ext_net_resource.get('name'): {100: 100}} if float(TestGateway._api_version) <= float( ApiVersion.VERSION_30.value): TestGateway._gateway = \ TestGateway._vdc.create_gateway_api_version_30( self._name, [ext_net_resource.get('name')], 'compact', None, True, ext_net_resource.get('name'), gateway_ip, True, False, False, False, True, ext_net_to_participated_subnet_with_ip_settings, True, ext_net_to_subnet_with_ip_range, ext_net_to_rate_limit) elif float(TestGateway._api_version) == float( ApiVersion.VERSION_31.value): TestGateway._gateway = \ TestGateway._vdc.create_gateway_api_version_31( self._name, [ext_net_resource.get('name')], 'compact', None, True, ext_net_resource.get('name'), gateway_ip, True, False, False, False, True, ext_net_to_participated_subnet_with_ip_settings, True, ext_net_to_subnet_with_ip_range, ext_net_to_rate_limit) elif float(TestGateway._api_version) >= float( ApiVersion.VERSION_32.value): TestGateway._gateway = \ TestGateway._vdc.create_gateway_api_version_32( self._name, [ext_net_resource.get('name')], 'compact', None, True, ext_net_resource.get('name'), gateway_ip, True, False, False, False, True, ext_net_to_participated_subnet_with_ip_settings, True, ext_net_to_subnet_with_ip_range, ext_net_to_rate_limit) result = TestGateway._client.get_task_monitor().wait_for_success( task=TestGateway._gateway.Tasks.Task) self.assertEqual(result.get('status'), TaskStatus.SUCCESS.value) TestGateway._extension = Extension(TestGateway._client) TestGateway._extension.get_resource() link = find_link(TestGateway._extension.resource, RelationType.DOWN, EntityType.SYSTEM_SETTINGS.value) settings = TestGateway._client.get_resource(link.href) syslog_server_settings = settings.GeneralSettings.SyslogServerSettings if hasattr(syslog_server_settings, '{' + NSMAP['vcloud'] + '}SyslogServerIp1'): return syslog_server_settings.append( E.SyslogServerIp1(TestGateway._syslog_server_ip1)) TestGateway._client.put_resource(link.href, settings, EntityType.SYSTEM_SETTINGS.value) TestGateway._extension.reload() settings = TestGateway._client.get_resource(link.href) self.assertTrue( hasattr(syslog_server_settings, '{' + NSMAP['vcloud'] + '}SyslogServerIp1'))
def add_external_network(self, network_name, ip_configuration): """Add the given external network to the gateway. :param str network_name: external network name. :param list ip_configuration: list of tuples that contain subnet in CIDR format and allocated ip address. Example [(10.10.10.1/24, Auto), (10.10.20.1/24, 10.10.20.3)] :return: object containing EntityType.TASK XML data representing the asynchronous task. :rtype: lxml.objectify.ObjectifiedElement """ if self.resource is None: self.reload() gateway = self.resource for inf in gateway.Configuration.GatewayInterfaces.GatewayInterface: if inf.Network.get('name') == network_name: raise AlreadyExistsException('External network ' + network_name + 'already added to the gateway.') ext_nw = self._get_external_network(network_name) gw_interface = self._create_gateway_interface(ext_nw, 'uplink') # Add subnet participation ip_scopes = ext_nw.xpath( 'vcloud:Configuration/vcloud:IpScopes/vcloud:IpScope', namespaces=NSMAP) for ip_scope in ip_scopes: subnet_participation_param = E.SubnetParticipation() subnet = None ext_nw_subnet = ip_scope.Gateway.text + '/' + \ str(netmask_to_cidr_prefix_len(ip_scope.Gateway.text, ip_scope.Netmask.text)) for sn in ip_configuration: if len(sn) != 2: raise InvalidParameterException( 'IP Configuration should have both subnet and IP.') if sn[0] == ext_nw_subnet: subnet = sn break if subnet is None: continue ip_assigned = subnet[1].strip() # Configure Ip Settings subnet_participation_param.append(E.Gateway(ip_scope.Gateway.text)) subnet_participation_param.append(E.Netmask(ip_scope.Netmask.text)) if not ip_assigned and ip_assigned.lower() != 'auto': subnet_participation_param.append(E.IpAddress(ip_assigned)) gw_interface.append(subnet_participation_param) gateway.Configuration.GatewayInterfaces.append(gw_interface) return self.client.put_linked_resource( self.resource, RelationType.GATEWAY_UPDATE_PROPERTIES, EntityType.EDGE_GATEWAY.value, gateway)
def add_vm(self): params = self.params source_vapp_resource = self.get_source_resource() target_vm_name = params.get('target_vm_name') hostname = params.get('hostname') source_vm_name = params.get('source_vm_name') target_vapp = params.get('target_vapp') vmpassword = params.get('vmpassword') vmpassword_auto = params.get('vmpassword_auto') vmpassword_reset = params.get('vmpassword_reset') network = params.get('network') power_on = params.get('power_on') ip_allocation_mode = params.get('ip_allocation_mode') cust_script = params.get('cust_script') storage_profile_name = params.get('storage_profile') storage_profile = None all_eulas_accepted = params.get('all_eulas_accepted') response = dict() response['msg'] = dict() response['changed'] = False if storage_profile_name: storage_profile = self.get_storage_profile(storage_profile_name) try: self.vdc.get_vapp(target_vapp) except EntityNotFoundException: spec = { 'source_vm_name': source_vm_name, 'vapp': source_vapp_resource, 'target_vm_name': target_vm_name, 'hostname': hostname, 'password': vmpassword, 'password_auto': vmpassword_auto, 'password_reset': vmpassword_reset, 'ip_allocation_mode': ip_allocation_mode, 'network': network, 'cust_script': cust_script, 'storage_profile': storage_profile, 'power_on': power_on } params = self.to_instantiate_vm_template_params(spec) if all_eulas_accepted is not None: params.append(E.AllEULAsAccepted(all_eulas_accepted)) add_vms_task = self.client.post_linked_resource( self.vdc.resource, RelationType.ADD, 'application/vnd.vmware.vcloud.instantiateVmTemplateParams+xml', params) result = self.execute_task(add_vms_task) result = task_to_dict(result) if isinstance(result.get('details'), StringElement): del result['details'] response['msg'].update(result) response['changed'] = True else: response['warnings'] = "Vapp {} is already present.".format( target_vapp) return response
def update_vm_compute_policy_element(api_version, vm, sizing_policy_href=None, placement_policy_href=None): """Update the compute policy element of a VM. Note: This method only adds the policy elements if supported by the api_version :param api_version float: :param vm lxml.objectify.ObjectifiedElement: Element representing a VM :param sizing_policy_href: href of the sizing policy to be added :param placement_policy_href: href of the placement policy to be added :return: Boolean which indicates if update is required. (VM resource is manipulated in-place) :rtype: bool """ # boolean which indicates if template vm element has been changed update_required = False if api_version < VM_SIZING_POLICY_MIN_API_VERSION and \ not (sizing_policy_href or placement_policy_href): return update_required date_created_node = vm.find( '{http://www.vmware.com/vcloud/v1.5}DateCreated') # noqa: E501 if hasattr(vm, 'ComputePolicy'): compute_policy_element = vm.ComputePolicy else: update_required = True compute_policy_element = E.ComputePolicy() date_created_node.addprevious(compute_policy_element) if placement_policy_href: placement_policy_id = retrieve_compute_policy_id_from_href( placement_policy_href) # noqa: E501 if hasattr(compute_policy_element, 'VmPlacementPolicy'): if compute_policy_element.VmPlacementPolicy.get( 'href', '') != placement_policy_href: # noqa: E501 update_required = True vm_placement_policy_element = compute_policy_element.VmPlacementPolicy # noqa: E501 else: update_required = True vm_placement_policy_element = E.VmPlacementPolicy() # VmPlacementPolicy should always precede VmSizingPolicy compute_policy_element.insert(0, vm_placement_policy_element) compute_policy_element.insert( 1, E.VmPlacementPolicyFinal('false')) # noqa: E501 vm_placement_policy_element.set('href', placement_policy_href) vm_placement_policy_element.set('id', placement_policy_id) vm_placement_policy_element.set('type', 'application/json') if sizing_policy_href: sizing_policy_id = retrieve_compute_policy_id_from_href( sizing_policy_href) # noqa: E501 if hasattr(compute_policy_element, 'VmSizingPolicy'): if compute_policy_element.VmSizingPolicy.get( 'href', '') != sizing_policy_href: # noqa: E501 update_required = True vm_sizing_policy_element = compute_policy_element.VmSizingPolicy # noqa: E501 else: update_required = True vm_sizing_policy_element = E.VmSizingPolicy() compute_policy_element.append(vm_sizing_policy_element) compute_policy_element.append(E.VmSizingPolicyFinal('false')) vm_sizing_policy_element.set('href', sizing_policy_href) vm_sizing_policy_element.set('id', sizing_policy_id) vm_sizing_policy_element.set('type', 'application/json') return update_required
def add_subnet(self, name, gateway_ip, netmask, ip_ranges, primary_dns_ip=None, secondary_dns_ip=None, dns_suffix=None): """Add subnet to an external network. :param str name: Name of external network. :param str gateway_ip: IP address of the gateway of the new network. :param str netmask: Netmask of the gateway. :param list ip_ranges: list of IP ranges used for static pool allocation in the network. For example, [192.168.1.2-192.168.1.49, 192.168.1.100-192.168.1.149]. :param str primary_dns_ip: IP address of primary DNS server. :param str secondary_dns_ip: IP address of secondary DNS Server. :param str dns_suffix: DNS suffix. :rtype: lxml.objectify.ObjectifiedElement """ if self.resource is None: self.reload() platform = Platform(self.client) ext_net = platform.get_external_network(name) config = ext_net['{' + NSMAP['vcloud'] + '}Configuration'] ip_scopes = config.IpScopes ip_scope = E.IpScope() ip_scope.append(E.IsInherited(False)) ip_scope.append(E.Gateway(gateway_ip)) ip_scope.append(E.Netmask(netmask)) if primary_dns_ip is not None: ip_scope.append(E.Dns1(primary_dns_ip)) if secondary_dns_ip is not None: ip_scope.append(E.Dns2(secondary_dns_ip)) if dns_suffix is not None: ip_scope.append(E.DnsSuffix(dns_suffix)) e_ip_ranges = E.IpRanges() for ip_range in ip_ranges: e_ip_range = E.IpRange() ip_range_token = ip_range.split('-') e_ip_range.append(E.StartAddress(ip_range_token[0])) e_ip_range.append(E.EndAddress(ip_range_token[1])) e_ip_ranges.append(e_ip_range) ip_scope.append(e_ip_ranges) ip_scopes.append(ip_scope) return self.client.put_linked_resource( ext_net, rel=RelationType.EDIT, media_type=EntityType.EXTERNAL_NETWORK.value, contents=ext_net)
def connect_vm(self, mode='DHCP', reset_mac_address=False): if self.resource is None: self.resource = self.client.get_resource(self.href) if hasattr(self.resource, 'Children') and \ hasattr(self.resource.Children, 'Vm') and \ len(self.resource.Children.Vm) > 0: network_name = 'none' for nc in self.resource.NetworkConfigSection.NetworkConfig: if nc.get('networkName') != 'none': network_name = nc.get('networkName') break self.resource.Children.Vm[0].NetworkConnectionSection.NetworkConnection.set('network', network_name) # NOQA self.resource.Children.Vm[0].NetworkConnectionSection.NetworkConnection.IsConnected = E.IsConnected('true') # NOQA if reset_mac_address: self.resource.Children.Vm[0].NetworkConnectionSection.NetworkConnection.MACAddress = E.MACAddress('') # NOQA self.resource.Children.Vm[0].NetworkConnectionSection.NetworkConnection.IpAddressAllocationMode = E.IpAddressAllocationMode(mode.upper()) # NOQA return self.client.put_linked_resource( self.resource.Children.Vm[0].NetworkConnectionSection, RelationType.EDIT, EntityType.NETWORK_CONNECTION_SECTION.value, self.resource.Children.Vm[0].NetworkConnectionSection )
def add_vm(self): params = self.params source_vapp_resource = self.get_source_resource() target_vm_name = params.get('target_vm_name') source_vm_name = params.get('source_vm_name') hostname = params.get('hostname') vmpassword = params.get('vmpassword') vmpassword_auto = params.get('vmpassword_auto') vmpassword_reset = params.get('vmpassword_reset') network = params.get('network') all_eulas_accepted = params.get('all_eulas_accepted') power_on = params.get('power_on') ip_allocation_mode = params.get('ip_allocation_mode') cust_script = params.get('cust_script') storage_profile = params.get('storage_profile') properties = params.get('properties') response = dict() response['changed'] = False try: self.get_vm() except EntityNotFoundException: spec = { 'source_vm_name': source_vm_name, 'vapp': source_vapp_resource, 'target_vm_name': target_vm_name, 'hostname': hostname, 'password': vmpassword, 'password_auto': vmpassword_auto, 'password_reset': vmpassword_reset, 'ip_allocation_mode': ip_allocation_mode, 'network': network, 'cust_script': cust_script } if storage_profile != '': spec['storage_profile'] = self.get_storage_profile( storage_profile) spec = {k: v for k, v in spec.items() if v} source_vm = self.vapp.to_sourced_item(spec) # Check the source vm if we need to inject OVF properties. source_vapp = VApp(self.client, resource=source_vapp_resource) vm = source_vapp.get_vm(source_vm_name) productsection = vm.find('ovf:ProductSection', NSMAP) if productsection is not None: for prop in productsection.iterfind('ovf:Property', NSMAP): if properties and prop.get('{' + NSMAP['ovf'] + '}key') in properties: val = prop.find('ovf:Value', NSMAP) if val: prop.remove(val) val = E_OVF.Value() val.set( '{' + NSMAP['ovf'] + '}value', properties[prop.get('{' + NSMAP['ovf'] + '}key')]) prop.append(val) source_vm.InstantiationParams.append(productsection) source_vm.VmGeneralParams.NeedsCustomization = E.NeedsCustomization( 'true') params = E.RecomposeVAppParams( deploy='true', powerOn='true' if power_on else 'false') params.append(source_vm) if all_eulas_accepted is not None: params.append(E.AllEULAsAccepted(all_eulas_accepted)) add_vms_task = self.client.post_linked_resource( self.get_target_resource(), RelationType.RECOMPOSE, EntityType.RECOMPOSE_VAPP_PARAMS.value, params) self.execute_task(add_vms_task) response['msg'] = 'Vapp VM {} has been created.'.format( target_vm_name) response['changed'] = True else: response['warnings'] = 'Vapp VM {} is already present.'.format( target_vm_name) return response
def instantiate_vapp(self, name, catalog, template, network=None, fence_mode='bridged', ip_allocation_mode='dhcp', deploy=True, power_on=True, accept_all_eulas=True, memory=None, cpu=None, password=None, cust_script=None): if self.resource is None: self.resource = self.client.get_resource(self.href) network_href = None if hasattr(self.resource, 'AvailableNetworks') and \ hasattr(self.resource.AvailableNetworks, 'Network'): for n in self.resource.AvailableNetworks.Network: if network is None or network == n.get('name'): network_href = n.get('href') network_name = n.get('name') if network_href is None: raise Exception('Network not found in the Virtual Datacenter.') org_href = find_link(self.resource, RelationType.UP, EntityType.ORG.value).href org = Org(self.client, href=org_href) template_resource = org.get_catalog_item(catalog, template) v = self.client.get_resource(template_resource.Entity.get('href')) n = v.xpath( '//ovf:NetworkSection/ovf:Network', namespaces={'ovf': 'http://schemas.dmtf.org/ovf/envelope/1'}) assert len(n) > 0 network_name_from_template = n[0].get( '{http://schemas.dmtf.org/ovf/envelope/1}name') deploy_param = 'true' if deploy else 'false' power_on_param = 'true' if power_on else 'false' network_configuration = E.Configuration( E.ParentNetwork(href=network_href), E.FenceMode(fence_mode)) # if fence_mode == 'natRouted': # network_configuration.append( # E.Features( # E.NatService( # E.IsEnabled('true'), # E.NatType('ipTranslation'), # E.Policy('allowTraffic'), # E.NatRule( # E.OneToOneVmRule( # E.MappingMode('automatic'), # E.VAppScopedVmId(vm_id), # E.VmNicId(0) # ) # ) # ) # ) # ) vapp_network_name = network_name_from_template if vapp_network_name == 'none': vapp_network_name = network_name vapp_template_params = E.InstantiateVAppTemplateParams( name=name, deploy=deploy_param, powerOn=power_on_param) if network_name is not None: vapp_template_params.append( E.InstantiationParams( E.NetworkConfigSection( E_OVF.Info('Configuration for logical networks'), E.NetworkConfig(network_configuration, networkName=vapp_network_name)))) vapp_template_params.append( E.Source(href=template_resource.Entity.get('href'))) vm = v.xpath('//vcloud:VAppTemplate/vcloud:Children/vcloud:Vm', namespaces=NSMAP) assert len(vm) > 0 ip = E.InstantiationParams() gc = E.GuestCustomizationSection( E_OVF.Info('Specifies Guest OS Customization Settings'), E.Enabled('false'), ) if password is not None: gc.append(E.AdminPasswordEnabled('true')) gc.append(E.AdminPasswordAuto('false')) gc.append(E.AdminPassword(password)) gc.append(E.ResetPasswordRequired('false')) else: gc.append(E.AdminPasswordEnabled('false')) if cust_script is not None: gc.append(E.CustomizationScript(cust_script)) gc.Enabled = E.Enabled('true') gc.append(E.ComputerName(name)) ip.append(gc) primary_index = int( vm[0].NetworkConnectionSection.PrimaryNetworkConnectionIndex.text) ip.append( E.NetworkConnectionSection( E_OVF.Info('Specifies the available VM network connections'), E.NetworkConnection(E.NetworkConnectionIndex(primary_index), E.IsConnected('true'), E.IpAddressAllocationMode( ip_allocation_mode.upper()), network=vapp_network_name))) if memory is not None: items = v.Children[0].Vm.xpath( '//ovf:VirtualHardwareSection/ovf:Item', namespaces={'ovf': 'http://schemas.dmtf.org/ovf/envelope/1'}) for item in items: if item['{http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData}ResourceType'] == 4: # NOQA item[ '{http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData}ElementName'] = '%s MB of memory' % memory # NOQA item[ '{http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData}VirtualQuantity'] = memory # NOQA memory_params = item break if cpu is not None: items = v.Children[0].Vm.xpath( '//ovf:VirtualHardwareSection/ovf:Item', namespaces={'ovf': 'http://schemas.dmtf.org/ovf/envelope/1'}) for item in items: if item['{http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData}ResourceType'] == 3: # NOQA item[ '{http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData}ElementName'] = '%s virtual CPU(s)' % cpu # NOQA item[ '{http://schemas.dmtf.org/wbem/wscim/1/cim-schema/2/CIM_ResourceAllocationSettingData}VirtualQuantity'] = cpu # NOQA cpu_params = item break if memory is not None or cpu is not None: vhs = E_OVF.VirtualHardwareSection( E_OVF.Info('Virtual hardware requirements')) if memory is not None: vhs.append(memory_params) if cpu is not None: vhs.append(cpu_params) ip.append(vhs) if password is None and cust_script is None: needs_customization = 'false' else: needs_customization = 'true' si = E.SourcedItem( E.Source(href=vm[0].get('href'), id=vm[0].get('id'), name=vm[0].get('name'), type=vm[0].get('type')), E.VmGeneralParams(E.Name(name), E.NeedsCustomization(needs_customization)), ip) # if network_name != network_name_from_template: # si.append(E.NetworkAssignment( # innerNetwork=network_name_from_template, # containerNetwork=network_name)) vapp_template_params.append(si) all_eulas_accepted = 'true' if accept_all_eulas else 'false' vapp_template_params.append(E.AllEULAsAccepted(all_eulas_accepted)) return self.client.post_resource( self.href + '/action/instantiateVAppTemplate', vapp_template_params, EntityType.INSTANTIATE_VAPP_TEMPLATE_PARAMS.value)
def upload_ovf(self, catalog_name, file_name, item_name=None, description='', chunk_size=DEFAULT_CHUNK_SIZE, callback=None): catalog = self.get_catalog(catalog_name) if item_name is None: item_name = os.path.basename(file_name) tempdir = tempfile.mkdtemp(dir='.') total_bytes = 0 try: ova = tarfile.open(file_name) ova.extractall(path=tempdir) ova.close() ovf_file = None files = os.listdir(tempdir) for f in files: fn, ex = os.path.splitext(f) if ex == '.ovf': ovf_file = os.path.join(tempdir, f) break if ovf_file is not None: stat_info = os.stat(ovf_file) total_bytes += stat_info.st_size ovf = objectify.parse(ovf_file) files = [] ns = '{' + NSMAP['ovf'] + '}' for f in ovf.getroot().References.File: source_file = { 'href': f.get(ns + 'href'), 'name': f.get(ns + 'id'), 'size': f.get(ns + 'size') } files.append(source_file) if item_name is None: item_name = os.path.basename(file_name) params = E.UploadVAppTemplateParams(name=item_name) params.append(E.Description(description)) catalog_item = self.client.post_resource( catalog.get('href') + '/action/upload', params, EntityType.UPLOAD_VAPP_TEMPLATE_PARAMS.value) entity = self.client.get_resource( catalog_item.Entity.get('href')) file_href = entity.Files.File.Link.get('href') self.client.put_resource(file_href, ovf, 'text/xml') while True: time.sleep(5) entity = self.client.get_resource( catalog_item.Entity.get('href')) if len(entity.Files.File) > 1: break for source_file in files: for target_file in entity.Files.File: if source_file.get('href') == target_file.get('name'): file_path = os.path.join(tempdir, source_file.get('href')) total_bytes += self.upload_file( file_path, target_file.Link.get('href'), chunk_size=chunk_size, callback=callback) shutil.rmtree(tempdir) except Exception as e: print(traceback.format_exc()) shutil.rmtree(tempdir) raise e return total_bytes
def instantiate_vapp(self, name, catalog, template, network=None, fence_mode=FenceMode.BRIDGED.value, ip_allocation_mode='dhcp', deploy=True, power_on=True, accept_all_eulas=False, memory=None, cpu=None, disk_size=None, password=None, cust_script=None, vm_name=None, hostname=None, storage_profile=None): """Instantiate a vApp from a vApp template in a catalog. If customization parameters are provided, it will customize the VM and guest OS, taking some assumptions. See each parameter for details. :param name: (str): The name of the new vApp. :param catalog: (str): The name of the catalog. :param template: (str): The name of the vApp template. :param network: (str): The name of a vdc network. When provided, connects the VM to the network. It assumes one VM in the vApp and one NIC in the VM. :param fence_mode: (str): Fence mode. Possible values are `bridged` and `natRouted` :param ip_allocation_mode: (str): IP allocation mode. Possible values are `pool`, `dhcp` and `static` :param deploy: (bool): :param power_on: (bool): :param accept_all_eulas: (bool): True confirms acceptance of all EULAs in a vApp template. :param memory: (int): :param cpu: (int): :param disk_size: (int): :param password: (str): :param cust_script: (str): :param vm_name: (str): When provided, set the name of the VM. It assumes one VM in the vApp. :param hostname: (str): When provided, set the hostname of the guest OS. It assumes one VM in the vApp. :param storage_profile: (str): :return: A :class:`lxml.objectify.StringElement` object describing the new vApp. """ if self.resource is None: self.resource = self.client.get_resource(self.href) # Get hold of the template org_href = find_link(self.resource, RelationType.UP, EntityType.ORG.value).href org = Org(self.client, href=org_href) catalog_item = org.get_catalog_item(catalog, template) template_resource = self.client.get_resource( catalog_item.Entity.get('href')) # If network is not specified by user then default to # vApp network name specified in the template template_networks = template_resource.xpath( '//ovf:NetworkSection/ovf:Network', namespaces={'ovf': NSMAP['ovf']}) assert len(template_networks) > 0 network_name_from_template = template_networks[0].get('{' + NSMAP['ovf'] + '}name') if ((network is None) and (network_name_from_template != 'none')): network = network_name_from_template # Find the network in vdc referred to by user, using # name of the network network_href = network_name = None if network is not None: if hasattr(self.resource, 'AvailableNetworks') and \ hasattr(self.resource.AvailableNetworks, 'Network'): for n in self.resource.AvailableNetworks.Network: if network == n.get('name'): network_href = n.get('href') network_name = n.get('name') break if network_href is None: raise Exception( 'Network \'%s\' not found in the Virtual Datacenter.' % network) # Configure the network of the vApp vapp_instantiation_param = None if network_name is not None: network_configuration = E.Configuration( E.ParentNetwork(href=network_href), E.FenceMode(fence_mode)) if fence_mode == 'natRouted': # TODO(need to find the vm_id) vm_id = None network_configuration.append( E.Features( E.NatService( E.IsEnabled('true'), E.NatType('ipTranslation'), E.Policy('allowTraffic'), E.NatRule( E.OneToOneVmRule(E.MappingMode('automatic'), E.VAppScopedVmId(vm_id), E.VmNicId(0)))))) vapp_instantiation_param = E.InstantiationParams( E.NetworkConfigSection( E_OVF.Info('Configuration for logical networks'), E.NetworkConfig(network_configuration, networkName=network_name))) # Get all vms in the vapp template vms = template_resource.xpath( '//vcloud:VAppTemplate/vcloud:Children/vcloud:Vm', namespaces=NSMAP) assert len(vms) > 0 vm_instantiation_param = E.InstantiationParams() # Configure network of the first vm if network_name is not None: primary_index = int(vms[0].NetworkConnectionSection. PrimaryNetworkConnectionIndex.text) vm_instantiation_param.append( E.NetworkConnectionSection( E_OVF.Info( 'Specifies the available VM network connections'), E.NetworkConnection( E.NetworkConnectionIndex(primary_index), E.IsConnected('true'), E.IpAddressAllocationMode(ip_allocation_mode.upper()), network=network_name))) # Configure cpu, memory, disk of the first vm cpu_params = memory_params = disk_params = None if memory is not None or cpu is not None or disk_size is not None: virtual_hardware_section = E_OVF.VirtualHardwareSection( E_OVF.Info('Virtual hardware requirements')) items = vms[0].xpath('//ovf:VirtualHardwareSection/ovf:Item', namespaces={'ovf': NSMAP['ovf']}) for item in items: if memory is not None and memory_params is None: if item['{' + NSMAP['rasd'] + '}ResourceType'] == 4: item['{' + NSMAP['rasd'] + '}ElementName'] = '%s MB of memory' % memory item['{' + NSMAP['rasd'] + '}VirtualQuantity'] = memory memory_params = item virtual_hardware_section.append(memory_params) if cpu is not None and cpu_params is None: if item['{' + NSMAP['rasd'] + '}ResourceType'] == 3: item['{' + NSMAP['rasd'] + '}ElementName'] = '%s virtual CPU(s)' % cpu item['{' + NSMAP['rasd'] + '}VirtualQuantity'] = cpu cpu_params = item virtual_hardware_section.append(cpu_params) if disk_size is not None and disk_params is None: if item['{' + NSMAP['rasd'] + '}ResourceType'] == 17: item['{' + NSMAP['rasd'] + '}Parent'] = None item['{' + NSMAP['rasd'] + '}HostResource'].attrib[ '{' + NSMAP['vcloud'] + '}capacity'] = '%s' % disk_size item['{' + NSMAP['rasd'] + '}VirtualQuantity'] = disk_size * 1024 * 1024 disk_params = item virtual_hardware_section.append(disk_params) vm_instantiation_param.append(virtual_hardware_section) # Configure guest customization for the vm if password is not None or cust_script is not None or \ hostname is not None: guest_customization_param = E.GuestCustomizationSection( E_OVF.Info('Specifies Guest OS Customization Settings'), E.Enabled('true'), ) if password is None: guest_customization_param.append( E.AdminPasswordEnabled('false')) else: guest_customization_param.append( E.AdminPasswordEnabled('true')) guest_customization_param.append(E.AdminPasswordAuto('false')) guest_customization_param.append(E.AdminPassword(password)) guest_customization_param.append( E.ResetPasswordRequired('false')) if cust_script is not None: guest_customization_param.append( E.CustomizationScript(cust_script)) if hostname is not None: guest_customization_param.append(E.ComputerName(hostname)) vm_instantiation_param.append(guest_customization_param) # Craft the <SourcedItem> element for the first VM sourced_item = E.SourcedItem( E.Source(href=vms[0].get('href'), id=vms[0].get('id'), name=vms[0].get('name'), type=vms[0].get('type'))) vm_general_params = E.VmGeneralParams() if vm_name is not None: vm_general_params.append(E.Name(vm_name)) # TODO(check if it needs customization if network, cpu or memory...) if disk_size is None and \ password is None and \ cust_script is None and \ hostname is None: needs_customization = 'false' else: needs_customization = 'true' vm_general_params.append(E.NeedsCustomization(needs_customization)) sourced_item.append(vm_general_params) sourced_item.append(vm_instantiation_param) if storage_profile is not None: sp = self.get_storage_profile(storage_profile) vapp_storage_profile = E.StorageProfile( href=sp.get('href'), id=sp.get('href').split('/')[-1], type=sp.get('type'), name=sp.get('name')) sourced_item.append(vapp_storage_profile) # Cook the entire vApp Template instantiation element deploy_param = 'true' if deploy else 'false' power_on_param = 'true' if power_on else 'false' all_eulas_accepted = 'true' if accept_all_eulas else 'false' vapp_template_params = E.InstantiateVAppTemplateParams( name=name, deploy=deploy_param, powerOn=power_on_param) if vapp_instantiation_param is not None: vapp_template_params.append(vapp_instantiation_param) vapp_template_params.append( E.Source(href=catalog_item.Entity.get('href'))) vapp_template_params.append(sourced_item) vapp_template_params.append(E.AllEULAsAccepted(all_eulas_accepted)) # TODO(use post_linked_resource?) return self.client.post_resource( self.href + '/action/instantiateVAppTemplate', vapp_template_params, EntityType.INSTANTIATE_VAPP_TEMPLATE_PARAMS.value)
def create_org_vdc(self, vdc_name, provider_vdc_name, description='', allocation_model='AllocationVApp', cpu_units='MHz', cpu_allocated=0, cpu_limit=0, mem_units='MB', mem_allocated=0, mem_limit=0, nic_quota=0, network_quota=0, vm_quota=0, storage_profiles=[], resource_guaranteed_memory=None, resource_guaranteed_cpu=None, vcpu_in_mhz=None, is_thin_provision=None, network_pool_name=None, uses_fast_provisioning=None, over_commit_allowed=None, vm_discovery_enabled=None, is_enabled=True): """Create Organization VDC in the current Org. :param vdc_name (str): The name of the new org vdc. :param provider_vdc_name (str): The name of an existing provider vdc. :param description (str): The description of the new org vdc. :param allocation_model (str): The allocation model used by this vDC. One of AllocationVApp, AllocationPool or ReservationPool. :param cpu_units (str): The cpu units compute capacity allocated to this vDC. One of MHz or GHz :param cpu_allocated (int): Capacity that is committed to be available. :param cpu_limit (int): Capacity limit relative to the value specified for Allocation. :param mem_units (str): The memory units compute capacity allocated to this vDC. One of MB or GB. :param mem_allocated (int): Memory capacity that is committed to be available. :param mem_limit (int): Memory capacity limit relative to the value specified for Allocation. :param nic_quota (int): Maximum number of virtual NICs allowed in this vDC. Defaults to 0, which specifies an unlimited number. :param network_quota (int): Maximum number of network objects that can be deployed in this vDC. Defaults to 0, which means no networks can be deployed. :param vm_quota (int): The maximum number of VMs that can be created in this vDC. Defaults to 0, which specifies an unlimited number. :param storage_profiles: List of provider vDC storage profiles to add to this vDC. Each item is a dictionary that should include the following elements: name: (string) name of the PVDC storage profile. enabled: (bool) True if the storage profile is enabled for this vDC. units: (string) Units used to define limit. One of MB or GB. limit: (int) Max number of units allocated for this storage profile. default: (bool) True if this is default storage profile for this vDC. :param resource_guaranteed_memory (float): Percentage of allocated CPU resources guaranteed to vApps deployed in this vDC. Value defaults to 1.0 if the element is empty. :param resource_guaranteed_cpu (float): Percentage of allocated memory resources guaranteed to vApps deployed in this vDC. Value defaults to 1.0 if the element is empty. :param vcpu_in_mhz (int): Specifies the clock frequency, in Megahertz, for any virtual CPU that is allocated to a VM. :param is_thin_provision (bool): Boolean to request thin provisioning. :param network_pool_name (str): Reference to a network pool in the Provider vDC. :param uses_fast_provisioning (bool): Boolean to request fast provisioning. :param over_commit_allowed (bool): Set to false to disallow creation of the VDC if the AllocationModel is AllocationPool or ReservationPool and the ComputeCapacity you specified is greater than what the backing Provider VDC can supply. Defaults to true if empty or missing. :param vm_discovery_enabled (bool): True if discovery of vCenter VMs is enabled for resource pools backing this vDC. :param is_enabled (bool): True if this vDC is enabled for use by the organization users. :return: A :class:`lxml.objectify.StringElement` object describing the new VDC. """ if self.resource is None: self.resource = self.client.get_resource(self.href) sys_admin_resource = self.client.get_admin() system = System(self.client, admin_resource=sys_admin_resource) pvdc = system.get_provider_vdc(provider_vdc_name) resource_admin = self.client.get_resource(self.href_admin) params = E.CreateVdcParams(E.Description(description), E.AllocationModel(allocation_model), E.ComputeCapacity( E.Cpu(E.Units(cpu_units), E.Allocated(cpu_allocated), E.Limit(cpu_limit)), E.Memory(E.Units(mem_units), E.Allocated(mem_allocated), E.Limit(mem_limit))), E.NicQuota(nic_quota), E.NetworkQuota(network_quota), E.VmQuota(vm_quota), E.IsEnabled(is_enabled), name=vdc_name) for sp in storage_profiles: pvdc_sp = system.get_provider_vdc_storage_profile(sp['name']) params.append( E.VdcStorageProfile( E.Enabled(sp['enabled']), E.Units(sp['units']), E.Limit(sp['limit']), E.Default(sp['default']), E.ProviderVdcStorageProfile(href=pvdc_sp.get('href')))) if resource_guaranteed_memory is not None: params.append( E.ResourceGuaranteedMemory(resource_guaranteed_memory)) if resource_guaranteed_cpu is not None: params.append(E.ResourceGuaranteedCpu(resource_guaranteed_cpu)) if vcpu_in_mhz is not None: params.append(E.VCpuInMhz(vcpu_in_mhz)) if is_thin_provision is not None: params.append(E.IsThinProvision(is_thin_provision)) if network_pool_name is not None: npr = system.get_network_pool_reference(network_pool_name) href = npr.get('href') params.append( E.NetworkPoolReference(href=href, id=href.split('/')[-1], type=npr.get('type'), name=npr.get('name'))) params.append(pvdc) if uses_fast_provisioning is not None: params.append(E.UsesFastProvisioning(uses_fast_provisioning)) if over_commit_allowed is not None: params.append(E.OverCommitAllowed(over_commit_allowed)) if vm_discovery_enabled is not None: params.append(E.VmDiscoveryEnabled(vm_discovery_enabled)) return self.client.post_linked_resource(resource_admin, RelationType.ADD, EntityType.VDCS_PARAMS.value, params)
def create_isolated_vdc_network(self, network_name, gateway_ip, netmask, description=None, primary_dns_ip=None, secondary_dns_ip=None, dns_suffix=None, ip_range_start=None, ip_range_end=None, is_dhcp_enabled=None, default_lease_time=None, max_lease_time=None, dhcp_ip_range_start=None, dhcp_ip_range_end=None, is_shared=None): """Create a new isolated OrgVdc network in this vdc. :param network_name: (str): Name of the new network. :param gateway_ip: (str): IP address of the gateway of the new network. :param netmask: (str): Network mask. :param description: (str): Description of the new network. :param primary_dns_ip: (str): IP address of primary DNS server. :param secondary_dns_ip: (str): IP address of secondary DNS Server. :param dns_suffix: (str): DNS suffix. :param ip_range_start: (str): Start address of the IP ranges used for static pool allocation in the network. :param ip_range_end: (str): End address of the IP ranges used for static pool allocation in the network. :param is_dhcp_enabled: (bool): Is DHCP service enabled on the new network. :param default_lease_time: (int): Default lease in seconds for DHCP addresses. :param max_lease_time: (int): Max lease in seconds for DHCP addresses. :param dhcp_ip_range_start: (str): Start address of the IP range used for DHCP addresses. :param dhcp_ip_range_end: (str): End address of the IP range used for DHCP addresses. :param is_shared: (bool): True, if the network is shared with other vdc(s) in the organization, else False. :return: A :class:`lxml.objectify.StringElement` object representing a sparsely populated OrgVdcNetwork element. """ if self.resource is None: self.resource = self.client.get_resource(self.href) request_payload = E.OrgVdcNetwork(name=network_name) if description is not None: request_payload.append(E.Description(description)) vdc_network_configuration = E.Configuration() ip_scope = E.IpScope() ip_scope.append(E.IsInherited('false')) ip_scope.append(E.Gateway(gateway_ip)) ip_scope.append(E.Netmask(netmask)) if primary_dns_ip is not None: ip_scope.append(E.Dns1(primary_dns_ip)) if secondary_dns_ip is not None: ip_scope.append(E.Dns2(secondary_dns_ip)) if dns_suffix is not None: ip_scope.append(E.DnsSuffix(dns_suffix)) if ip_range_start is not None and ip_range_end is not None: ip_range = E.IpRange() ip_range.append(E.StartAddress(ip_range_start)) ip_range.append(E.EndAddress(ip_range_end)) ip_scope.append(E.IpRanges(ip_range)) vdc_network_configuration.append(E.IpScopes(ip_scope)) vdc_network_configuration.append(E.FenceMode(FenceMode.ISOLATED.value)) request_payload.append(vdc_network_configuration) dhcp_service = E.DhcpService() if is_dhcp_enabled is not None: dhcp_service.append(E.IsEnabled(is_dhcp_enabled)) if default_lease_time is not None: dhcp_service.append(E.DefaultLeaseTime(str(default_lease_time))) if max_lease_time is not None: dhcp_service.append(E.MaxLeaseTime(str(max_lease_time))) if dhcp_ip_range_start is not None and dhcp_ip_range_end is not None: dhcp_ip_range = E.IpRange() dhcp_ip_range.append(E.StartAddress(dhcp_ip_range_start)) dhcp_ip_range.append(E.EndAddress(dhcp_ip_range_end)) dhcp_service.append(dhcp_ip_range) request_payload.append(E.ServiceConfig(dhcp_service)) if is_shared is not None: request_payload.append(E.IsShared(is_shared)) return self.client.post_linked_resource( self.resource, RelationType.ADD, EntityType.ORG_VDC_NETWORK.value, request_payload)
def _makeNatServiceAttr(features): nat_service = E.NatService() nat_service.append(E.IsEnabled(True)) nat_service.append(E.NatType('ipTranslation')) nat_service.append(E.Policy('allowTrafficIn')) features.append(nat_service)
def validate_add_nic(self): ''' Error - More than 10 Nics are not permissible in vCD ''' vm = self.get_vm() vm_name = self.params.get('vm_name') nic_id = self.params.get('nic_id') network = self.params.get('network') ip_address = self.params.get('ip_address') ip_allocation_mode = self.params.get('ip_allocation_mode') adapter_type = self.params.get('adapter_type') uri = vm.resource.get('href') + '/networkConnectionSection' response = defaultdict(dict) response['changed'] = False new_nic_id = None network_section = self.net_connection_section_obj_create() net_conn = self.net_connection_obj_create() nics = self.get_vm_nics() nics_indexes = [ int(nic.NetworkConnectionIndex) for nic in nics.NetworkConnection ] nics_indexes.sort() for nic in nics.NetworkConnection: if nic.NetworkConnectionIndex == nic_id: response[ 'warnings'] = 'Validate add: NIC {} is already present on VM {}'.format( nic_id, vm_name) return response if not adapter_type: nics_adapters = [ int(nic.NetworkAdapterType) for nic in nics.NetworkConnection ] adapter_type = nics_adapters[ 0] # select the first nic NetworkAdapterType if nic_id is None or nic_id < 0: for index, nic_index in enumerate(nics_indexes): new_nic_id = nic_index + 1 if index != nic_index: new_nic_id = index break nic_id = new_nic_id if ip_allocation_mode not in ('DHCP', 'POOL', 'MANUAL'): raise Exception( 'IpAllocationMode should be one of DHCP/POOL/MANUAL') if ip_allocation_mode in ('DHCP', 'POOL'): nic = E.NetworkConnection( E.NetworkConnectionIndex(nic_id), E.IsConnected(True), E.IpAddressAllocationMode(ip_allocation_mode), E.NetworkAdapterType(adapter_type), network=network) else: if not ip_address: raise Exception('IpAddress is missing.') nic = E.NetworkConnection( E.NetworkConnectionIndex(nic_id), E.IpAddress(ip_address), E.IsConnected(True), E.IpAddressAllocationMode(ip_allocation_mode), E.NetworkAdapterType(adapter_type), network=network) nics.NetworkConnection.addnext(nic) add_nic_task = self.client.put_resource( uri, nics, EntityType.NETWORK_CONNECTION_SECTION.value) self.execute_task(add_nic_task) response['msg'] = { 'nic_id': nic_id, 'adapter_type': adapter_type, 'ip_allocation_mode': ip_allocation_mode, 'ip_address': ip_address, 'network': network, 'Validate add: ': 'true' } response['changed'] = True return response
def validate_nic(self): ''' Following update scenarios are covered 1. IP allocation mode change: DHCP, POOL, MANUAL 2. Update IP address in MANUAL mode 3. Network change ''' vm = self.get_vm() nic_id = self.params.get('nic_id') network = self.params.get('network') ip_address = self.params.get('ip_address') adapter_type = self.params.get('adapter_type') is_connected = self.params.get('is_connected') ip_allocation_mode = self.params.get('ip_allocation_mode') uri = vm.resource.get('href') + '/networkConnectionSection' response = defaultdict(dict) response['changed'] = False vm_name = self.params.get('vm_name') nics = self.get_vm_nics() nic_indexes = [] if hasattr(nics, "NetworkConnection"): # If we find attr in nics object for nic in nics.NetworkConnection: nic_indexes.append(nic.NetworkConnectionIndex) self.nic_indexes = nic_indexes return self.nic_indexes else: #if getattr(nics, 'NetworkConnection', None): # Go add nic because no any adapters are present in VM # we find attr in nics object # nic_id = self.params.get('nic_id') # nic = E.NetworkConnection( # E.NetworkConnectionIndex(nic_id), # E.IpAddress(ip_address), # E.IsConnected(True), # E.IpAddressAllocationMode(ip_allocation_mode), # network=network) add_nic_task = vm.add_nic(adapter_type=adapter_type, is_connected=is_connected, network_name=network, ip_address_mode=ip_allocation_mode, ip_address=ip_address, nic_id=nic_id) self.execute_task(add_nic_task) response['msg'] = { 'nic_id': nic_id, 'adapter_type': adapter_type, 'ip_allocation_mode': ip_allocation_mode, 'ip_address': ip_address, 'network': network, 'is_connected': is_connected, 'malinki': "vecerinki" } response['changed'] = True nics = self.vm.list_nics() nic_indexes = [ nic.NetworkConnectionIndex for nic in nics.NetworkConnection ] # for nic in nics.NetworkConnection: # nic_indexes.append(nic.NetworkConnectionIndex) # self.nic_indexes = nic_indexes # return self.nic_indexes return response # # adding_nic = self.execute_task(add_nic_task) # nics.NetworkConnection.addnext(nic_id) # #add_nic_task = self.client.put_resource(uri, nics, EntityType.NETWORK_CONNECTION_SECTION.value) # self.execute_task(add_nic_task) # response['msg'] = { # 'VM': vm_name, # 'A added nic with ID:': nic_id, # 'ip_allocation_mode': ip_allocation_mode, # 'ip_address': ip_address, # 'we_at_here': "we_at_here" # } # response['changed'] = True # return response # # response['msg'] = 'A new nic has been added to VM {0}, NICs list: {1}'.format(vm_name,str(nics)) # # response['changed'] = True # # return self.add_nic() # #else: if nic_id not in nic_indexes: response['changed'] = 'go add NIC, because his not are found.' return self.validate_add_nic() #response['warnings'] = 'NIC not found.' # nic_to_update = nic_indexes.index(nic_id) if network: nics.NetworkConnection[nic_id].set('network', network) response['changed'] = True if ip_allocation_mode: allocation_mode_element = E.IpAddressAllocationMode( ip_allocation_mode) nics.NetworkConnection[ nic_id].IpAddressAllocationMode = allocation_mode_element response['changed'] = True if ip_address: response['changed'] = True if hasattr(nics.NetworkConnection[nic_id], 'IpAddress'): nics.NetworkConnection[nic_id].IpAddress = E.IpAddress( ip_address) else: network = nics.NetworkConnection[nic_id].get('network') nics.NetworkConnection[nic_id] = E.NetworkConnection( E.NetworkConnectionIndex(nic_id), E.IpAddress(ip_address), E.IsConnected(True), E.IpAddressAllocationMode(ip_allocation_mode), network=network) if response['changed']: update_nic_task = self.client.put_resource( uri, nics, EntityType.NETWORK_CONNECTION_SECTION.value) self.execute_task(update_nic_task) response['msg'] = 'vApp VM nic has been updated.' return response
def create_vapp_network(self, name, network_cidr, description=None, primary_dns_ip=None, secondary_dns_ip=None, dns_suffix=None, ip_ranges=None, is_guest_vlan_allowed=False): """Create a vApp network. :param str network_name: name of vApp network to be created. :param str network_cidr: CIDR in the format of 192.168.1.1/24. :param str description: description of vApp network. :param str primary_dns_ip: IP address of primary DNS server. :param str secondary_dns_ip: IP address of secondary DNS Server. :param str dns_suffix: DNS suffix. :params list ip_ranges: list of IP ranges used for static pool allocation in the network. For example, [192.168.1.2-192.168.1.49, 192.168.1.100-192.168.1.149]. :return: an object containing EntityType.TASK XML data which represents the asynchronous task that is creating the vApp network. :rtype: lxml.objectify.ObjectifiedElement """ network_config_section = \ deepcopy(self.resource.NetworkConfigSection) network_config = E.NetworkConfig(networkName=name) if description is not None: network_config.append(E.Description(description)) config = E.Configuration() ip_scopes = E.IpScopes() ip_scope = E.IpScope() ip_scope.append(E.IsInherited(False)) gateway_ip, netmask = cidr_to_netmask(network_cidr) ip_scope.append(E.Gateway(gateway_ip)) ip_scope.append(E.Netmask(netmask)) if primary_dns_ip is not None: ip_scope.append(E.Dns1(primary_dns_ip)) if secondary_dns_ip is not None: ip_scope.append(E.Dns2(secondary_dns_ip)) if dns_suffix is not None: ip_scope.append(E.DnsSuffix(dns_suffix)) e_ip_ranges = E.IpRanges() for ip_range in ip_ranges: e_ip_range = E.IpRange() ip_range_token = ip_range.split('-') e_ip_range.append(E.StartAddress(ip_range_token[0])) e_ip_range.append(E.EndAddress(ip_range_token[1])) e_ip_ranges.append(e_ip_range) ip_scope.append(e_ip_ranges) ip_scopes.append(ip_scope) config.append(ip_scopes) config.append(E.FenceMode(FenceMode.ISOLATED.value)) config.append(E.GuestVlanAllowed(is_guest_vlan_allowed)) network_config.append(config) network_config_section.append(network_config) return self.client.put_linked_resource( self.resource.NetworkConfigSection, RelationType.EDIT, EntityType.NETWORK_CONFIG_SECTION.value, network_config_section)