x
/
nova-lxd
Code Issues Proposed changes

Fix PEP8 errors

This commit is contained in:
Michał Sawicz 2015-07-06 11:47:28 +02:00
parent e482591a62
commit aaa5ca3f46
17 changed files with 298 additions and 247 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

82
nclxd/nova/virt/lxd/container_config.py
View File

@ -14,20 +14,23 @@
# License for the specific language governing permissions and limitations
# under the License.
from oslo.utils import excutils
from oslo_config import cfg
from oslo_log import log as logging
from oslo.utils import excutils
from oslo_utils import units
from nova.api.metadata import base as instance_metadata
from nova.i18n import _, _LI, _LE
from nova.openstack.common import fileutils
from nova import exception
from nova import i18n
from nova.virt import configdrive
import container_image
import container_utils
_ = i18n._
_LE = i18n._LE
_LI = i18n._LI
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
@ -54,18 +57,19 @@ class LXDContainerConfig(object):
name = name_label
container_config = self._init_container_config()
container_config = self.add_config(container_config, 'name',
container_config = self.add_config(container_config, 'name',
name)
container_config = self.add_config(container_config, 'profiles',
['%s' % CONF.lxd.lxd_default_profile])
container_config = self.configure_container_config(container_config, instance)
[str(CONF.lxd.lxd_default_profile)])
container_config = self.configure_container_config(
container_config, instance)
''' Create an LXD image '''
self.container_image.fetch_image(context, instance, image_meta)
container_config = self.add_config(container_config, 'source',
self.configure_lxd_image(container_config,
instance, image_meta))
container_config = (
self.add_config(container_config, 'source',
self.configure_lxd_image(container_config,
instance, image_meta)))
return container_config
@ -86,19 +90,20 @@ class LXDContainerConfig(object):
''' Basic container configuration. '''
self.add_config(container_config, 'config', 'raw.lxc',
data='lxc.console.logfile=%s\n'
% self.container_dir.get_console_path(instance.name))
% self.container_dir.get_console_path(instance.name))
return container_config
def configure_lxd_image(self, container_config, instance, image_meta):
LOG.debug('Getting LXD image')
self.add_config(container_config, 'source',
self.add_config(container_config, 'source',
{'type': 'image',
'alias': str(image_meta.get('name'))
})
})
return container_config
def configure_network_devices(self, container_config, instance, network_info):
def configure_network_devices(self, container_config,
instance, network_info):
LOG.debug('Get network devices')
''' ugh this is ugly'''
@ -109,69 +114,68 @@ class LXDContainerConfig(object):
bridge = 'qbr%s' % vif_id
self.add_config(container_config, 'devices', bridge,
data={'nictype': 'bridged',
'hwaddr': mac,
'parent': bridge,
'type': 'nic'})
data={'nictype': 'bridged',
'hwaddr': mac,
'parent': bridge,
'type': 'nic'})
return container_config
def configure_disk_path(self, container_config, vfs_type, instance):
LOG.debug('Create disk path')
config_drive = \
self.container_dir.get_container_configdirve(instance.name)
config_drive = self.container_dir.get_container_configdirve(
instance.name)
self.add_config(container_config, 'devices', str(vfs_type),
data={'path': 'mnt',
'source': config_drive,
'type': 'disk'})
return container_config
return container_config
def configure_container_rescuedisk(self, container_config, instance):
LOG.debug('Create rescue disk')
rescue_path = \
self.container_dir.get_container_rootfs(instance.name)
rescue_path = self.container_dir.get_container_rootfs(instance.name)
self.add_config(container_config, 'devices', 'rescue',
data={'path': 'mnt',
'source': rescue_path,
'type': 'disk'})
return container_config
def configure_container_configdrive(self, container_config, instance, injected_files,
admin_password):
def configure_container_configdrive(self, container_config, instance,
injected_files, admin_password):
LOG.debug('Create config drive')
if CONF.config_drive_format not in ('fs', None):
msg = _('Invalid config drive format: %s'
% CONF.config_drive_format)
msg = (_('Invalid config drive format: %s')
% CONF.config_drive_format)
raise exception.InstancePowerOnFailure(reason=msg)
LOG.info(_LI('Using config drive for instance'), instance=instance)
extra_md = {}
inst_md = instance_metadata.InstanceMetadata(instance,
content=injected_files,
extra_md=extra_md)
content=injected_files,
extra_md=extra_md)
name = instance.name
try:
with configdrive.ConfigDriveBuilder(instance_md=inst_md) as cdb:
container_configdrive = \
container_configdrive = (
self.container_dir.get_container_configdirve(name)
)
cdb.make_drive(container_configdrive)
container_config = self.configure_disk_path(container_config, 'configdrive',
instance)
container_config = self.configure_disk_path(container_config,
'configdrive',
instance)
except Exception as e:
with excutils.save_and_reraise_exception():
LOG.error(_LE('Creating config drive failed with error: %s'),
e, instance=instance)
e, instance=instance)
return container_config
def add_config(self, config, key, value, data=None):
if key == 'config':
config.setdefault('config', {}).\
setdefault(value, data)
config.setdefault('config', {}).setdefault(value, data)
elif key == 'devices':
config.setdefault('devices', {}).\
setdefault(value, data)
elif not key in config:
config.setdefault('devices', {}).setdefault(value, data)
elif key not in config:
config.setdefault(key, value)
return config

