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()
