def _get_initialization(sysprep, cloud_init):
initialization = None
if cloud_init:
initialization = otypes.Initialization(
nic_configurations=[
otypes.NicConfiguration(
boot_protocol=otypes.BootProtocol(
cloud_init.pop('nic_boot_protocol').lower()
) if cloud_init.get('nic_boot_protocol') else None,
name=cloud_init.pop('nic_name'),
on_boot=cloud_init.pop('nic_on_boot'),
ip=otypes.Ip(
address=cloud_init.pop('nic_ip_address'),
netmask=cloud_init.pop('nic_netmask'),
gateway=cloud_init.pop('nic_gateway'),
) if (
cloud_init.get('nic_gateway') is not None or
cloud_init.get('nic_netmask') is not None or
cloud_init.get('nic_ip_address') is not None
) else None,
)
] if (
cloud_init.get('nic_gateway') is not None or
cloud_init.get('nic_netmask') is not None or
cloud_init.get('nic_ip_address') is not None or
cloud_init.get('nic_boot_protocol') is not None or
cloud_init.get('nic_on_boot') is not None
) else None,
**cloud_init
)
elif sysprep:
initialization = otypes.Initialization(
**sysprep
)
return initialization
def get_initialization(self, vm):
if self._initialization is not None:
return self._initialization
sysprep = vm.get('sysprep')
cloud_init = vm.get('cloud_init')
cloud_init_nics = vm.get('cloud_init_nics') or []
if cloud_init is not None:
cloud_init_nics.append(cloud_init)
if cloud_init or cloud_init_nics:
self._initialization = otypes.Initialization(nic_configurations=[
otypes.NicConfiguration(
boot_protocol=otypes.BootProtocol(
nic.pop('nic_boot_protocol').lower())
if nic.get('nic_boot_protocol') else None,
name=nic.pop('nic_name', None),
on_boot=nic.pop('nic_on_boot', None),
ip=otypes.Ip(
address=nic.pop('nic_ip_address', None),
netmask=nic.pop('nic_netmask', None),
gateway=nic.pop('nic_gateway', None),
) if (nic.get('nic_gateway') is not None
or nic.get('nic_netmask') is not None
or nic.get('nic_ip_address') is not None) else None,
) for nic in cloud_init_nics
if (nic.get('nic_gateway') is not None or nic.get(
'nic_netmask') is not None or nic.get('nic_ip_address')
is not None or nic.get('nic_boot_protocol') is not None
or nic.get('nic_on_boot') is not None)
] if cloud_init_nics else None,
**cloud_init)
elif sysprep:
self._initialization = otypes.Initialization(**sysprep)
return self._initialization
def vm_run(prefix, api):
host_names = [h.name() for h in prefix.virt_env.host_vms()]
vms_service = api.system_service().vms_service()
vm = vms_service.list(search='name=%s' % VM0_NAME)[0]
gw_ip = test_utils.get_management_net(prefix).gw()
vm_params = types.Vm(
placement_policy=types.VmPlacementPolicy(hosts=[
types.Host(name="{}.{}".format(sorted(host_names)[0], DOMAIN_NAME))
], ),
initialization=types.Initialization(user_name=VM_USER_NAME,
root_password=VM_PASSWORD))
vm_params.initialization.host_name = 'VM0'
vm_params.initialization.dns_search = DOMAIN_NAME
vm_params.initialization.domain = DOMAIN_NAME
vm_params.initialization.dns_servers = gw_ip
vm_params.initialization.nic_configurations = [
types.NicConfiguration(
name='eth0',
boot_protocol=types.BootProtocol.STATIC,
on_boot=True,
ip=types.Ip(address=test_utils.get_vm0_ip_address(prefix),
netmask='255.255.255.0',
gateway=gw_ip))
]
vm_service = vms_service.vm_service(vm.id)
vm_service.start(use_cloud_init=True, vm=vm_params)
testlib.assert_true_within_long(
lambda: (vms_service.list(search='name=%s' % VM0_NAME)[0]).status ==
types.VmStatus.UP, )
def _get_initialization(sysprep, cloud_init, cloud_init_nics):
initialization = None
if cloud_init or cloud_init_nics:
initialization = otypes.Initialization(nic_configurations=[
otypes.NicConfiguration(
boot_protocol=otypes.BootProtocol(
nic.pop('nic_boot_protocol').lower())
if nic.get('nic_boot_protocol') else None,
name=nic.pop('nic_name', None),
on_boot=nic.pop('nic_on_boot', None),
ip=otypes.Ip(
address=nic.pop('nic_ip_address', None),
netmask=nic.pop('nic_netmask', None),
gateway=nic.pop('nic_gateway', None),
) if (nic.get('nic_gateway') is not None
or nic.get('nic_netmask') is not None
or nic.get('nic_ip_address') is not None) else None,
) for nic in cloud_init_nics
if (nic.get('nic_gateway') is not None or nic.get('nic_netmask')
is not None or nic.get('nic_ip_address') is not None
or nic.get('nic_boot_protocol') is not None
or nic.get('nic_on_boot') is not None)
] if cloud_init_nics else None,
**cloud_init)
elif sysprep:
initialization = otypes.Initialization(**sysprep)
return initialization
def startVMWithClouldinit(self,
vmname,
fqdn,
address,
netmask,
gateway,
dns_server,
dns_search,
nicname="eth0"):
vms_service = self.connection.system_service().vms_service()
vm = vms_service.list(search='name=%s' % vmname)[0]
vm_service = vms_service.vm_service(vm.id)
vm_service.start(
use_cloud_init=True,
vm=types.Vm(initialization=types.Initialization(
# user_name='root',
# root_password='******',
host_name=fqdn, # 虚拟机的hostname
nic_configurations=[
types.NicConfiguration(
name=nicname, # 默认网卡名为eth0 ，如果多网卡指定名称，目前不支持多网卡配置地址
on_boot=True, # 网卡onboot=yes
boot_protocol=types.BootProtocol.STATIC,
ip=types.Ip(
version=types.IpVersion.V4,
address=address, # 虚拟机的ip地址
netmask=netmask, # 虚拟机的地址掩码
gateway=gateway # 虚拟机的网关
))
],
dns_servers=dns_server, # 虚拟机DNS服务器地址
dns_search=dns_search, # 虚拟机dns 查找域
)))
def bucle2():
try:
vm_service.start(
use_cloud_init=True,
vm=types.Vm(
initialization=types.Initialization(
nic_configurations=[
types.NicConfiguration(
name='eth0',
on_boot=True,
boot_protocol=types.BootProtocol.STATIC,
ip=types.Ip(
version=types.IpVersion.V4,
address=sys.argv[2],
netmask='255.255.255.0',
gateway='10.6.134.50'
)
)
]
)
)
)
except:
time.sleep(100)
bucle2()
def start_vm_cloud_init(self, vm_service, vm, use_cloud_init=True):
vm_service.start(use_cloud_init=use_cloud_init,
vm=types.Vm(initialization=types.Initialization(
nic_configurations=[
types.NicConfiguration(
name='eth0',
on_boot=True,
boot_protocol=types.BootProtocol.STATIC,
ip=types.Ip(version=types.IpVersion.V4,
address=vm.ip.ip,
netmask=vm.ip.netmask,
gateway=vm.ip.gateway))
],
dns_servers='8.8.8.8',
)))
def test_run_vms(prefix):
engine = prefix.virt_env.engine_vm().get_api_v4().system_service()
vm_params = types.Vm(initialization=types.Initialization(
user_name=VM_USER_NAME, root_password=VM_PASSWORD))
vm_params.initialization.host_name = BACKUP_VM_NAME
backup_vm_service = test_utils.get_vm_service(engine, BACKUP_VM_NAME)
backup_vm_service.start(use_cloud_init=True, vm=vm_params)
vm_params.initialization.host_name = VM2_NAME
vm2_service = test_utils.get_vm_service(engine, VM2_NAME)
vm2_service.start(use_cloud_init=True, vm=vm_params)
gw_ip = test_utils.get_management_net(prefix).gw()
vm_params.initialization.host_name = VM0_NAME
vm_params.initialization.dns_search = 'lago.local'
vm_params.initialization.domain = 'lago.local'
vm_params.initialization.dns_servers = gw_ip
vm_params.initialization.nic_configurations = [
types.NicConfiguration(
name='eth0',
boot_protocol=types.BootProtocol.STATIC,
on_boot=True,
ip=types.Ip(address=test_utils.get_vm0_ip_address(prefix),
netmask='255.255.255.0',
gateway=gw_ip))
]
vm0_service = test_utils.get_vm_service(engine, VM0_NAME)
vm0_service.start(use_cloud_init=True, vm=vm_params)
for vm_name in [VM0_NAME, BACKUP_VM_NAME]:
_verify_vm_state(engine, vm_name, types.VmStatus.UP)
assert_vm0_is_alive(prefix)
import ovirtsdk4.types as types
import conexion as conn
import sys
connection = conn.createconnection()
# Find the virtual machine:
vms_service = connection.system_service().vms_service()
vm = vms_service.list(search='name=' + sys.argv[1])[0]
# Find the service that manages the virtual machine:
vm_service = vms_service.vm_service(vm.id)
# Start the virtual machine enabling cloud-init and providing the
# password for the `root` user and the network configuration:
vm_service.start(
use_cloud_init=True,
vm=types.Vm(initialization=types.Initialization(nic_configurations=[
types.NicConfiguration(name='eth0',
on_boot=True,
boot_protocol=types.BootProtocol.STATIC,
ip=types.Ip(version=types.IpVersion.V4,
address=sys.argv[2],
netmask='255.255.255.0',
gateway='10.6.134.50'))
])))
# Close the connection to the server:
connection.close()
def create(self,
name,
virttype='kvm',
profile='',
flavor=None,
plan='kvirt',
cpumodel='Westmere',
cpuflags=[],
numcpus=2,
memory=512,
guestid='guestrhel764',
pool='default',
template=None,
disks=[{
'size': 10
}],
disksize=10,
diskthin=True,
diskinterface='virtio',
nets=['default'],
iso=None,
vnc=False,
cloudinit=True,
reserveip=False,
reservedns=False,
reservehost=False,
start=True,
keys=None,
cmds=[],
ips=None,
netmasks=None,
gateway=None,
nested=True,
dns=None,
domain=None,
tunnel=False,
files=[],
enableroot=True,
alias=[],
overrides={},
tags=None):
"""
:param name:
:param virttype:
:param profile:
:param flavor:
:param plan:
:param cpumodel:
:param cpuflags:
:param numcpus:
:param memory:
:param guestid:
:param pool:
:param template:
:param disks:
:param disksize:
:param diskthin:
:param diskinterface:
:param nets:
:param iso:
:param vnc:
:param cloudinit:
:param reserveip:
:param reservedns:
:param reservehost:
:param start:
:param keys:
:param cmds:
:param ips:
:param netmasks:
:param gateway:
:param nested:
:param dns:
:param domain:
:param tunnel:
:param files:
:param enableroot:
:param alias:
:param overrides:
:param tags:
:return:
"""
clone = not diskthin
templateobject = types.Template(name=template) if template else None
console = types.Console(enabled=True)
try:
vm = self.vms_service.add(types.Vm(
name=name,
cluster=types.Cluster(name=self.cluster),
template=templateobject,
console=console),
clone=clone)
vm_service = self.vms_service.vm_service(vm.id)
except Exception as e:
if self.debug:
print(e)
return {'result': 'failure', 'reason': e}
timeout = 0
while True:
vm = vm_service.get()
if vm.status == types.VmStatus.DOWN:
break
else:
timeout += 5
sleep(5)
common.pprint("Waiting for vm to be ready", color='green')
if timeout > 60:
return {
'result': 'failure',
'reason': 'timeout waiting for vm to be ready'
}
profiles_service = self.conn.system_service().vnic_profiles_service()
netprofiles = {}
for prof in profiles_service.list():
netprofiles[prof.name] = prof.id
if 'default' not in netprofiles and 'ovirtmgmt' in netprofiles:
netprofiles['default'] = netprofiles['ovirtmgmt']
nics_service = self.vms_service.vm_service(vm.id).nics_service()
nic_configurations = []
for index, net in enumerate(nets):
netname = None
netmask = None
mac = None
if isinstance(net, str):
netname = net
elif isinstance(net, dict) and 'name' in net:
netname = net['name']
ip = None
mac = net.get('mac')
netmask = next(
(e for e in [net.get('mask'),
net.get('netmask')] if e is not None), None)
gateway = net.get('gateway')
noconf = net.get('noconf')
if noconf is not None:
continue
if 'ip' in net:
ip = net['ip']
# if 'alias' in net:
# alias = net['alias']
if ips and len(ips) > index and ips[index] is not None:
ip = ips[index]
if ip is not None and netmask is not None and gateway is not None:
nic_configuration = types.NicConfiguration(
name='eth%s' % index,
on_boot=True,
boot_protocol=types.BootProtocol.STATIC,
ip=types.Ip(version=types.IpVersion.V4,
address=ip,
netmask=netmask,
gateway=gateway))
nic_configurations.append(nic_configuration)
if netname is not None and netname in netprofiles:
profile_id = netprofiles[netname]
nics_service.add(
types.Nic(name='eth%s' % index,
mac=mac,
vnic_profile=types.VnicProfile(id=profile_id)))
for index, disk in enumerate(disks):
diskpool = pool
diskthin = True
disksize = '10'
if index == 0 and template is not None:
continue
if isinstance(disk, int):
disksize = disk
elif isinstance(disk, str) and disk.isdigit():
disksize = int(disk)
elif isinstance(disk, dict):
disksize = disk.get('size', disksize)
diskpool = disk.get('pool', pool)
diskthin = disk.get('thin', diskthin)
self.add_disk(name, disksize, pool=diskpool, thin=diskthin)
initialization = None
if cloudinit:
custom_script = ''
if files:
data = common.process_files(files=files, overrides=overrides)
if data != '':
custom_script += "write_files:\n"
custom_script += data
cmds.append('sleep 60')
if template.lower().startswith('centos'):
cmds.append('yum -y install centos-release-ovirt42')
if template.lower().startswith('centos') or template.lower().startswith('fedora')\
or template.lower().startswith('rhel'):
cmds.append('yum -y install ovirt-guest-agent-common')
cmds.append('systemctl enable ovirt-guest-agent')
cmds.append('systemctl start ovirt-guest-agent')
if template.lower().startswith('debian'):
cmds.append(
'echo "deb http://download.opensuse.org/repositories/home:/evilissimo:/deb/Debian_7.0/ ./" '
'>> /etc/apt/sources.list')
cmds.append(
'gpg -v -a --keyserver http://download.opensuse.org/repositories/home:/evilissimo:/deb/'
'Debian_7.0/Release.key --recv-keys D5C7F7C373A1A299')
cmds.append('gpg --export --armor 73A1A299 | apt-key add -')
cmds.append('apt-get update')
cmds.append('apt-get -Y install ovirt-guest-agent')
cmds.append('service ovirt-guest-agent enable')
cmds.append('service ovirt-guest-agent start')
if [x for x in common.ubuntus if x in template.lower()]:
cmds.append(
'echo deb http://download.opensuse.org/repositories/home:/evilissimo:/ubuntu:/16.04/'
'xUbuntu_16.04/ /')
cmds.append(
'wget http://download.opensuse.org/repositories/home:/evilissimo:/ubuntu:/16.04/'
'xUbuntu_16.04//Release.key')
cmds.append('apt-key add - < Release.key')
cmds.append('apt-get update')
cmds.append('apt-get -Y install ovirt-guest-agent')
data = common.process_cmds(cmds=cmds, overrides=overrides)
custom_script += "runcmd:\n"
custom_script += data
custom_script = None if custom_script == '' else custom_script
user_name = common.get_user(template)
root_password = None
dns_servers = '8.8.8.8 1.1.1.1'
key = get_home_ssh_key()
initialization = types.Initialization(
user_name=user_name,
root_password=root_password,
regenerate_ssh_keys=True,
authorized_ssh_keys=key,
host_name=name,
nic_configurations=nic_configurations,
dns_servers=dns_servers,
dns_search=domain,
custom_script=custom_script)
tags_service = self.conn.system_service().tags_service()
existing_tags = [tag.name for tag in tags_service.list()]
if "profile_%s" % profile not in existing_tags:
tags_service.add(types.Tag(name="profile_%s" % profile))
if "plan_%s" % plan not in existing_tags:
tags_service.add(types.Tag(name="plan_%s" % plan))
tags_service = vm_service.tags_service()
tags_service.add(tag=types.Tag(name="profile_%s" % profile))
tags_service.add(tag=types.Tag(name="plan_%s" % plan))
vm_service.start(use_cloud_init=cloudinit,
vm=types.Vm(initialization=initialization))
return {'result': 'success'}
- content: |
Hello, world!
path: /tmp/greeting.txt
permissions: '0644'
"""
# Start the virtual machine enabling cloud-init and providing the
# password for the `root` user and the network configuration:
vm_service.start(
use_cloud_init=True,
vm=types.Vm(initialization=types.Initialization(
user_name='root',
root_password='******',
host_name='myvm.example.com',
nic_configurations=[
types.NicConfiguration(name='eth0',
on_boot=True,
boot_protocol=types.BootProtocol.STATIC,
ip=types.Ip(version=types.IpVersion.V4,
address='192.168.0.100',
netmask='255.255.255.0',
gateway='192.168.0.1'))
],
dns_servers='192.168.0.1 192.168.0.2 192.168.0.3',
dns_search='example.com',
custom_script=my_script,
)))
# Close the connection to the server:
connection.close()