33
nclxd/nova/virt/lxd/container_image.py
View File

@ -19,20 +19,18 @@ import os
from oslo_config import cfg
from oslo_log import log as logging
from pylxd import api
from pylxd import exceptions as lxd_exceptions
from nova.i18n import _
from nova.openstack.common import fileutils
from nova.compute import task_states
from nova import image
from nova import exception
from nova import utils
from nova import i18n
from nova import image
from nova.openstack.common import fileutils
import container_config
import container_utils
_ = i18n._
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
IMAGE_API = image.API()
@ -47,7 +45,7 @@ class LXDContainerImage(object):
def fetch_image(self, context, instance, image_meta):
LOG.debug("Downloading image file data %(image_ref)s to LXD",
{'image_ref': instance.image_ref})
image_name = image_meta.get('name')
if image_name in self.lxd.alias_list():
return
@ -71,8 +69,9 @@ class LXDContainerImage(object):
if e.status_code == 404:
pass
else:
raise exception.ImageUnacceptable(image_id=instance.image_ref,
reason=_('Image already exists.'))
raise exception.ImageUnacceptable(
image_id=instance.image_ref,
reason=_('Image already exists.'))
try:
LOG.debug('Uploading image: %s' % container_image)
@ -80,17 +79,19 @@ class LXDContainerImage(object):
except lxd_exceptions.APIError as e:
raise exception.ImageUnacceptable(
image_id=instance.image_ref,
reason=_('Image failed to upload: %s' % e))
reason=_('Image failed to upload: %s') % e)
try:
alias_config = {'name': image_name,
'target': self.get_container_image_md5(image_meta)
}
alias_config = {
'name': image_name,
'target': self.get_container_image_md5(image_meta)
}
LOG.debug('Creating alias: %s' % alias_config)
self.lxd.alias_create(alias_config)
except lxd_exceptions.APIError:
raise exception.ImageUnacceptable(image_id=instance.image_ref,
reason=_('Image already exists.'))
raise exception.ImageUnacceptable(
image_id=instance.image_ref,
reason=_('Image already exists.'))
def get_container_image_md5(self, image_meta):
container_image = self.container_dir.get_container_image(image_meta)

59
nclxd/nova/virt/lxd/container_ops.py
View File

