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