def test_object_not_found_exceptions(self):
with self.assertRaises(DevopsObjNotFound):
Environment.get(name='other-env')
with self.assertRaises(DevopsObjNotFound):
self.env.get_group(name='other-rack')
with self.assertRaises(DevopsObjNotFound):
self.env.get_address_pool(name='other-pool')
with self.assertRaises(DevopsObjNotFound):
self.env.get_node(name='other-node')
group = self.env.get_group(name='rack-01')
with self.assertRaises(DevopsObjNotFound):
group.get_l2_network_device(name='other-device')
with self.assertRaises(DevopsObjNotFound):
group.get_network_pool(name='other-pool')
with self.assertRaises(DevopsObjNotFound):
group.get_node(name='other-node')
with self.assertRaises(DevopsObjNotFound):
Group.get(name='other-group')
node = self.env.get_node(name='slave-01')
with self.assertRaises(DevopsObjNotFound):
node.get_volume(name='other-volume')
def d_env(self):
if self._virtual_environment is None:
try:
return Environment.get(name=settings.ENV_NAME)
except Exception:
self._virtual_environment = Environment.describe_environment(
boot_from=settings.ADMIN_BOOT_DEVICE)
self._virtual_environment.define()
return self._virtual_environment
def d_env(self):
if self._virtual_environment is None:
try:
return Environment.get(name=settings.ENV_NAME)
except Exception:
self._virtual_environment = Environment.describe_environment(
boot_from=settings.ADMIN_BOOT_DEVICE)
self._virtual_environment.define()
return self._virtual_environment
def _create_env_from_config(self, config):
env_name = config['template']['devops_settings']['env_name']
for env in Environment.list_all():
if env.name == env_name:
print("Please, set another environment name")
raise SystemExit()
self.env = Environment.create_environment(config)
self.env.define()
# Start all l2 network devices
for group in self.env.get_groups():
for net in group.get_l2_network_devices():
net.start()
def _create_env_from_config(self, config):
env_name = config['template']['devops_settings']['env_name']
for env in Environment.list_all():
if env.name == env_name:
print("Please, set another environment name")
raise SystemExit()
self.env = Environment.create_environment(config)
self.env.define()
# Start all l2 network devices
for group in self.env.get_groups():
for net in group.get_l2_network_devices():
net.start()
def test_network_pool(self):
environment = Environment.create('test_env2')
self.assertEqual('10.0.0.0/24', str(Network.network_create(
environment=environment, name='internal', pool=None).ip_network))
self.assertEqual('10.0.1.0/24', str(Network.network_create(
environment=environment, name='external', pool=None).ip_network))
self.assertEqual('10.0.2.0/24', str(Network.network_create(
environment=environment, name='private', pool=None).ip_network))
environment = Environment.create('test_env2')
self.assertEqual('10.0.3.0/24', str(Network.network_create(
environment=environment, name='internal', pool=None).ip_network))
self.assertEqual('10.0.4.0/24', str(Network.network_create(
environment=environment, name='external', pool=None).ip_network))
self.assertEqual('10.0.5.0/24', str(Network.network_create(
environment=environment, name='private', pool=None).ip_network))
def d_env(self):
if self._virt_env is None:
if not self._config:
try:
return Environment.get(name=settings.ENV_NAME)
except Exception:
self._virt_env = Environment.describe_environment(boot_from=settings.ADMIN_BOOT_DEVICE)
self._virt_env.define()
else:
try:
return Environment.get(name=self._config["template"]["devops_settings"]["env_name"])
except Exception:
self._virt_env = Environment.create_environment(full_config=self._config)
self._virt_env.define()
return self._virt_env
def test_network_pool(self):
environment = Environment.create('test_env2')
self.assertEqual('10.0.0.0/24', str(Network.network_create(
environment=environment, name='internal', pool=None).ip_network))
self.assertEqual('10.0.1.0/24', str(Network.network_create(
environment=environment, name='external', pool=None).ip_network))
self.assertEqual('10.0.2.0/24', str(Network.network_create(
environment=environment, name='private', pool=None).ip_network))
environment = Environment.create('test_env2')
self.assertEqual('10.0.3.0/24', str(Network.network_create(
environment=environment, name='internal', pool=None).ip_network))
self.assertEqual('10.0.4.0/24', str(Network.network_create(
environment=environment, name='external', pool=None).ip_network))
self.assertEqual('10.0.5.0/24', str(Network.network_create(
environment=environment, name='private', pool=None).ip_network))
def setUp(self):
super(TestLibvirtVolume, self).setUp()
self.sleep_mock = self.patch('devops.helpers.retry.sleep')
self.open_mock = mock.mock_open(read_data='image_data')
self.patch('devops.driver.libvirt.libvirt_driver.open',
self.open_mock, create=True)
self.os_mock = self.patch('devops.helpers.helpers.os')
Size = collections.namedtuple('Size', ['st_size'])
self.file_sizes = {
'/tmp/admin.iso': Size(st_size=500),
}
self.os_mock.stat.side_effect = self.file_sizes.get
self.env = Environment.create('test_env')
self.group = self.env.add_group(
group_name='test_group',
driver_name='devops.driver.libvirt.libvirt_driver',
connection_string='test:///default',
storage_pool_name='default-pool')
self.node = self.group.add_node(
name='test_node',
role='default',
architecture='i686',
hypervisor='test',
)
self.d = self.group.driver
def test_create_node3(self):
environment = Environment.create('test_env3')
internal = Network.network_create(environment=environment,
name='internal',
pool=None)
external = Network.network_create(environment=environment,
name='external',
pool=None)
private = Network.network_create(environment=environment,
name='private',
pool=None)
node = Node.node_create(name='test_node', environment=environment)
Interface.interface_create(node=node, network=internal)
Interface.interface_create(node=node, network=external)
Interface.interface_create(node=node, network=private)
volume = Volume.volume_get_predefined(
'/var/lib/libvirt/images/disk-135824657433.qcow2')
v3 = Volume.volume_create_child('test_vp892',
backing_store=volume,
environment=environment)
v4 = Volume.volume_create_child('test_vp891',
backing_store=volume,
environment=environment)
DiskDevice.node_attach_volume(node=node, volume=v3)
DiskDevice.node_attach_volume(node, v4)
environment.define()
def setUp(self):
super(TestLibvirtVolume, self).setUp()
self.sleep_mock = self.patch('devops.helpers.retry.sleep')
self.open_mock = mock.mock_open(read_data='image_data')
self.patch('devops.driver.libvirt.libvirt_driver.open',
self.open_mock,
create=True)
self.os_mock = self.patch('devops.helpers.helpers.os')
Size = collections.namedtuple('Size', ['st_size'])
self.file_sizes = {
'/tmp/admin.iso': Size(st_size=500),
}
self.os_mock.stat.side_effect = self.file_sizes.get
self.env = Environment.create('test_env')
self.group = self.env.add_group(group_name='test_group',
driver_name='devops.driver.libvirt',
connection_string='test:///default',
storage_pool_name='default-pool')
self.node = self.group.add_node(
name='test_node',
role='default',
architecture='i686',
hypervisor='test',
)
self.d = self.group.driver
def test_update_disks_from_snapshot_with_children(
self, mock_has_snapshot, mock_volume_define,
mock_libvirt_version,
mock_get_snapshot, mock_create_snapshot):
mock_has_snapshot.return_value = False
mock_libvirt_version.return_value = 1002012
volume_path_template = '/var/lib/libvirt/images/{0}'
environment = Environment.create('test_env_extsnap')
node = Node.node_create(name='test_node', environment=environment)
vol_volume_name = factories.fuzzy_string()
vol = Volume.volume_create(vol_volume_name,
capacity=1000000000,
format='qcow2',
environment=environment)
vol.uuid = volume_path_template.format(vol_volume_name)
DiskDevice.node_attach_volume(node=node, volume=vol)
environment.define()
snap_name = factories.fuzzy_string('snap_')
snap_description = factories.fuzzy_string('description_')
snapshot_volume_name = '{0}.{1}'.format(vol_volume_name,
snap_name)
mock_get_snapshot.return_value = mock.Mock(
get_type='external', children_num=1,
disks={'sda': volume_path_template.format(snap_name)})
node.snapshot(name=snap_name, description=snap_description,
external=True)
vol1 = environment.get_volume(name=snapshot_volume_name)
vol1.uuid = volume_path_template.format(snap_name)
vol1.save()
node._update_disks_from_snapshot(snap_name)
self.assertEqual(node.disk_devices[0].volume, vol)
def setUp(self):
super(TestLibvirtTemplate, self).setUp()
# speed up retry
self.sleep_mock = self.patch('time.sleep')
# mock open
self.open_mock = mock.mock_open(read_data='image_data')
self.patch('devops.driver.libvirt.libvirt_driver.open',
self.open_mock, create=True)
self.os_mock = self.patch('devops.helpers.helpers.os')
self.os_mock.urandom = os.urandom
# noinspection PyPep8Naming
Size = collections.namedtuple('Size', ['st_size'])
self.file_sizes = {
'/tmp/admin.iso': Size(st_size=500),
}
self.os_mock.stat.side_effect = self.file_sizes.get
# Create Environment
self.full_conf = yaml.load(ENV_TMPLT)
self.env = Environment.create_environment(self.full_conf)
self.d = self.env.get_group(name='rack-01').driver
def setUp(self):
super(TestLibvirtDriver, self).setUp()
self.env = Environment.create('test_env')
self.group = self.env.add_group(
group_name='test_group',
driver_name='devops.driver.libvirt.libvirt_driver',
connection_string='test:///default')
self.ap = self.env.add_address_pool(
name='test_ap',
net='172.0.0.0/16:24',
tag=0,
ip_reserved=dict(l2_network_device=1),
)
self.net_pool = self.group.add_network_pool(
name='fuelweb_admin',
address_pool_name='test_ap',
)
self.l2_net_dev = self.group.add_l2_network_device(
name='test_l2_net_dev',
address_pool='test_ap',
forward=dict(mode='nat'),
)
self.d = self.group.driver
def test_external_snapshot_erase(
self, mock_has_snapshot, mock_volume_define,
mock_libvirt_version, mock_delete_snapshot,
mock_get_snapshot, mock_create_snapshot):
mock_has_snapshot.return_value = False
mock_libvirt_version.return_value = 1002012
mock_get_snapshot.return_value = mock.Mock(get_type='external',
children_num=0)
environment = Environment.create('test_env_extsnap')
node = Node.node_create(name='test_node', environment=environment)
vol_volume_name = factories.fuzzy_string()
vol = Volume.volume_create(vol_volume_name,
capacity=1000000000,
format='qcow2',
environment=environment)
DiskDevice.node_attach_volume(node=node, volume=vol)
environment.define()
snap_name = factories.fuzzy_string('snap_')
snap_description = factories.fuzzy_string('description_')
node.snapshot(name=snap_name, description=snap_description,
external=True)
mock_has_snapshot.return_value = True
node.erase_snapshot(snap_name)
mock_delete_snapshot.assert_called_with(node=node, name=snap_name)
self.assertEqual(node.disk_devices[0].volume, vol)
def test_external_snapshot_revert_with_children_revert_present(
self, mock_revert_snapshot_recreate_disks,
mock_revert_snapshot, mock_get_snapshot, mock_has_snapshot,
mock_destroy, mock_update_disks_from_snapshot):
revert_postfix = '-revert3'
def get_snapshot(node, snapname):
if snapname.endswith(revert_postfix):
return mock.Mock(get_type='external', children_num=0)
else:
return mock.Mock(get_type='external', children_num=1)
mock_has_snapshot.return_value = True
mock_get_snapshot.side_effect = get_snapshot
environment = Environment.create('test_env_extsnap')
node = Node.node_create(name='test_node', environment=environment)
environment.define()
snapshot_name = factories.fuzzy_string('snap_')
node.revert(name=snapshot_name, destroy=False)
revert_snapshot_name = '{0}{1}'.format(snapshot_name, revert_postfix)
mock_update_disks_from_snapshot.assert_called_with(
revert_snapshot_name)
mock_revert_snapshot_recreate_disks.assert_called_with(
node, revert_snapshot_name)
mock_revert_snapshot.assert_called_with(node=node,
name=revert_snapshot_name)
def test_create_volume(self):
environment = Environment.create('test_env3')
volume = Volume.volume_get_predefined(
'/var/lib/libvirt/images/disk-135824657433.qcow2')
v3 = Volume.volume_create_child(
'test_vp89', backing_store=volume, environment=environment)
v3.define()
def setUp(self):
super(TestLibvirtL2NetworkDevice, self).setUp()
self.env = Environment.create('test_env')
self.group = self.env.add_group(
group_name='test_group',
driver_name='devops.driver.libvirt',
connection_string='test:///default')
self.ap = self.env.add_address_pool(
name='test_ap',
net='172.0.0.0/16:24',
tag=0,
ip_reserved=dict(l2_network_device='172.0.0.1'),
)
self.net_pool = self.group.add_network_pool(
name='fuelweb_admin',
address_pool_name='test_ap',
)
self.l2_net_dev = self.group.add_l2_network_device(
name='test_l2_net_dev',
forward=dict(mode='nat'),
address_pool='test_ap',
)
self.d = self.group.driver
def do_list(self):
env_list = Environment.list_all().values("name", "created")
columns = []
for env in env_list:
column = collections.OrderedDict({"NAME": env["name"]})
if self.params.list_ips:
cur_env = Environment.get(name=env["name"])
admin_ip = ""
if "admin" in [node.name for node in cur_env.get_nodes()]:
admin_ip = cur_env.get_node(name="admin").get_ip_address_by_network_name("admin")
column["ADMIN IP"] = admin_ip
if self.params.timestamps:
column["CREATED"] = env["created"].strftime("%Y-%m-%d_%H:%M:%S")
columns.append(column)
self.print_table(headers="keys", columns=columns)
def test_network_model(self):
environment = Environment.create('test_env')
node = Node.objects.create(
group=None,
name='test_node',
role='default',
)
pool = IpNetworksPool(networks=[IPNetwork('10.1.0.0/24')], prefix=24)
address_pool = AddressPool.address_pool_create(environment=environment,
name='internal',
pool=pool)
l2_net_dev = L2NetworkDevice.objects.create(group=None,
address_pool=address_pool,
name='test_l2_dev')
interface1 = Interface.interface_create(l2_network_device=l2_net_dev,
node=node,
label='eth0')
assert interface1.model == 'virtio'
interface2 = Interface.interface_create(l2_network_device=l2_net_dev,
node=node,
label='eth0',
model='e1000')
assert interface2.model == 'e1000'
def do_create(self):
env_name = self.params.name
for env in Environment.list_all():
if env.name == env_name:
print("Please, set another environment name")
raise SystemExit()
self.env = Environment.create(env_name)
networks, prefix = self.params.net_pool.split(":")
Network.default_pool = Network.create_network_pool(networks=[ipaddr.IPNetwork(networks)], prefix=int(prefix))
networks = Network.create_networks(environment=self.env)
admin_node = self.admin_add(networks=networks)
self.do_slave_add(force_define=False)
self.env.define()
admin_node.disk_devices.get(device="cdrom").volume.upload(self.params.iso_path)
for net in self.env.get_networks():
net.start()
def test_snapshot_with_existing_name_force_delete(self, mock_has_snapshot,
mock_delete_snapshot,
mock_create_snapshot):
mock_has_snapshot.return_value = True
environment = Environment.create('test_env_extsnap')
node = Node.node_create(name='test_node', environment=environment)
environment.define()
snap_name = factories.fuzzy_string('snap_')
snap_description = factories.fuzzy_string('description_')
node.snapshot(
name=snap_name,
force=True,
description=snap_description,
disk_only=True)
self.assertEqual(mock_delete_snapshot.called, True)
mock_delete_snapshot.assert_called_with(node=node, name=snap_name)
mock_create_snapshot.assert_called_with(
node=node,
name=snap_name,
description=snap_description,
disk_only=True,
external=False)
def test_node_creation(self):
environment = Environment.create('test_env3')
internal = Network.network_create(
environment=environment, name='internal', pool=None)
node = Node.node_create(name='test_node', environment=environment)
Interface.interface_create(node=node, network=internal)
environment.define()
def test_create_volume(self):
environment = Environment.create('test_env3')
volume = Volume.volume_get_predefined(
'/var/lib/libvirt/images/disk-135824657433.qcow2')
v3 = Volume.volume_create_child(
'test_vp89', backing_store=volume, environment=environment)
v3.define()
def setUp(self):
super(TestCloudImage, self).setUp()
self.open_mock = mock.mock_open(read_data='image_data')
self.patch('devops.driver.libvirt.libvirt_driver.open',
self.open_mock, create=True)
self.os_mock = self.patch('devops.helpers.helpers.os')
# noinspection PyPep8Naming
Size = collections.namedtuple('Size', ['st_size'])
self.file_sizes = {
'/tmp/test/cloud_settings.iso': Size(st_size=1 * 1024 ** 3),
}
self.os_mock.stat.side_effect = self.file_sizes.get
self.generate_cloud_image_settings_mock = self.patch(
'devops.helpers.cloud_image_settings'
'.generate_cloud_image_settings')
self.volume_upload_mock = self.patch(
'devops.driver.libvirt.Volume.upload')
# Environment with a 'public' network
self.env = Environment.create('test')
self.group = self.env.add_group(
group_name='test_group',
driver_name='devops.driver.libvirt',
connection_string='test:///default',
storage_pool_name='default-pool')
self.pub_ap = self.env.add_address_pool(
name='public-pool01', net='10.109.0.0/16:24', tag=0,
ip_reserved=dict(gateway=1, l2_network_device=1),
ip_ranges=dict(default=[2, -2]))
self.group.add_l2_network_device(
name='public', address_pool='public-pool01')
# Node connected to the 'public' network
self.node = self.group.add_node(
name='test-node',
role='cloud-node',
architecture='x86_64',
hypervisor='test',
cloud_init_volume_name='iso',
cloud_init_iface_up='enp0s3')
self.system_volume = self.node.add_volume(name='system', capacity=10)
self.iso_volume = self.node.add_volume(name='iso', capacity=5)
self.adm_iface = self.node.add_interface(
label='enp0s3',
l2_network_device_name='public',
mac_address='64:b6:87:44:14:17',
interface_model='e1000')
self.node.add_network_config(
label='enp0s3',
networks=['public'])
def test_external_snapshot(
self, mock_has_snapshot, mock_create_volume,
mock_libvirt_version, mock_create_snapshot):
mock_has_snapshot.return_value = False
mock_libvirt_version.return_value = 1002012
environment = Environment.create('test_env_extsnap')
node = Node.node_create(name='test_node', environment=environment)
vol_volume_name = factories.fuzzy_string()
vol = Volume.volume_create(vol_volume_name,
capacity=1000000000,
format='qcow2',
environment=environment)
DiskDevice.node_attach_volume(node=node, volume=vol)
environment.define()
snap_name = factories.fuzzy_string('snap_')
snap_description = factories.fuzzy_string('description_')
node.snapshot(name=snap_name, description=snap_description,
external=True)
mock_create_volume.assert_called_with(snap_name)
mock_create_snapshot.assert_called_with(
node=node, name=snap_name, description=snap_description,
disk_only=False, external=True)
def test_external_snapshot_volume_creation(self, mock_volume_define):
mock_volume_define.return_value = None
environment = Environment.create('test_env_extsnap')
node = Node.node_create(name='test_node', environment=environment)
vol_volume_name = factories.fuzzy_string()
vol = Volume.volume_create(vol_volume_name,
capacity=1000000000,
format='qcow2',
environment=environment)
DiskDevice.node_attach_volume(node=node, volume=vol)
environment.define()
snapshot_name = factories.fuzzy_string('snap_')
snapshot_volume_name = '{0}.{1}'.format(vol_volume_name,
snapshot_name)
node.snapshot_create_volume(snapshot_name)
vol1 = environment.get_volume(name=snapshot_volume_name)
self.assertEqual(len(node.disk_devices), 1)
self.assertEqual(vol1.name, snapshot_volume_name)
self.assertEqual(vol1.format, 'qcow2')
self.assertEqual(vol1.environment, environment)
self.assertEqual(vol1.backing_store, vol)
self.assertEqual(vol1, node.disk_devices[0].volume)
mock_volume_define.assert_called_with(vol1)
def setUp(self):
super(TestCloudImage, self).setUp()
self.open_mock = mock.mock_open(read_data='image_data')
self.patch('devops.driver.libvirt.libvirt_driver.open',
self.open_mock,
create=True)
self.os_mock = self.patch('devops.helpers.helpers.os')
# noinspection PyPep8Naming
Size = collections.namedtuple('Size', ['st_size'])
self.file_sizes = {
'/tmp/test/cloud_settings.iso': Size(st_size=1 * 1024**3),
}
self.os_mock.stat.side_effect = self.file_sizes.get
self.generate_cloud_image_settings_mock = self.patch(
'devops.helpers.cloud_image_settings'
'.generate_cloud_image_settings')
self.volume_upload_mock = self.patch(
'devops.driver.libvirt.Volume.upload')
# Environment with a 'public' network
self.env = Environment.create('test')
self.group = self.env.add_group(group_name='test_group',
driver_name='devops.driver.libvirt',
connection_string='test:///default',
storage_pool_name='default-pool')
self.pub_ap = self.env.add_address_pool(
name='public-pool01',
net='10.109.0.0/16:24',
tag=0,
ip_reserved=dict(gateway=1, l2_network_device=1),
ip_ranges=dict(default=[2, -2]))
self.group.add_l2_network_device(name='public',
address_pool='public-pool01')
# Node connected to the 'public' network
self.node = self.group.add_node(name='test-node',
role='cloud-node',
architecture='x86_64',
hypervisor='test',
cloud_init_volume_name='iso',
cloud_init_iface_up='enp0s3')
self.system_volume = self.node.add_volume(name='system', capacity=10)
self.iso_volume = self.node.add_volume(name='iso', capacity=5)
self.adm_iface = self.node.add_interface(
label='enp0s3',
l2_network_device_name='public',
mac_address='64:b6:87:44:14:17',
interface_model='e1000')
self.node.add_network_config(label='enp0s3', networks=['public'])
def setUp(self):
super(TestLibvirtNodeMultipath, self).setUp()
self.sleep_mock = self.patch('devops.helpers.retry.sleep')
self.libvirt_sleep_mock = self.patch(
'devops.driver.libvirt.libvirt_driver.sleep')
self.env = Environment.create('test_env')
self.group = self.env.add_group(
group_name='test_group',
driver_name='devops.driver.libvirt',
connection_string='test:///default',
storage_pool_name='default-pool',
vnc_password='******',
)
self.ap = self.env.add_address_pool(
name='test_ap',
net='172.0.0.0/16:24',
tag=0,
ip_reserved=dict(l2_network_device=1),
)
self.net_pool = self.group.add_network_pool(
name='fuelweb_admin',
address_pool_name='test_ap',
)
self.l2_net_dev = self.group.add_l2_network_device(
name='test_l2_net_dev',
address_pool='test_ap',
forward=dict(mode='nat'),
)
self.node = self.group.add_node(
name='test_node',
role='default',
architecture='i686',
hypervisor='test',
)
self.interface = self.node.add_interface(
label='eth0',
l2_network_device_name='test_l2_net_dev',
interface_model='virtio',
)
self.interface.mac_address = '64:b6:87:44:14:17'
self.interface.save()
self.volume = self.node.add_volume(
name='test_volume',
capacity=5,
multipath_count=2,
serial='3b16d312420d4adbb2d5b04fcbd5221c',
)
self.d = self.group.driver
self.l2_net_dev.define()
def get_env(cls, env_name):
"""Find and return env by name."""
try:
return EnvProxy(Environment.get(name=env_name))
except Exception as e:
logger.error(
'failed to find the last created environment{}'.format(e))
raise
def do_list(self):
env_list = Environment.list().values('name', 'created')
for env in env_list:
if self.params.list_ips:
cur_env = Environment.get(name=env['name'])
admin_ip = ''
if 'admin' in [node.name for node in cur_env.get_nodes()]:
admin_ip = (cur_env.get_node(
name='admin').get_ip_address_by_network_name('admin'))
print('{0}\t{1}'.format(env['name'], admin_ip))
elif self.params.timestamps:
created_text = env['created'].strftime('%Y-%m-%d_%H:%M:%S')
print('{0} {1}'.format(env['name'], created_text))
else:
print(env['name'])
return env_list
def do_list(self):
env_list = Environment.list().values('name', 'created')
for env in env_list:
if self.params.list_ips:
cur_env = Environment.get(name=env['name'])
admin_ip = ''
if 'admin' in [node.name for node in cur_env.get_nodes()]:
admin_ip = (cur_env.get_node(name='admin').
get_ip_address_by_network_name('admin'))
print('{0}\t{1}'.format(env['name'], admin_ip))
elif self.params.timestamps:
created_text = env['created'].strftime('%Y-%m-%d_%H:%M:%S')
print('{0} {1}'.format(env['name'], created_text))
else:
print(env['name'])
return env_list
def get_env(cls, env_name):
"""Find and return env by name."""
try:
return EnvProxy(Environment.get(name=env_name))
except Exception as e:
logger.error(
'failed to find the last created environment{}'.format(e))
raise
def test_node_creation(self):
environment = Environment.create('test_env3')
internal = Network.network_create(
environment=environment, name='internal', pool=None)
node = Node.node_create(
name='test_node', environment=environment)
Interface.interface_create(node=node, network=internal)
environment.define()
def setUp(self):
super(TestLibvirtNodeMultipath, self).setUp()
self.sleep_mock = self.patch('time.sleep')
self.env = Environment.create('test_env')
self.group = self.env.add_group(
group_name='test_group',
driver_name='devops.driver.libvirt',
connection_string='test:///default',
storage_pool_name='default-pool',
vnc_password='******',
enable_nwfilters=True,
)
self.ap = self.env.add_address_pool(
name='test_ap',
net='172.0.0.0/16:24',
tag=0,
ip_reserved=dict(l2_network_device=1),
)
self.net_pool = self.group.add_network_pool(
name='fuelweb_admin',
address_pool_name='test_ap',
)
self.l2_net_dev = self.group.add_l2_network_device(
name='test_l2_net_dev',
address_pool='test_ap',
forward=dict(mode='nat'),
)
self.node = self.group.add_node(
name='test_node',
role='default',
architecture='i686',
hypervisor='test',
)
self.interface = self.node.add_interface(
label='eth0',
l2_network_device_name='test_l2_net_dev',
interface_model='virtio',
)
self.interface.mac_address = '64:b6:87:44:14:17'
self.interface.save()
self.volume = self.node.add_volume(
name='test_volume',
capacity=5,
multipath_count=2,
serial='3b16d312420d4adbb2d5b04fcbd5221c',
)
self.d = self.group.driver
self.l2_net_dev.define()
def do_list(self):
env_list = Environment.list_all().values('name', 'created')
columns = []
for env in env_list:
column = collections.OrderedDict({'NAME': env['name']})
if self.params.list_ips:
cur_env = Environment.get(name=env['name'])
admin_ip = ''
if 'admin' in [node.name for node in cur_env.get_nodes()]:
admin_ip = (cur_env.get_node(name='admin').
get_ip_address_by_network_name('admin'))
column['ADMIN IP'] = admin_ip
if self.params.timestamps:
column['CREATED'] = env['created'].strftime(
'%Y-%m-%d_%H:%M:%S')
columns.append(column)
self.print_table(headers="keys", columns=columns)
def do_create(self):
env_name = self.params.name
for env in Environment.list_all():
if env.name == env_name:
print("Please, set another environment name")
raise SystemExit()
self.env = Environment.create(env_name)
networks, prefix = self.params.net_pool.split(':')
Network.default_pool = Network.create_network_pool(
networks=[ipaddr.IPNetwork(networks)], prefix=int(prefix))
networks = Network.create_networks(environment=self.env)
admin_node = self.admin_add(networks=networks)
self.do_slave_add(force_define=False)
self.env.define()
admin_node.disk_devices.get(device='cdrom').volume.upload(
self.params.iso_path)
for net in self.env.get_networks():
net.start()
def setUp(self):
super(TestLibvirtNodeSnapshotBase, self).setUp()
self.sleep_mock = self.patch('devops.helpers.retry.sleep')
self.libvirt_sleep_mock = self.patch(
'devops.driver.libvirt.libvirt_driver.sleep')
self.env = Environment.create('tenv')
self.group = self.env.add_group(
group_name='test_group',
driver_name='devops.driver.libvirt.libvirt_driver',
connection_string='test:///default',
storage_pool_name='default-pool',
vnc_password='******',
)
self.ap = self.env.add_address_pool(
name='test_ap',
net='172.0.0.0/16:24',
tag=0,
ip_reserved=dict(l2_network_device='172.0.0.1'),
)
self.net_pool = self.group.add_network_pool(
name='fuelweb_admin',
address_pool_name='test_ap',
)
self.l2_net_dev = self.group.add_l2_network_device(
name='test_l2_net_dev',
address_pool='test_ap',
forward=dict(mode='nat'),
)
self.node = self.group.add_node(
name='tnode',
role='default',
architecture='i686',
hypervisor='test',
)
self.interface = self.node.add_interface(
label='eth0',
l2_network_device_name='test_l2_net_dev',
interface_model='virtio',
)
self.volume = self.node.add_volume(
name='tvol',
capacity=5,
)
self.d = self.group.driver
self.l2_net_dev.define()
self.volume.define()
self.node.define()
def do_list(self):
env_list = Environment.list_all().values('name', 'created')
columns = []
for env in env_list:
column = collections.OrderedDict({'NAME': env['name']})
if self.params.list_ips:
cur_env = Environment.get(name=env['name'])
admin_ip = ''
if 'admin' in [node.name for node in cur_env.get_nodes()]:
admin_ip = (cur_env.get_node(
name='admin').get_ip_address_by_network_name('admin'))
column['ADMIN IP'] = admin_ip
if self.params.timestamps:
column['CREATED'] = env['created'].strftime(
'%Y-%m-%d_%H:%M:%S')
columns.append(column)
self.print_table(headers="keys", columns=columns)
def d_env(self):
if self._virt_env is None:
if not self._config:
try:
return Environment.get(name=settings.ENV_NAME)
except Exception:
self._virt_env = Environment.describe_environment(
boot_from=settings.ADMIN_BOOT_DEVICE)
self._virt_env.define()
else:
try:
return Environment.get(name=self._config['template']
['devops_settings']['env_name'])
except Exception:
self._virt_env = Environment.create_environment(
full_config=self._config)
self._virt_env.define()
return self._virt_env
def list_env():
environments = Environment.list_all()
for env in environments:
print "Env: %s" % env.name
print "DNS: %s" % socket.getfqdn()
for node in env.get_nodes():
if node.is_admin:
print "admin node ip: %s" % node.get_ip_address_by_network_name(
'admin')
def test_network_model(self):
environment = Environment.create('test_env')
node = Node.node_create('test_node', environment)
network = Network.network_create(
environment=environment, name='internal', ip_network='10.1.0.0/24')
interface1 = Interface.interface_create(network=network, node=node)
self.assertEquals('virtio', interface1.model)
interface2 = Interface.interface_create(
network=network, node=node, model='e1000')
self.assertEquals('e1000', interface2.model)
def test_snapshot_with_existing_name(self, mock_has_snapshot,
mock_node_create_snapshot):
mock_has_snapshot.return_value = True
environment = Environment.create('test_env_extsnap')
node = Node.node_create(name='test_node', environment=environment)
environment.define()
node.snapshot(name='test_name')
self.assertEqual(mock_node_create_snapshot.called, False)
def test_network_model(self):
environment = Environment.create('test_env')
node = Node.node_create('test_node', environment)
network = Network.network_create(
environment=environment, name='internal', ip_network='10.1.0.0/24')
interface1 = Interface.interface_create(network=network, node=node)
self.assertEquals('virtio', interface1.model)
interface2 = Interface.interface_create(
network=network, node=node, model='e1000')
self.assertEquals('e1000', interface2.model)
def dnsmasq_file_output():
environments = Environment.list_all()
print "# fuel-devops dnsmasq output:"
print "# last update UTC: %s" % datetime.datetime.utcnow()
for env in environments:
for node in env.get_nodes():
if node.is_admin:
#dnsmasq format:
print("server=/{0}.{1}/{2}".format(
env.name, socket.getfqdn(),
node.get_ip_address_by_network_name('admin')))
def test_network_iterator(self):
environment = Environment.create('test_env')
node = Node.node_create('test_node', environment)
network = Network.network_create(
environment=environment, name='internal', ip_network='10.1.0.0/24')
interface = Interface.interface_create(network=network, node=node)
Address.objects.create(str('10.1.0.1'), interface=interface)
network.next_ip()
Address.objects.create(str('10.1.0.3'), interface=interface)
ip = network.next_ip()
self.assertEquals('10.1.0.4', str(ip))
def __init__(self, args):
self.args = args
self.params = self.get_params()
if getattr(self.params, "snapshot-name", None):
self.snapshot_name = getattr(self.params, "snapshot-name")
if getattr(self.params, "name", None) and getattr(self.params, "command", None) != "create":
try:
self.env = Environment.get(name=self.params.name)
except Environment.DoesNotExist:
self.env = None
sys.exit("Enviroment with name {} doesn't exist." "".format(self.params.name))
def update():
from os import environ
from devops.models import Environment
environ.setdefault("DJANGO_SETTINGS_MODULE", "devops.settings")
with open("hosts.pp", "w") as pp:
for e in Environment.list_all():
ip = e.nodes().admin.get_ip_address_by_network_name(e.admin_net)
pp.write("host {{ '{}': ip => '{}' }}\n".format(e.name, ip))
local("sudo puppet apply hosts.pp")
def update():
from os import environ
from devops.models import Environment
environ.setdefault("DJANGO_SETTINGS_MODULE", "devops.settings")
with open("hosts.pp", "w") as pp:
for e in Environment.list_all():
ip = e.nodes().admin.get_ip_address_by_network_name(e.admin_net)
pp.write("host {{ '{}': ip => '{}' }}\n".format(e.name, ip))
local("sudo puppet apply hosts.pp")
def test_network_iterator(self):
environment = Environment.create('test_env')
node = Node.node_create('test_node', environment)
network = Network.network_create(environment=environment,
name='internal',
ip_network='10.1.0.0/24')
interface = Interface.interface_create(network=network, node=node)
Address.objects.create(str('10.1.0.1'), interface=interface)
network.next_ip()
Address.objects.create(str('10.1.0.3'), interface=interface)
ip = network.next_ip()
self.assertEquals('10.1.0.4', str(ip))
def setUp(self):
# ENVIRONMENT
self.env = Environment.create(name='test')
# ADRESS POOLS
self.admin_ap = self.env.add_address_pool(
name='fuelweb_admin-pool01', net='10.109.0.0/16:24', tag=0,
ip_reserved=dict(gateway=1, l2_network_device=1),
ip_ranges=dict(default=[2, -2]))
self.pub_ap = self.env.add_address_pool(
name='public-pool01', net='10.109.0.0/16:24', tag=0,
ip_reserved=dict(gateway=1, l2_network_device=1),
ip_ranges=dict(default=[2, -2]))
self.stor_ap = self.env.add_address_pool(
name='storage-pool01', net='10.109.0.0/16:24', tag=101,
ip_reserved=dict(gateway=1, l2_network_device=1),
ip_ranges=dict(default=[2, -2]))
self.mng_ap = self.env.add_address_pool(
name='management-pool01', net='10.109.0.0/16:24', tag=102,
ip_reserved=dict(gateway=1, l2_network_device=1),
ip_ranges=dict(default=[2, -2]))
self.priv_ap = self.env.add_address_pool(
name='private-pool01', net='10.109.0.0/16:24', tag=103,
ip_reserved=dict(gateway=1, l2_network_device=1),
ip_ranges=dict(default=[2, -2]))
# GROUP
self.group = self.env.add_group(group_name='test-group',
driver_name='devops.driver.empty')
# NETWORK POOLS
self.group.add_network_pool(name='fuelweb_admin',
address_pool_name='fuelweb_admin-pool01')
self.group.add_network_pool(name='public',
address_pool_name='public-pool01')
self.group.add_network_pool(name='storage',
address_pool_name='storage-pool01')
self.group.add_network_pool(name='management',
address_pool_name='management-pool01')
self.group.add_network_pool(name='private',
address_pool_name='private-pool01')
# L2 NETWORK DEVICES
self.group.add_l2_network_device(
name='admin', address_pool='fuelweb_admin-pool01')
self.group.add_l2_network_device(
name='public', address_pool='public-pool01')
self.group.add_l2_network_device(
name='storage', address_pool='storage-pool01')
self.group.add_l2_network_device(
name='management', address_pool='management-pool01')
self.group.add_l2_network_device(
name='private', address_pool='private-pool01')
def __init__(self, args):
self.args = args
self.params = self.get_params()
if getattr(self.params, 'snapshot-name', None):
self.snapshot_name = getattr(self.params, 'snapshot-name')
if (getattr(self.params, 'name', None)
and getattr(self.params, 'command', None) != 'create'):
try:
self.env = Environment.get(name=self.params.name)
except Environment.DoesNotExist:
self.env = None
sys.exit("Enviroment with name {} doesn't exist."
"".format(self.params.name))
def test_external_snapshot_incorrect_libvirt_version(
self, mock_has_snapshot, mock_libvirt_version,
mock_create_snapshot):
mock_has_snapshot.return_value = False
mock_libvirt_version.return_value = 1002009
environment = Environment.create('test_env_extsnap')
node = Node.node_create(name='test_node', environment=environment)
environment.define()
node.snapshot(name='test_name', external=True)
self.assertEqual(mock_create_snapshot.called, False)
def one():
environment = Environment.create('cdrom')
internal_pool = Network.create_network_pool(
networks=[IPNetwork('10.108.0.0/16')], prefix=24)
private_pool = Network.create_network_pool(
networks=[IPNetwork('10.108.0.0/16')], prefix=24)
external_pool = Network.create_network_pool(
networks=[IPNetwork('172.18.95.0/24')], prefix=27)
internal = Network.network_create(environment=environment,
name='internal',
pool=internal_pool)
external = Network.network_create(environment=environment,
name='external',
pool=external_pool,
forward='nat')
private = Network.network_create(environment=environment,
name='private',
pool=private_pool)
for i in range(1, 2):
node = Node.node_create(name='test_node' + str(i),
environment=environment)
Interface.interface_create(node=node, network=internal)
Interface.interface_create(node=node, network=external)
Interface.interface_create(node=node, network=private)
volume = Volume.volume_get_predefined(
'/var/lib/libvirt/images/centos63-cobbler-base.qcow2')
v3 = Volume.volume_create_child('test_vp895' + str(i),
backing_store=volume,
environment=environment)
v4 = Volume.volume_create_child('test_vp896' + str(i),
backing_store=volume,
environment=environment)
DiskDevice.node_attach_volume(node=node, volume=v3)
DiskDevice.node_attach_volume(node, v4)
DiskDevice.node_attach_volume(
node,
Volume.volume_get_predefined(
'/var/lib/libvirt/images/fuel-centos-6.3-x86_64.iso'),
device='cdrom',
bus='sata')
environment.define()
environment.start()
remotes = []
for node in environment.get_nodes():
node. await ('internal')
node.remote('internal', 'root', 'r00tme').check_stderr('ls -la',
verbose=True)
remotes.append(node.remote('internal', 'root', 'r00tme'))
SSHClient.execute_together(remotes, 'ls -la')
def setUp(self):
super(TestLibvirtDriverDeviceNames, self).setUp()
self.env = Environment.create('test_env')
self.group = self.env.add_group(group_name='test_group',
driver_name='devops.driver.libvirt',
connection_string='test:///default')
self.ap = self.env.add_address_pool(
name='test_ap',
net='172.0.0.0/16:24',
tag=0,
ip_reserved=dict(l2_network_device=1),
)
self.net_pool = self.group.add_network_pool(
name='fuelweb_admin',
address_pool_name='test_ap',
)
self.l2_net_dev = self.group.add_l2_network_device(
name='test_l2_net_dev',
address_pool='test_ap',
forward=dict(mode='nat'),
)
self.d = self.group.driver
self.d._device_name_generators = dict()
self.dev_mock = mock.Mock(spec=libvirt.virNodeDevice)
self.dev_mock.listCaps.return_value = ['net']
self.dev_mock.XMLDesc.return_value = """
<device>
<name>net_virnet132_fe_70_74_90_bc_84</name>
<path>/sys/devices/virtual/net/virnet132</path>
<parent>computer</parent>
<capability type='net'>
<interface>virnet1</interface>
<address>fe:70:74:90:bc:84</address>
<link state='unknown'/>
<capability type='80203'/>
</capability>
</device>
"""
self.dev2_mock = mock.Mock(spec=libvirt.virNodeDevice)
self.dev2_mock.listCaps.return_value = ['usb_device']
self.dev2_mock.XMLDesc.return_value = """
def setUp(self):
super(TestIpmiNode, self).setUp()
# Create Environment
self.ipmiclient_mock = self.patch(
'devops.driver.baremetal.ipmi_client.IpmiClient', autospec=True)
self.ipmiclient = self.ipmiclient_mock.return_value
self.wait_mock = self.patch('devops.helpers.helpers.wait')
self.env = Environment.create('test_env')
self.group = self.env.add_group(
group_name='test_group',
driver_name='devops.driver.baremetal',
)
self.ap = self.env.add_address_pool(
name='test_ap',
net='172.0.0.0/16:24',
tag=0,
ip_reserved=dict(l2_network_device=1),
)
self.net_pool = self.group.add_network_pool(
name='fuelweb_admin',
address_pool_name='test_ap',
)
self.l2_net_dev = self.group.add_l2_network_device(
name='test_l2_net_dev',
address_pool='test_ap',
)
self.node = self.group.add_node(
name='test_node',
role='default',
boot='pxe',
force_set_boot=True,
ipmi_user='******',
ipmi_password='******',
ipmi_previlegies='OPERATOR',
ipmi_host='ipmi-1.hostaddress.net',
ipmi_lan_interface='lanplus',
ipmi_port=623,
)
def test_node_creation(self):
environment = Environment.create('test_env3')
pool = IpNetworksPool(networks=[IPNetwork('10.1.0.0/24')], prefix=24)
address_pool = AddressPool.address_pool_create(environment=environment,
name='internal',
pool=pool)
l2_net_dev = L2NetworkDevice.objects.create(group=None,
address_pool=address_pool,
name='test_l2_dev')
node = Node.objects.create(
group=None,
name='test_node',
role='default',
)
Interface.interface_create(l2_network_device=l2_net_dev,
node=node,
label='eth0')
environment.define()
def setUp(self):
super(TestIPMITemplate, self).setUp()
# Create Environment
self.full_conf = yaml.load(ENV_TMPLT)
self.env = Environment.create_environment(self.full_conf)
self.ipmiclient_mock = self.patch(
'devops.driver.baremetal.ipmi_client.IpmiClient')
self.wait_mock = self.patch('devops.helpers.helpers.wait')
self.ipmiclient1 = mock.Mock(spec=IpmiClient)
self.ipmiclient2 = mock.Mock(spec=IpmiClient)
def get_client(*args):
"""Tricky way to return necessary node """
if args and args[6] == 'slave-01':
return self.ipmiclient1
elif args and args[6] == 'slave-02':
return self.ipmiclient2
self.ipmiclient_mock.side_effect = get_client