@ -21,19 +21,23 @@ import pwd
from oslo_config import cfg
from oslo_log import log as logging
from oslo_utils import units
import vif
from nova.i18n import _, _LW
from nova import exception
from nova import i18n
from nova.openstack.common import fileutils
from nova import utils
from nova.virt import configdrive
from nova.virt import driver
from nova.virt import hardware
from nova import utils
import container_config
import container_image
import container_utils
import vif
_ = i18n._
_LE = i18n._LE
_LW = i18n._LW
CONF = cfg.CONF
CONF.import_opt('vif_plugging_timeout', 'nova.virt.driver')
@ -85,7 +89,7 @@ class LXDContainerOperations(object):
name_label, rescue)
def create_instance(self, context, instance, image_meta, injected_files,
admin_password, network_info, block_device_info,
admin_password, network_info, block_device_info,
name_label=None, rescue=False):
LOG.debug('Creating instance')
@ -109,34 +113,42 @@ class LXDContainerOperations(object):
msg = _('Ephemeral block devices is not supported.')
raise exception.NovaException(msg)
container_config = self.container_config.configure_container(context,
instance, network_info, image_meta, name_label, rescue)
container_config = self.container_config.configure_container(
context, instance, network_info, image_meta, name_label, rescue)
LOG.debug(pprint.pprint(container_config))
(state, data) = self.container_utils.container_init(container_config)
self.container_utils.wait_for_container(
data.get('operation').split('/')[3])
if configdrive.required_by(instance):
container_configdrive = self.container_config.configure_container_configdrive(
container_config,
instance, injected_files,
admin_password)
container_configdrive = (
self.container_config.configure_container_configdrive(
container_config,
instance,
injected_files,
admin_password))
LOG.debug(pprint.pprint(container_configdrive))
self.contianer_utils.container_update(name, containe_configdrive)
self.container_utils.container_update(name, container_configdrive)
if network_info:
container_network_devices = self.container_config.configure_network_devices(
container_config, instance, network_info)
container_network_devices = (
self.container_config.configure_network_devices(
container_config,
instance,
network_info))
LOG.debug(pprint.pprint(container_network_devices))
self.container_utils.container_update(name, container_network_devices)
self.container_utils.container_update(
name, container_network_devices)
if rescue:
container_rescue_devices = self.container_config.configure_container_rescuedisk(
container_config, instance)
container_rescue_devices = (
self.container_config.configure_container_rescuedisk(
container_config,
instance))
LOG.debug(pprint.pprint(container_rescue_devices))
self.container_utils.container_update(name, container_rescue_devices)
self.container_utils.container_update(
name, container_rescue_devices)
self.start_instance(instance, network_info, rescue)
@ -173,12 +185,12 @@ class LXDContainerOperations(object):
return self.container_utils.container_reboot(instance.name)
def plug_vifs(self, instance, network_info):
for vif in network_info:
self.vif_driver.plug(instance, vif)
for viface in network_info:
self.vif_driver.plug(instance, viface)
def unplug_vifs(self, instance, network_info):
for vif in network_info:
self.vif_driver.plug(instance, vif)
for viface in network_info:
self.vif_driver.plug(instance, viface)
def destroy(self, context, instance, network_info, block_device_info=None,
destroy_disks=True, migrate_data=None):
@ -210,8 +222,7 @@ class LXDContainerOperations(object):
self.container_utils.container_stop(instance.name)
rescue_name_label = '%s-rescue' % instance.name
if self.container_utils.container_defined(rescue_name_label):
msg = _('Instace is arleady in Rescue mode: %s'
% instance.name)
msg = _('Instace is arleady in Rescue mode: %s') % instance.name
raise exception.NovaException(msg)
self.spawn(context, instance, image_meta, [], rescue_password,
network_info, name_label=rescue_name_label, rescue=True)

59
nclxd/nova/virt/lxd/container_snapshot.py
View File

