def vlan_change(kvm_vnic): # Initiate oVirt SDK Connection try: connection = ovirt_connection() connection.authenticate() except: print("Failed to connect to oVirt engine!") exit(1) # Get the reference to the "networks" service try: networks_service = connection.system_service().networks_service() except: print("Unable to establish OLVM network connection") exit(1) for i in range(len(kvm_vnic)): if "kvm" in kvm_vnic[i]['display_name']: try: # Find the first logical network service matching the name of the VM network = networks_service.list( search='name={}'.format(kvm_vnic[i]['display_name']))[0] # Get the service for the logical network network_service = networks_service.network_service(network.id) # Update the VLAN for the logical network network_service.update(network=types.Network( vlan=types.Vlan(id=int(kvm_vnic[i]['vlan_tag'])), ), ) print("Network " + kvm_vnic[i]['display_name'] + " has it's VLAN tag changed to: " + str(kvm_vnic[i]['vlan_tag'])) except: print("Network " + kvm_vnic[i]['display_name'] + " has no entry in KVM!") connection.close()
def create_network(self, name, cidr=None, dhcp=True, nat=True, domain=None, plan='kvirt', pxe=None, vlan=None): """ :param name: :param cidr: :param dhcp: :param nat: :param domain: :param plan: :param pxe: :param vlan: :return: """ if vlan is None: return {'result': 'failure', 'reason': "Missing Vlan"} networks_service = self.conn.system_service().networks_service() networks_service.add( network=types.Network(name=name, data_center=types.DataCenter( name=self.datacenter), vlan=types.Vlan(vlan), usages=[types.NetworkUsage.VM], mtu=1500)) return
def build_entity(self): if self.param('external_provider'): ons_service = self._connection.system_service( ).openstack_network_providers_service() on_service = ons_service.provider_service( get_id_by_name(ons_service, self.param('external_provider'))) return otypes.Network( name=self._module.params['name'], comment=self._module.params['comment'], description=self._module.params['description'], id=self._module.params['id'], data_center=otypes.DataCenter( name=self._module.params['data_center'], ) if self._module.params['data_center'] else None, vlan=otypes.Vlan(self._module.params['vlan_tag'], ) if self._module.params['vlan_tag'] else None, usages=[ otypes.NetworkUsage.VM if self._module.params['vm_network'] else None ] if self._module.params['vm_network'] is not None else None, mtu=self._module.params['mtu'], external_provider=otypes.OpenStackNetworkProvider( id=on_service.get().id) if self.param('external_provider') else None, )
def create(self, name, vlan=None, usages=(NetworkUsage.VM,)): sdk_type = types.Network( name=name, data_center=self._parent_sdk_entity.service.get(), usages=usages, ) if vlan is not None: sdk_type.vlan = types.Vlan(id=vlan) self._create_sdk_entity(sdk_type)
def create( self, name, vlan=None, usages=(NetworkUsage.VM, ), qos=None, auto_generate_profile=True, external_provider=None, external_provider_physical_network=None, mtu=None, port_isolation=None, ): """ :type name: string :type vlan: integer :type usages: (netlib.NetworkUsage,) :type qos: netlib.QoS :type auto_generate_profile: bool :type external_provider: providerlib.OpenStackNetworkProvider :type external_provider_physical_network: netlib.Network :type mtu: integer :type port_isolation: bool """ qos_type = None if qos is None else qos.get_sdk_type() sdk_type = types.Network( name=name, data_center=self._parent_sdk_entity.service.get(), usages=usages, qos=qos_type, profile_required=auto_generate_profile, mtu=mtu, port_isolation=port_isolation, ) if vlan is not None: sdk_type.vlan = types.Vlan(id=vlan) if external_provider is not None: sdk_type.external_provider = types.OpenStackNetworkProvider( id=external_provider.id) if external_provider_physical_network is not None: if external_provider is None: raise ExternalProviderRequired sdk_type.external_provider_physical_network = types.Network( id=external_provider_physical_network.id) self._create_sdk_entity(sdk_type)
def _add_network_to_cluster(api, datacenter_id, ovirt_network_id): cluster_service = test_utils.get_cluster_service( api.system_service(), CLUSTER_NAME) assert cluster_service.networks_service().add( network=types.Network( id=ovirt_network_id, required=False ), )
def update_vm_nic(self, vm_name, network_name, nic_name='nic1', interface=types.NicInterface.VIRTIO): nic = self._get_vm_nic(vm_name, nic_name) nic_service = self._get_vm_nic_service(vm_name, nic_name) nic.network = types.Network(name=network_name) nic.interface = interface nic_service.update(nic)
def test_write_network_with_no_usages(): """ Test given network with usages attribute set to None, the usages isn't written to output xml """ network = types.Network() buf = make_buffer() writer = XmlWriter(buf, indent=True) NetworkWriter.write_one(network, writer) writer.flush() assert_equals(decode_buffer(buf), '<network/>\n')
def add_nic(api): engine = api.system_service() vms = engine.vms_service() vm = vms.list(search=VM_NAME)[0] new_nic = types.Nic( name='eth0', interface=types.NicInterface.VIRTIO, network=types.Network(name=MGMT_NETWORK) ) vms.vm_service(vm.id).nics_service().add(new_nic)
def test_write_network_with_empty_usages(): """ Test given network with usages attribute set empty list, the usages empty element is written to output xml """ network = types.Network(usages=[], ) buf = make_buffer() writer = XmlWriter(buf, indent=True) NetworkWriter.write_one(network, writer) writer.flush() assert_equals(decode_buffer(buf), '<network>\n' + ' <usages/>\n' + '</network>\n')
def test_write_network_with_one_usages(): """ Test given network with usages attribute set list with one value, the usages element with one value is written to output xml """ network = types.Network(usages=[types.NetworkUsage.VM], ) buf = make_buffer() writer = XmlWriter(buf, indent=True) NetworkWriter.write_one(network, writer) writer.flush() assert_equals( decode_buffer(buf), '<network>\n' + ' <usages>\n' + ' <usage>vm</usage>\n' + ' </usages>\n' + '</network>\n')
def build_entity(self): return otypes.Network( id=self._network_id, name=self._module.params['name'], required=self._cluster_network.get('required'), display=self._cluster_network.get('display'), usages=[ otypes.NetworkUsage(usage) for usage in ['display', 'gluster', 'migration'] if self._cluster_network.get(usage, False) ] if (self._cluster_network.get('display') is not None or self._cluster_network.get('gluster') is not None or self._cluster_network.get('migration') is not None) else None, )
def build_entity(self): return otypes.Network( name=self._module.params['name'], comment=self._module.params['comment'], description=self._module.params['description'], data_center=otypes.DataCenter( name=self._module.params['data_center'], ) if self._module.params['data_center'] else None, vlan=otypes.Vlan( self._module.params['vlan_tag'], ) if self._module.params['vlan_tag'] else None, usages=[ otypes.NetworkUsage.VM if self._module.params['vm_network'] else None ] if self._module.params['vm_network'] is not None else None, mtu=self._module.params['mtu'], )
def build_entity(self): return otypes.VnicProfile( name=self.param('name'), network=otypes.Network(id=self._get_network_id()), description=self.param('description') if self.param('description') is not None else None, pass_through=otypes.VnicPassThrough(mode=otypes.VnicPassThroughMode(self.param('pass_through'))) if self.param('pass_through') else None, custom_properties=[ otypes.CustomProperty( name=cp.get('name'), regexp=cp.get('regexp'), value=str(cp.get('value')), ) for cp in self.param('custom_properties') if cp ] if self.param('custom_properties') else None, migratable=self._get_migratable(), qos=self._get_qos(), port_mirroring=self._get_port_mirroring(), network_filter=self._get_network_filter() )
logging.basicConfig(level=logging.DEBUG, filename='example.log') # This example will connect to the server and create new logical network. # Create the connection to the server: connection = sdk.Connection( url='https://engine40.example.com/ovirt-engine/api', username='******', password='******', ca_file='ca.pem', debug=True, log=logging.getLogger(), ) # Get the reference to the networks service: networks_service = connection.system_service().networks_service() # Use the "add" method to create new VM logical network in data center # called "mydc", with VLAN tag 100 and MTU 1500. network = networks_service.add(network=types.Network( name='mynetwork', description='My logical network', data_center=types.DataCenter(name='mydc'), vlan=types.Vlan(id='100'), usages=[types.NetworkUsage.VM], mtu=1500, ), ) # Close the connection to the server: connection.close()
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=['present', 'absent'], default='present', ), name=dict(aliases=['host'], required=True), bond=dict(default=None, type='dict'), interface=dict(default=None), networks=dict(default=None, type='list'), labels=dict(default=None, type='list'), check=dict(default=None, type='bool'), save=dict(default=None, type='bool'), ) module = AnsibleModule(argument_spec=argument_spec) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) hosts_service = connection.system_service().hosts_service() host_networks_module = HostNetworksModule( connection=connection, module=module, service=hosts_service, ) host = host_networks_module.search_entity() if host is None: raise Exception("Host '%s' was not found." % module.params['name']) bond = module.params['bond'] interface = module.params['interface'] networks = module.params['networks'] labels = module.params['labels'] nic_name = bond.get('name') if bond else module.params['interface'] host_service = hosts_service.host_service(host.id) nics_service = host_service.nics_service() nic = search_by_name(nics_service, nic_name) network_names = [network['name'] for network in networks or []] state = module.params['state'] if (state == 'present' and (nic is None or host_networks_module.has_update( nics_service.service(nic.id)))): # Remove networks which are attached to different interface then user want: attachments_service = host_service.network_attachments_service() # Append attachment ID to network if needs update: for a in attachments_service.list(): current_network_name = get_link_name(connection, a.network) if current_network_name in network_names: for n in networks: if n['name'] == current_network_name: n['id'] = a.id # Check if we have to break some bonds: removed_bonds = [] if nic is not None: for host_nic in nics_service.list(): if host_nic.bonding and nic.id in [ slave.id for slave in host_nic.bonding.slaves ]: removed_bonds.append(otypes.HostNic(id=host_nic.id)) # Assign the networks: host_networks_module.action( entity=host, action='setup_networks', post_action=host_networks_module._action_save_configuration, check_connectivity=module.params['check'], removed_bonds=removed_bonds if removed_bonds else None, modified_bonds=[ otypes.HostNic( name=bond.get('name'), bonding=otypes.Bonding( options=get_bond_options(bond.get('mode'), bond.get('options')), slaves=[ otypes.HostNic(name=i) for i in bond.get('interfaces', []) ], ), ), ] if bond else None, modified_labels=[ otypes.NetworkLabel( id=str(name), host_nic=otypes.HostNic( name=bond.get('name') if bond else interface), ) for name in labels ] if labels else None, modified_network_attachments=[ otypes.NetworkAttachment( id=network.get('id'), network=otypes.Network( name=network['name']) if network['name'] else None, host_nic=otypes.HostNic( name=bond.get('name') if bond else interface), ip_address_assignments=[ otypes.IpAddressAssignment( assignment_method=otypes.BootProtocol( network.get('boot_protocol', 'none')), ip=otypes.Ip( address=network.get('address'), gateway=network.get('gateway'), netmask=network.get('netmask'), version=otypes.IpVersion( network.get('version')) if network.get('version') else None, ), ), ], ) for network in networks ] if networks else None, ) elif state == 'absent' and nic: attachments = [] nic_service = nics_service.nic_service(nic.id) attached_labels = set([ str(lbl.id) for lbl in nic_service.network_labels_service().list() ]) if networks: attachments_service = nic_service.network_attachments_service() attachments = attachments_service.list() attachments = [ attachment for attachment in attachments if get_link_name( connection, attachment.network) in network_names ] # Remove unmanaged networks: unmanaged_networks_service = host_service.unmanaged_networks_service( ) unmanaged_networks = [(u.id, u.name) for u in unmanaged_networks_service.list()] for net_id, net_name in unmanaged_networks: if net_name in network_names: if not module.check_mode: unmanaged_networks_service.unmanaged_network_service( net_id).remove() host_networks_module.changed = True # Need to check if there are any labels to be removed, as backend fail # if we try to send remove non existing label, for bond and attachments it's OK: if (labels and set(labels).intersection(attached_labels) ) or bond or attachments: host_networks_module.action( entity=host, action='setup_networks', post_action=host_networks_module. _action_save_configuration, check_connectivity=module.params['check'], removed_bonds=[ otypes.HostNic(name=bond.get('name'), ), ] if bond else None, removed_labels=[ otypes.NetworkLabel(id=str(name)) for name in labels ] if labels else None, removed_network_attachments=attachments if attachments else None, ) nic = search_by_name(nics_service, nic_name) module.exit_json( **{ 'changed': host_networks_module.changed, 'id': nic.id if nic else None, 'host_nic': get_dict_of_struct(nic), }) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
def main(): argument_spec = ovirt_full_argument_spec( state=dict( choices=['present', 'absent'], default='present', ), name=dict(default=None, aliases=['host'], required=True), bond=dict(default=None, type='dict'), interface=dict(default=None), networks=dict(default=None, type='list'), labels=dict(default=None, type='list'), check=dict(default=None, type='bool'), save=dict(default=None, type='bool'), ) module = AnsibleModule(argument_spec=argument_spec) check_sdk(module) try: auth = module.params.pop('auth') connection = create_connection(auth) hosts_service = connection.system_service().hosts_service() host_networks_module = HostNetworksModule( connection=connection, module=module, service=hosts_service, ) host = host_networks_module.search_entity() if host is None: raise Exception("Host '%s' was not found." % module.params['name']) bond = module.params['bond'] interface = module.params['interface'] networks = module.params['networks'] labels = module.params['labels'] nic_name = bond.get('name') if bond else module.params['interface'] nics_service = hosts_service.host_service(host.id).nics_service() nic = search_by_name(nics_service, nic_name) state = module.params['state'] if (state == 'present' and (nic is None or host_networks_module.has_update( nics_service.service(nic.id)))): host_networks_module.action( entity=host, action='setup_networks', post_action=host_networks_module._action_save_configuration, check_connectivity=module.params['check'], modified_bonds=[ otypes.HostNic( name=bond.get('name'), bonding=otypes.Bonding( options=[ otypes.Option( name="mode", value=str(bond.get('mode')), ) ], slaves=[ otypes.HostNic(name=i) for i in bond.get('interfaces', []) ], ), ), ] if bond else None, modified_labels=[ otypes.NetworkLabel( id=str(name), host_nic=otypes.HostNic( name=bond.get('name') if bond else interface), ) for name in labels ] if labels else None, modified_network_attachments=[ otypes.NetworkAttachment( network=otypes.Network( name=network['name']) if network['name'] else None, host_nic=otypes.HostNic( name=bond.get('name') if bond else interface), ip_address_assignments=[ otypes.IpAddressAssignment( assignment_method=otypes.BootProtocol( network.get('boot_protocol', 'none')), ip=otypes.Ip( address=network.get('address'), gateway=network.get('gateway'), netmask=network.get('netmask'), version=otypes.IpVersion( network.get('version')) if network.get('version') else None, ), ), ], ) for network in networks ] if networks else None, ) elif state == 'absent' and nic: attachments_service = nics_service.nic_service( nic.id).network_attachments_service() attachments = attachments_service.list() if networks: network_names = [network['name'] for network in networks] attachments = [ attachment for attachment in attachments if get_link_name( connection, attachment.network) in network_names ] if labels or bond or attachments: host_networks_module.action( entity=host, action='setup_networks', post_action=host_networks_module. _action_save_configuration, check_connectivity=module.params['check'], removed_bonds=[ otypes.HostNic(name=bond.get('name'), ), ] if bond else None, removed_labels=[ otypes.NetworkLabel(name=str(name), ) for name in labels ] if labels else None, removed_network_attachments=list(attachments), ) nic = search_by_name(nics_service, nic_name) module.exit_json( **{ 'changed': host_networks_module.changed, 'id': nic.id if nic else None, 'host_nic': get_dict_of_struct(nic), }) except Exception as e: module.fail_json(msg=str(e), exception=traceback.format_exc()) finally: connection.close(logout=auth.get('token') is None)
), types.Option( name='miimon', value='100', ), ], slaves=[ types.HostNic(name='eth1', ), types.HostNic(name='eth2', ), ], ), ), ], modified_network_attachments=[ types.NetworkAttachment( network=types.Network(name='mynetwork', ), host_nic=types.HostNic(name='bond0', ), ip_address_assignments=[ types.IpAddressAssignment( assignment_method=types.BootProtocol.STATIC, ip=types.Ip( address='192.168.122.100', netmask='255.255.255.0', ), ), ], ), ], ) # After modifying the network configuration it is very important to make it
def add(self, memory, disk_size, cluster_name, storage_name, nic_name='eth0', network_interface='virtio', network_name='ovirtmgmt', disk_interface='virtio', disk_format='raw', template_name='Blank', timeout=300): """ Create VM with one NIC and one Disk. :param memory: VM's memory size such as 1024*1024*1024=1GB. :param disk_size: VM's disk size such as 512*1024=512MB. :param nic_name: VM's NICs name such as 'eth0'. :param network_interface: VM's network interface such as 'virtio'. :param network_name: network such as ovirtmgmt for ovirt, rhevm for rhel. :param disk_format: VM's disk format such as 'raw' or 'cow'. :param disk_interface: VM's disk interface such as 'virtio'. :param cluster_name: cluster name. :param storage_name: storage domain name. :param template_name: VM's template name, default is 'Blank'. :param timeout: Time out """ end_time = time.time() + timeout # network name is ovirtmgmt for ovirt, rhevm for rhel. vm_params = types.VM( name=self.name, memory=memory, cluster=self.connection.clusters.get(cluster_name), template=self.connection.templates.get(template_name)) storage = self.connection.storagedomains.get(storage_name) storage_params = types.StorageDomains(storage_domain=[storage]) nic_params = types.NIC(name=nic_name, network=types.Network(name=network_name), interface=network_interface) disk_params = types.Disk(storage_domains=storage_params, size=disk_size, type_='system', status=None, interface=disk_interface, format=disk_format, sparse=True, bootable=True) try: logging.info('Creating a VM %s' % self.name) self.connection.vms.add(vm_params) logging.info('NIC is added to VM %s' % self.name) self.instance.nics.add(nic_params) logging.info('Disk is added to VM %s' % self.name) self.instance.disks.add(disk_params) logging.info('Waiting for VM to reach <Down> status') vm_down = False while time.time() < end_time: if self.is_dead(): vm_down = True break time.sleep(1) if not vm_down: raise WaitVMStateTimeoutError("DOWN", self.state()) except Exception as e: logging.error('Failed to create VM with disk and NIC\n%s' % str(e))
def build_entity(self): sched_policy = self._get_sched_policy() return otypes.Cluster( id=self.param('id'), name=self.param('name'), comment=self.param('comment'), description=self.param('description'), ballooning_enabled=self.param('ballooning'), gluster_service=self.param('gluster'), virt_service=self.param('virt'), threads_as_cores=self.param('threads_as_cores'), ha_reservation=self.param('ha_reservation'), trusted_service=self.param('trusted_service'), optional_reason=self.param('vm_reason'), maintenance_reason_required=self.param('host_reason'), scheduling_policy=otypes.SchedulingPolicy(id=sched_policy.id, ) if sched_policy else None, serial_number=otypes.SerialNumber( policy=otypes.SerialNumberPolicy(self.param('serial_policy')), value=self.param('serial_policy_value'), ) if (self.param('serial_policy') is not None or self.param('serial_policy_value') is not None) else None, migration=otypes.MigrationOptions( auto_converge=otypes.InheritableBoolean( self.param('migration_auto_converge'), ) if self.param('migration_auto_converge') else None, bandwidth=otypes.MigrationBandwidth( assignment_method=otypes. MigrationBandwidthAssignmentMethod( self.param('migration_bandwidth'), ) if self.param('migration_bandwidth') else None, custom_value=self.param('migration_bandwidth_limit'), ) if (self.param('migration_bandwidth') or self.param('migration_bandwidth_limit')) else None, compressed=otypes.InheritableBoolean( self.param('migration_compressed'), ) if self.param('migration_compressed') else None, policy=otypes.MigrationPolicy(id=self._get_policy_id()) if self.param('migration_policy') else None, ) if (self.param('migration_bandwidth') is not None or self.param('migration_bandwidth_limit') is not None or self.param('migration_auto_converge') is not None or self.param('migration_compressed') is not None or self.param('migration_policy') is not None) else None, error_handling=otypes.ErrorHandling(on_error=otypes.MigrateOnError( self.param('resilience_policy')), ) if self.param('resilience_policy') else None, fencing_policy=otypes.FencingPolicy( enabled=self.param('fence_enabled'), skip_if_gluster_bricks_up=self.param( 'fence_skip_if_gluster_bricks_up'), skip_if_gluster_quorum_not_met=self.param( 'fence_skip_if_gluster_quorum_not_met'), skip_if_connectivity_broken=otypes.SkipIfConnectivityBroken( enabled=self.param('fence_skip_if_connectivity_broken'), threshold=self.param('fence_connectivity_threshold'), ) if (self.param('fence_skip_if_connectivity_broken') is not None or self.param('fence_connectivity_threshold') is not None) else None, skip_if_sd_active=otypes.SkipIfSdActive( enabled=self.param('fence_skip_if_sd_active'), ) if self.param('fence_skip_if_sd_active') is not None else None, ) if (self.param('fence_enabled') is not None or self.param('fence_skip_if_sd_active') is not None or self.param('fence_skip_if_connectivity_broken') is not None or self.param('fence_skip_if_gluster_bricks_up') is not None or self.param('fence_skip_if_gluster_quorum_not_met') is not None or self.param('fence_connectivity_threshold') is not None) else None, display=otypes.Display(proxy=self.param('spice_proxy'), ) if self.param('spice_proxy') else None, required_rng_sources=[ otypes.RngSource(rng) for rng in self.param('rng_sources') ] if self.param('rng_sources') else None, memory_policy=otypes.MemoryPolicy( over_commit=otypes.MemoryOverCommit( percent=self._get_memory_policy(), ), ) if self.param('memory_policy') else None, ksm=otypes.Ksm( enabled=self.param('ksm'), merge_across_nodes=not self.param('ksm_numa'), ) if (self.param('ksm_numa') is not None or self.param('ksm') is not None) else None, data_center=otypes.DataCenter(name=self.param('data_center'), ) if self.param('data_center') else None, management_network=otypes.Network(name=self.param('network'), ) if self.param('network') else None, cpu=otypes.Cpu( architecture=otypes.Architecture(self.param('cpu_arch')) if self.param('cpu_arch') else None, type=self.param('cpu_type'), ) if (self.param('cpu_arch') or self.param('cpu_type')) else None, version=otypes.Version( major=self.__get_major(self.param('compatibility_version')), minor=self.__get_minor(self.param('compatibility_version')), ) if self.param('compatibility_version') else None, switch_type=otypes.SwitchType(self.param('switch_type')) if self.param('switch_type') else None, mac_pool=otypes.MacPool(id=get_id_by_name( self._connection.system_service().mac_pools_service(), self.param('mac_pool'))) if self.param('mac_pool') else None, external_network_providers=self. _get_external_network_providers_entity(), custom_scheduling_policy_properties=[ otypes.Property( name=sp.get('name'), value=str(sp.get('value')), ) for sp in self.param('scheduling_policy_properties') if sp ] if self.param('scheduling_policy_properties') is not None else None, firewall_type=otypes.FirewallType(self.param('firewall_type')) if self.param('firewall_type') else None, gluster_tuned_profile=self.param('gluster_tuned_profile'), )
password='******', ca_file='ca.pem', debug=True, log=logging.getLogger(), ) # Locate the networks service and use it to find the network: networks_service = connection.system_service().networks_service() network = networks_service.list( search='name=mynetwork and datacenter=mydc' )[0] # Locate the clusters service and use it to find the cluster: clusters_service = connection.system_service().clusters_service() cluster = clusters_service.list(search='name=mycluster')[0] # Locate the service that manages the networks of the cluster: cluster_service = clusters_service.cluster_service(cluster.id) cluster_networks_service = cluster_service.networks_service() # Use the "add" method to assign network to cluster: cluster_networks_service.add( network=types.Network( id=network.id, required=True, ), ) # Close the connection to the server: connection.close()