@ -1,24 +1,40 @@
# Copyright 2011 Justin Santa Barbara
# Copyright 2015 Canonical Ltd
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.from oslo_config import cfg
from oslo_config import cfg
from oslo_log import log as logging
from pylxd import api
from nova.compute import task_states
from nova import image
from nova import exception
from nova import utils
from pylxd import api
from pylxd import exceptions as lxd_exceptions
from nova.i18n import _
from nova import i18n
from nova import image
import container_utils
_ = i18n._
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
IMAGE_API = image.API()
class LXDSnapshot(object):
def __init__(self):
self.container_utils = container_utils.LXDContainerUtils()
self.lxd = api.API()
@ -26,9 +42,6 @@ class LXDSnapshot(object):
def snapshot(self, context, instance, image_id, update_task_state):
LOG.debug('in snapshot')
update_task_state(task_state=task_states.IMAGE_PENDING_UPLOAD)
image_meta = utils.get_image_from_system_metadata(
instance.system_metadata)
snapshot = IMAGE_API.get(context, image_id)
@ -38,7 +51,7 @@ class LXDSnapshot(object):
''' Publish the image to LXD '''
(state, data) = self.container_utils.container_stop(instance.name)
self.container_utils.wait_for_container(
data.get('operation').split('/')[3])
data.get('operation').split('/')[3])
fingerprint = self.create_lxd_image(snapshot, instance.name)
self.create_glance_image(context, image_id, snapshot, fingerprint)
@ -46,29 +59,29 @@ class LXDSnapshot(object):
expected_state=task_states.IMAGE_PENDING_UPLOAD)
(state, data) = self.container_utils.container_start(instance.name)
self.container_utils.wait_for_container(
data.get('operation').split('/')[3])
data.get('operation').split('/')[3])
def create_container_snapshot(self, snapshot, instance_name):
LOG.debug('Creating container snapshot')
container_snapshot = {'name': snapshot['name'],
'stateful': False}
'stateful': False}
(state, data) = self.lxd.container_snapshot_create(instance_name,
container_snapshot)
container_snapshot)
self.container_utils.wait_for_container(
data.get('operation').split('/')[3])
data.get('operation').split('/')[3])
def create_lxd_image(self, snapshot, instance_name):
LOG.debug('Uploading image to LXD image store.')
container_image = {
'source': {
'name': '%s/%s' % (instance_name,
snapshot['name']),
'type': 'snapshot'
}
}
'source': {
'name': '%s/%s' % (instance_name,
snapshot['name']),
'type': 'snapshot'
}
}
LOG.debug(container_image)
(state, data) = self.lxd.container_publish(container_image)
LOG.debug('Creating LXD alias')
fingerprint = str(data['metadata']['fingerprint'])
snapshot_alias = {'name': snapshot['name'],
@ -87,5 +100,5 @@ class LXDSnapshot(object):
data = self.lxd.image_export(fingerprint)
IMAGE_API.update(context, image_id, image_metadata, data)
except Exception as ex:
msg = _("Failed: %s" % ex)
msg = _("Failed: %s") % ex
raise exception.NovaException(msg)

45
nclxd/nova/virt/lxd/container_utils.py
View File

@ -19,13 +19,14 @@ import shutil
from oslo_config import cfg
from oslo_log import log as logging
from pylxd import api
from pylxd import exceptions as lxd_exceptions
from nova.i18n import _
from nova import exception
from nova.compute import power_state
from nova import exception
from nova import i18n
_ = i18n._
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
@ -94,9 +95,9 @@ class LXDContainerUtils(object):
def init_lxd_host(self, host):
LOG.debug('Host check')
try:
if not CONF.lxd.lxd_default_profile in self.lxd.profile_list():
msg = _('Default LXD profile is not available - %s'
% CONF.lxd.lxd_default_profile)
if CONF.lxd.lxd_default_profile not in self.lxd.profile_list():
msg = (_('Default LXD profile is not available - %s')
% CONF.lxd.lxd_default_profile)
raise exception.HostNotFound(msg)
if not self.lxd.host_ping():
@ -105,26 +106,16 @@ class LXDContainerUtils(object):
return True
except lxd_exceptions.APIError as ex:
msg = _('Unable to connect to LXD daemon: %s' % ex)
msg = _('Unable to connect to LXD daemon: %s') % ex
exception.HostNotFound(msg)
def list_containers(self):
try:
return self.lxd.container_list()
except lxd_exceptions.APIError as ex:
msg = _('Unable to list instances: %s' % ex)
msg = _('Unable to list instances: %s') % ex
exception.NovaException(msg)
def container_defined(self, instance):
LOG.debug('Container defined')
try:
self.lxd.container_defined(instance)
except lxd_exceptions.APIError as ex:
if ex.status_code == 404:
return False
else:
return True
def container_running(self, instance):
LOG.debug('container running')
if self.lxd.container_running(instance):
@ -138,7 +129,7 @@ class LXDContainerUtils(object):
return self.lxd.container_start(instance,
CONF.lxd.lxd_timeout)
except lxd_exceptions.APIError as ex:
msg = _('Failed to start container: %s' % ex)
msg = _('Failed to start container: %s') % ex
raise exception.NovaException(msg)
def container_stop(self, instance):
@ -150,7 +141,7 @@ class LXDContainerUtils(object):
if ex.status_code == 404:
return
else:
msg = _('Failed to stop container: %s' % ex)
msg = _('Failed to stop container: %s') % ex
raise exception.NovaException(msg)
def container_pause(self, instance):
@ -162,7 +153,7 @@ class LXDContainerUtils(object):
if ex.status_code == 404:
return
else:
msg = _('Failed to pause container: %s' % ex)
msg = _('Failed to pause container: %s') % ex
raise exception.NovaException(msg)
def container_unpause(self, instance):
@ -174,7 +165,7 @@ class LXDContainerUtils(object):
if ex.status_code == 404:
return
else:
msg = _('Failed to unpause container: %s' % ex)
msg = _('Failed to unpause container: %s') % ex
raise exception.NovaException(msg)
def container_destroy(self, instance):
@ -185,7 +176,7 @@ class LXDContainerUtils(object):
if ex.status_code == 404:
return
else:
msg = _('Failed to destroy container: %s' % ex)
msg = _('Failed to destroy container: %s') % ex
raise exception.NovaException(msg)
def container_cleanup(self, instance, network_info, block_device_info):
@ -208,7 +199,7 @@ class LXDContainerUtils(object):
try:
return self.lxd.container_init(container_config)
except lxd_exceptions.APIError as ex:
msg = _('Failed to destroy container: %s' % ex)
msg = _('Failed to destroy container: %s') % ex
raise exception.NovaException(msg)
def container_update(self, instance, config):
@ -216,7 +207,7 @@ class LXDContainerUtils(object):
try:
return self.lxd.container_update(instance, config)
except lxd_exceptions.APIError as ex:
msg = _('Failed to update container: %s' % ex)
msg = _('Failed to update container: %s') % ex
raise exception.NovaException(msg)
def container_defined(self, instance):
@ -233,10 +224,10 @@ class LXDContainerUtils(object):
try:
return self.lxd.container_reboot(instance)
except lxd_exceptions.APIError as ex:
if e.status_code == 404:
if ex.status_code == 404:
pass
else:
msg = _('Failed to reboot container: %s' % ex)
msg = _('Failed to reboot container: %s') % ex
raise exception.NovaException(msg)
def wait_for_container(self, oid):

27
nclxd/nova/virt/lxd/driver.py
View File

@ -19,13 +19,15 @@ import socket
from oslo_config import cfg
from oslo_log import log as logging
from nova.i18n import _
from nova import i18n
from nova.virt import driver
import container_ops
import container_snapshot
import host
_ = i18n._
lxd_opts = [
cfg.StrOpt('lxd_root_dir',
default='/var/lib/lxd/',
@ -34,8 +36,8 @@ lxd_opts = [
default=5,
help='Default LXD timeout'),
cfg.StrOpt('lxd_default_profile',
default='nclxd-profile',
help='Default LXD profile')
default='nclxd-profile',
help='Default LXD profile')
]
CONF = cfg.CONF
@ -44,9 +46,7 @@ LOG = logging.getLogger(__name__)
class LXDDriver(driver.ComputeDriver):
""" LXD Lightervisor
"""
"""LXD Lightervisor."""
capabilities = {
"has_imagecache": False,
@ -85,8 +85,8 @@ class LXDDriver(driver.ComputeDriver):
def spawn(self, context, instance, image_meta, injected_files,
admin_password, network_info=None, block_device_info=None):
return self.container_ops.spawn(context, instance, image_meta,
injected_files, admin_password, network_info,
block_device_info)
injected_files, admin_password,
network_info, block_device_info)
def destroy(self, context, instance, network_info, block_device_info=None,
destroy_disks=True, migrate_data=None):
@ -105,7 +105,7 @@ class LXDDriver(driver.ComputeDriver):
block_device_info=None, bad_volumes_callback=None):
return self.container_ops.reboot(context, instance, network_info,
reboot_type, block_device_info,
bad - volumes_callback)
bad_volumes_callback)
def get_console_output(self, context, instance):
return self.container_ops.get_console_output(context, instance)
@ -147,7 +147,7 @@ class LXDDriver(driver.ComputeDriver):
def snapshot(self, context, instance, image_id, update_task_state):
return self.container_snapshot.snapshot(context, instance, image_id,
update_task_state)
update_task_state)
def post_interrupted_snapshot_cleanup(self, context, instance):
pass
@ -178,14 +178,15 @@ class LXDDriver(driver.ComputeDriver):
def rescue(self, context, instance, network_info, image_meta,
rescue_password):
return self.container_ops.rescue(context, instance, network_info, image_meta,
rescue_password)
return self.container_ops.rescue(context, instance, network_info,
image_meta, rescue_password)
def unrescue(self, instance, network_info):
return self.container_ops.unrescue(instance, network_info)
def power_off(self, instance, timeout=0, retry_interval=0):
return self.container_ops.power_off(instance, timeout=0, retry_interval=0)
return self.container_ops.power_off(instance, timeout=0,
retry_interval=0)
def power_on(self, context, instance, network_info,
block_device_info=None):

22
nclxd/nova/virt/lxd/host.py
View File

@ -30,13 +30,15 @@ from nova.compute import arch
from nova.compute import hv_type
from nova.compute import utils as compute_utils
from nova.compute import vm_mode
from nova.i18n import _LW, _
from nova import exception
from nova import i18n
from nova import utils
from pylxd import api
import psutil
from pylxd import api
_ = i18n._
_LW = i18n._LW
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
@ -90,7 +92,8 @@ class LXDHost(object):
return out
def _get_fs_info(self, path):
"""get free/used/total space info for a filesystem
"""Get free/used/total space info for a filesystem
:param path: Any dirent on the filesystem
:returns: A dict containing
:free: How much space is free (in bytes)
@ -107,7 +110,8 @@ class LXDHost(object):
def _get_memory_mb_usage(self):
"""Get the used memory size(MB) of the host.
"returns: the total usage of memory(MB)
:returns: the total usage of memory(MB)
"""
with open('/proc/meminfo') as fp:
@ -144,7 +148,7 @@ class LXDHost(object):
return cpu_info
def _get_cpu_info(self):
''' Parse the output of lscpu. '''
'''Parse the output of lscpu.'''
cpuinfo = {}
out, err = utils.execute('lscpu')
if err:
@ -175,9 +179,9 @@ class LXDHost(object):
def get_host_cpu_stats(self):
return {
'kernel': long(psutil.cpu_times()[2]),
'idle': long(psutil.cpu_times()[3]),
'user': long(psutil.cpu_times()[0]),
'iowait': long(psutil.cpu_times()[4]),
'kernel': int(psutil.cpu_times()[2]),
'idle': int(psutil.cpu_times()[3]),
'user': int(psutil.cpu_times()[0]),
'iowait': int(psutil.cpu_times()[4]),
'frequency': self.host_cpu_info['hz_advertised']
}

13
nclxd/nova/virt/lxd/vif.py
View File

@ -16,13 +16,14 @@ from oslo_concurrency import processutils
from oslo_config import cfg
from oslo_log import log as logging
from nova.i18n import _LE, _
from nova import exception
from nova import i18n
from nova.network import linux_net
from nova.network import model as network_model
from nova import utils
_ = i18n._
_LE = i18n._LE
CONF = cfg.CONF
@ -124,8 +125,8 @@ class LXDNetworkBridgeDriver(object):
if (not network.get_meta('multi_host', False) and
network.get_meta('should_create_bridge', False)):
if network.get_meta('should_create_vlan', False):
iface = CONF.vlan_interface or \
network.get_meta('bridge_interface')
iface = (CONF.vlan_interface or
network.get_meta('bridge_interface'))
LOG.debug('Ensuring vlan %(vlan)s and bridge %(bridge)s',
{'vlan': network.get_meta('vlan'),
'bridge': vif['network']['bridge']},
@ -135,8 +136,8 @@ class LXDNetworkBridgeDriver(object):
vif['network']['bridge'],
iface)
else:
iface = CONF.flat_interface or \
network.get_meta('bridge_interface')
iface = (CONF.flat_interface or
network.get_meta('bridge_interface'))
LOG.debug("Ensuring bridge %s",
vif['network']['bridge'], instance=instance)
linux_net.LinuxBridgeInterfaceDriver.ensure_bridge(

29
nclxd/tests/test_container_config.py
View File

@ -1,24 +1,29 @@
import contextlib
import platform
import mock
# Copyright 2015 Canonical Ltd
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from nova import context
from nova import test
from nova.virt import fake
from nova.tests.unit import fake_network
from nova.tests.unit import fake_instance
from nclxd.nova.virt.lxd import driver
from nova import exception
from nova import utils
from nclxd.nova.virt.lxd import container_config
CONF = cfg.CONF
class LXDTestContainerConfig(test.NoDBTestCase):
def setUp(self):
super(LXDTestContainerConfig, self).setUp()
self.container_config = container_config.LXDContainerConfig()
self.container_config = container_config.LXDContainerConfig()

31
nclxd/tests/test_container_ops.py
View File

@ -1,23 +1,26 @@
import contextlib
import platform
import mock
# Copyright 2015 Canonical Ltd
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from nova import context
from nova import test
from nova.virt import fake
from nova.tests.unit import fake_network
from nova.tests.unit import fake_instance
from nclxd.nova.virt.lxd import driver
from nova import exception
from nova import utils
from nclxd.nova.virt.lxd import container_ops
CONF = cfg.CONF
class LXDTestContainerOps(test.NoDBTestCase):
def setUp(self):
super(LXDTestContainerOps, self).setUp()
super(LXDTestContainerOps, self).setUp()

69
nclxd/tests/test_container_utils.py
View File

@ -1,20 +1,36 @@
import os
import mock
import shutil
# Copyright 2015 Canonical Ltd
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import os
import mock
from oslo_config import cfg
import pylxd
from nova import test
from nova.compute import power_state
from nova import test
from nova.tests.unit import fake_instance
import pylxd
from nclxd.nova.virt.lxd import container_utils
CONF = cfg.CONF
class LXDTestContainerDirectory(test.NoDBTestCase):
def setUp(self):
super(LXDTestContainerDirectory, self).setUp()
self.container_dir = container_utils.LXDContainerDirectories()
@ -25,27 +41,19 @@ class LXDTestContainerDirectory(test.NoDBTestCase):
CONF.image_cache_subdirectory_name)
self.assertEqual(expected_path, path)
def test_get_container_dir(self):
instance = fake_instance.fake_instance_obj(None, name='fake_inst',
uuid='fake_uuid')
path = self.container_dir.get_container_dir(instance.uuid)
expected_path = os.path.join(CONF.instances_path,
instance.uuid)
self.assertEqual(expected_path, path)
def test_get_container_image(self):
image_meta = {
'name': 'fake_image'
}
path = self.container_dir.get_container_image(image_meta)
expected_path = os.path.join(CONF.instances_path,
CONF.image_cache_subdirectory_name,
'%s.tar.gz' % image_meta.get('name'))
CONF.image_cache_subdirectory_name,
'%s.tar.gz' % image_meta.get('name'))
self.assertEqual(expected_path, path)
def test_get_container_configdrive(self):
instance = fake_instance.fake_instance_obj(None, name='fake_inst',
uuid='fake_uuid')
uuid='fake_uuid')
path = self.container_dir.get_container_configdirve(instance.uuid)
expected_path = os.path.join(CONF.instances_path,
instance.uuid,
@ -54,17 +62,17 @@ class LXDTestContainerDirectory(test.NoDBTestCase):
def test_get_console_path(self):
instance = fake_instance.fake_instance_obj(None, name='fake_inst',
uuid='fake_uuid')
uuid='fake_uuid')
path = self.container_dir.get_console_path(instance.uuid)
expected_path = os.path.join(CONF.lxd.lxd_root_dir,
'lxc',
instance.uuid,
'console.log')
instance.uuid,
'console.log')
self.assertEqual(expected_path, path)
def test_get_container_dir(self):
instance = fake_instance.fake_instance_obj(None, name='fake_inst',
uuid='fake_uuid')
uuid='fake_uuid')
path = self.container_dir.get_container_dir(instance.uuid)
expected_path = os.path.join(CONF.lxd.lxd_root_dir,
'lxc',
@ -73,7 +81,7 @@ class LXDTestContainerDirectory(test.NoDBTestCase):
def test_get_container_rootfs(self):
instance = fake_instance.fake_instance_obj(None, name='fake_inst',
uuid='fake_uuid')
uuid='fake_uuid')
path = self.container_dir.get_container_rootfs(instance.uuid)
expected_path = os.path.join(CONF.lxd.lxd_root_dir,
'lxc',
@ -81,7 +89,9 @@ class LXDTestContainerDirectory(test.NoDBTestCase):
'rootfs')
self.assertEqual(expected_path, path)
class LXDTestContainerUtils(test.NoDBTestCase):
def setUp(self):
super(LXDTestContainerUtils, self).setUp()
self.container_utils = container_utils.LXDContainerUtils()
@ -96,35 +106,34 @@ class LXDTestContainerUtils(test.NoDBTestCase):
@mock.patch.object(pylxd.api.API, 'container_list')
def test_container_list(self, mock_container_list):
mock_container_list.return_value = ['instance-0001',
'instance-0002']
'instance-0002']
self.assertEqual(len(self.container_utils.list_containers()), 2)
@mock.patch.object(pylxd.api.API, 'container_start')
def test_container_start(self, mock_container_start):
mock_container_start.return_value = True
instance = fake_instance.fake_instance_obj(None, name='fake_inst',
uuid='fake_uuid')
uuid='fake_uuid')
self.assertTrue(self.container_utils.container_start(instance))
@mock.patch.object(pylxd.api.API, 'container_destroy')
def test_container_destroy(self, mock_container_destroy):
mock_container_destroy.return_value = True
instance = fake_instance.fake_instance_obj(None, name='fake_inst',
uuid='fake_uuid')
uuid='fake_uuid')
self.assertTrue(self.container_utils.container_destroy(instance))
@mock.patch.object(pylxd.api.API, 'container_reboot')
def test_container_reboot(self, mock_container_reboot):
mock_container_reboot.return_value = True
instance = fake_instance.fake_instance_obj(None, name='fake_inst',
uuid='fake_uuid')
uuid='fake_uuid')
self.assertTrue(self.container_utils.container_reboot(instance))
@mock.patch.object(pylxd.api.API, 'container_state')
def test_container_info(self, mock_container_state):
mock_container_state.return_value = 'RUNNING'
instance = fake_instance.fake_instance_obj(None, name='fake_inst',
uuid='fake_uuid')
self.assertTrue(self.container_utils.container_info(instance), power_state.RUNNING)
uuid='fake_uuid')
self.assertTrue(self.container_utils.container_info(instance),
power_state.RUNNING)

34
nclxd/tests/test_driver_api.py
View File

@ -1,26 +1,30 @@
import contextlib
import platform
import mock
# Copyright 2015 Canonical Ltd
# All Rights Reserved.
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
from oslo_config import cfg
from nova import context
from nova import test
from nova.virt import fake
from nova.tests.unit import fake_network
from nova.tests.unit import fake_instance
from nclxd.nova.virt.lxd import driver
from nova import exception
from nova import utils
from nclxd.nova.virt.lxd import container_ops
from nclxd.nova.virt.lxd import driver
CONF = cfg.CONF
class LXDTestDriver(test.NoDBTestCase):
def setUp(self):
super(LXDTestDriver, self).setUp()
self.connection = driver.LXDDriver(fake.FakeVirtAPI())
@ -28,5 +32,5 @@ class LXDTestDriver(test.NoDBTestCase):
def test_capabilities(self):
self.assertFalse(self.connection.capabilities['has_imagecache'])
self.assertFalse(self.connection.capabilities['supports_recreate'])
self.assertFalse(self.connection.capabilities[
'supports_migrate_to_same_host'])
self.assertFalse(
self.connection.capabilities['supports_migrate_to_same_host'])

12
tools/config/analyze_opts.py
View File

@ -26,11 +26,13 @@ import argparse
import os
import sys
sys.path.append(os.getcwd())
from oslo.config import iniparser
sys.path.append(os.getcwd())
class PropertyCollecter(iniparser.BaseParser):
def __init__(self):
super(PropertyCollecter, self).__init__()
self.key_value_pairs = {}
@ -62,11 +64,11 @@ if __name__ == '__main__':
parser.add_argument('-c', action='store',
default='/etc/nova/nova.conf',
help='path to nova.conf\
(defaults to /etc/nova/nova.conf)')
help='path to nova.conf'
' (defaults to /etc/nova/nova.conf)')
parser.add_argument('-s', default='./etc/nova/nova.conf.sample',
help='path to nova.conf.sample\
(defaults to ./etc/nova/nova.conf.sample')
help='path to nova.conf.sample'
' (defaults to ./etc/nova/nova.conf.sample')
options = parser.parse_args()
conf_file_options = PropertyCollecter.collect_properties(open(options.c))

20
tools/db/schema_diff.py
View File

@ -45,12 +45,12 @@ from __future__ import print_function
import datetime
import glob
from nova import i18n
import os
import subprocess
import sys
from nova.i18n import _
_ = i18n._
# Dump
@ -90,6 +90,7 @@ def diff_files(filename1, filename2):
class Mysql(object):
def create(self, name):
subprocess.check_call(['mysqladmin', '-u', 'root', 'create', name])
@ -98,12 +99,13 @@ class Mysql(object):
def dump(self, name, dump_filename):
subprocess.check_call(
'mysqldump -u root %(name)s > %(dump_filename)s'
% {'name': name, 'dump_filename': dump_filename},
shell=True)
'mysqldump -u root %(name)s > %(dump_filename)s'
% {'name': name, 'dump_filename': dump_filename},
shell=True)
class Postgresql(object):
def create(self, name):
subprocess.check_call(['createdb', name])
@ -112,9 +114,9 @@ class Postgresql(object):
def dump(self, name, dump_filename):
subprocess.check_call(
'pg_dump %(name)s > %(dump_filename)s'
% {'name': name, 'dump_filename': dump_filename},
shell=True)
'pg_dump %(name)s > %(dump_filename)s'
% {'name': name, 'dump_filename': dump_filename},
shell=True)
def _get_db_driver_class(db_url):
@ -136,7 +138,7 @@ def _migrate(db_url, migration_version):
# NOTE(sirp): sqlalchemy-migrate currently cannot handle the skipping of
# migration numbers.
_migrate_cmd(
db_url, 'version_control', str(earliest_version - 1))
db_url, 'version_control', str(earliest_version - 1))
upgrade_cmd = ['upgrade']
if migration_version != 'latest':

2
tools/install_venv.py
View File

@ -61,7 +61,7 @@ def main(argv):
py_version = "python%s.%s" % (sys.version_info[0], sys.version_info[1])
project = 'Nova'
install = install_venv.InstallVenv(root, venv, pip_requires, test_requires,
py_version, project)
py_version, project)
options = install.parse_args(argv)
install.check_python_version()
install.check_dependencies()

4
tools/regression_tester.py
View File

@ -62,8 +62,8 @@ def main():
original_branch = run("git rev-parse --abbrev-ref HEAD")
run("git review -d %s" % options.review)
else:
print ("no gerrit review number specified, running on latest commit"
"on current branch.")
print("no gerrit review number specified, running on latest commit"
"on current branch.")
test_works = False

4
tox.ini
View File

@ -1,6 +1,6 @@
[tox]
minversion = 1.6
envlist = py26,py27,py33,pypy,pep8
envlist = py27,py34,pep8
skipsdist = True
[testenv]
@ -33,4 +33,4 @@ commands = python setup.py build_sphinx
show-source = True
ignore = E123,E125,H803
builtins = _
exclude=.venv,.git,.tox,dist,doc,*openstack/common*,*lib/python*,*egg,build
exclude=.venv,.git,.tox,dist,doc,*openstack/common*,*lib/python*,*egg,build,tools/colorizer.py