def wrapped_func(*args, **kwarg):
if fn.__name__ == 'create':
LOG = logging.getLogger(fn.__module__)
try:
idx_svol = inspect.getargspec(fn).args.index("source_volume")
idx_voltp = inspect.getargspec(fn).args.index("volume_type")
except Exception as e:
LOG.error(_("cinder volume_create interface has been changed. "
"PowerVC monkey patch for volume clone won't work."
" function: %(fx)s, arguments: %(args)s") %
dict(fx=fn.__module__,
args=inspect.getargspec(fn).args))
raise e
svol = kwarg.get('source_volume')
voltp = kwarg.get('volume_type')
if svol and voltp:
if svol['volume_type_id'] != voltp['id']:
# this is the condition that will trigger the
# volume clone to fail. Patch it here.
svol['volume_type_id'] = voltp['id']
LOG.info(_("Monkey patched volume clone by paxes "
"volume_create_decorator(). Source Volume ID: "
"%(svol)s, volume type name: %(voltpnm)s, "
"volume type ID: %(voltpid)s") %
dict(svol=svol['id'],
voltpnm=voltp['name'],
voltpid=voltp['id']))
return fn(*args, **kwarg)
return fn(*args, **kwarg)
def __init__(self, name, app, host=None, port=None, pool_size=None,
protocol=eventlet.wsgi.HttpProtocol, backlog=128):
"""Initialize, but do not start, a WSGI server.
:param name: Pretty name for logging.
:param app: The WSGI application to serve.
:param host: IP address to serve the application.
:param port: Port number to server the application.
:param pool_size: Maximum number of eventlets to spawn concurrently.
:returns: None
"""
# Allow operators to customize http requests max header line size.
eventlet.wsgi.MAX_HEADER_LINE = CONF.max_header_line
self.name = name
self.app = app
self._host = host or "0.0.0.0"
self._port = port or 0
self._server = None
self._socket = None
self._protocol = protocol
self._pool = eventlet.GreenPool(pool_size or self.default_pool_size)
self._logger = logging.getLogger("eventlet.wsgi.server")
self._wsgi_logger = logging.WritableLogger(self._logger)
if backlog < 1:
raise exception.InvalidInput(
reason='The backlog must be more than 1')
self._socket = self._get_socket(self._host,
self._port,
backlog=backlog)
def notify(_context, message):
"""Notifies the recipient of the desired event given the model.
Log notifications using openstack's default logging system"""
priority = message.get("priority", CONF.default_notification_level)
priority = priority.lower()
logger = logging.getLogger("openstack.common.notification.%s" % message["event_type"])
getattr(logger, priority)(json.dumps(message))
def notify(message):
"""Notifies the recipient of the desired event given the model.
Log notifications using cinder's default logging system"""
priority = message.get('priority',
FLAGS.default_notification_level)
priority = priority.lower()
logger = logging.getLogger(
'cinder.notification.%s' % message['event_type'])
getattr(logger, priority)(jsonutils.dumps(message))
def notify(_context, message):
"""Notifies the recipient of the desired event given the model.
Log notifications using OpenStack's default logging system.
"""
priority = message.get('priority',
CONF.default_notification_level)
priority = priority.lower()
logger = logging.getLogger(
'cinder.openstack.common.notification.%s' %
message['event_type'])
getattr(logger, priority)(jsonutils.dumps(message))
def setUp(self):
super(DriverTestCase, self).setUp()
self.flags(volume_driver=self.driver_name,
logging_default_format_string="%(message)s")
self.volume = importutils.import_object(FLAGS.volume_manager)
self.context = context.get_admin_context()
self.output = ""
def _fake_execute(_command, *_args, **_kwargs):
"""Fake _execute."""
return self.output, None
self.volume.driver.set_execute(_fake_execute)
log = logging.getLogger()
self.stream = cStringIO.StringIO()
log.logger.addHandler(logging.logging.StreamHandler(self.stream))
def test_error_notification(self):
self.stubs.Set(cinder.flags.FLAGS, 'notification_driver',
'cinder.notifier.rabbit_notifier')
self.stubs.Set(cinder.flags.FLAGS, 'publish_errors', True)
LOG = logging.getLogger('cinder')
logging.setup("cinder")
msgs = []
def mock_notify(context, topic, data):
msgs.append(data)
self.stubs.Set(cinder.openstack.common.rpc, 'notify', mock_notify)
LOG.error('foo')
self.assertEqual(1, len(msgs))
msg = msgs[0]
self.assertEqual(msg['event_type'], 'error_notification')
self.assertEqual(msg['priority'], 'ERROR')
self.assertEqual(msg['payload']['error'], 'foo')
def wrapped_func(*args, **kwarg):
if fn.__name__ == 'create':
# cinder.volume.volume_types.create() decorator
r = fn(*args, **kwarg)
LOG = logging.getLogger(fn.__module__)
try:
idx_specs = inspect.getargspec(fn).args.index('extra_specs')
idx_name = inspect.getargspec(fn).args.index('name')
idx_ctxt = inspect.getargspec(fn).args.index('context')
except Exception as e:
LOG.warn(_("Failed to get the parameters from function "
"cinder.volume.volume_types.create(). Default "
"quota didn't set for the storage template. "
"Error: %(err)s") % dict(err=e))
# Just return. Don't set the storage template default quota.
return r
volume_type = args[idx_name]
extra_specs = args[idx_specs]
ctxt = args[idx_ctxt]
volume_host = None
if extra_specs and isinstance(extra_specs, dict):
volume_host = extra_specs.get(
"capabilities:volume_backend_name", None)
if volume_host and volume_type and ctxt:
volume_rpcapi = volume_rpc.VolumeAPIProduct()
try:
volume_rpcapi.set_volume_type_quota(
ctxt, volume_host, volume_type)
LOG.info(_("Successfully set default quota for storage "
"template %(vol_type)s") %
dict(vol_type=volume_type))
except Exception as e:
LOG.warn(_("Failed to set default quota for storage "
"template %(vol_type)s, error: %(err)s") %
dict(vol_type=volume_type, err=e))
else:
LOG.warn(_("Cannot set default quota for storage template "
"%(vol_type)s due to invalid Parameters from volume "
"type create.") % dict(vol_type=volume_type))
return r
else:
return fn(*args, **kwarg)
def main():
CONF(sys.argv[1:], project='cinder',
version=version.version_string())
logging.setup("cinder")
LOG = logging.getLogger('cinder.all')
utils.monkey_patch()
launcher = service.process_launcher()
# cinder-api
try:
server = service.WSGIService('osapi_volume')
launcher.launch_service(server, workers=server.workers or 1)
except (Exception, SystemExit):
LOG.exception(_LE('Failed to load osapi_volume'))
for binary in ['cinder-volume', 'cinder-scheduler', 'cinder-backup']:
try:
launcher.launch_service(service.Service.create(binary=binary))
except (Exception, SystemExit):
LOG.exception(_LE('Failed to load %s'), binary)
launcher.wait()
def __init__(self, name, app, host=None, port=None, pool_size=None, protocol=eventlet.wsgi.HttpProtocol):
"""Initialize, but do not start, a WSGI server.
:param name: Pretty name for logging.
:param app: The WSGI application to serve.
:param host: IP address to serve the application.
:param port: Port number to server the application.
:param pool_size: Maximum number of eventlets to spawn concurrently.
:returns: None
"""
self.name = name
self.app = app
self._host = host or "0.0.0.0"
self._port = port or 0
self._server = None
self._socket = None
self._protocol = protocol
self._pool = eventlet.GreenPool(pool_size or self.default_pool_size)
self._logger = logging.getLogger("eventlet.wsgi.server")
self._wsgi_logger = logging.WritableLogger(self._logger)
def test_create_consistencygroup_exceptions(self):
with mock.patch.object(filter_scheduler.FilterScheduler,
'schedule_create_consistencygroup') as mock_cg:
original_driver = self.manager.driver
self.manager.driver = filter_scheduler.FilterScheduler
LOG = logging.getLogger('cinder.scheduler.manager')
self.stubs.Set(LOG, 'error', mock.Mock())
self.stubs.Set(LOG, 'exception', mock.Mock())
self.stubs.Set(db, 'consistencygroup_update', mock.Mock())
ex = exception.CinderException('test')
mock_cg.side_effect = ex
group_id = '1'
self.assertRaises(exception.CinderException,
self.manager.create_consistencygroup,
self.context,
'volume',
group_id)
LOG.exception.assert_called_once_with(_(
"Failed to create consistency group "
"%(group_id)s."), {'group_id': group_id})
db.consistencygroup_update.assert_called_once_with(
self.context, group_id, {'status': 'error'})
mock_cg.reset_mock()
LOG.exception.reset_mock()
db.consistencygroup_update.reset_mock()
mock_cg.side_effect = exception.NoValidHost(
reason="No weighed hosts available")
self.manager.create_consistencygroup(
self.context, 'volume', group_id)
LOG.error.assert_called_once_with(_(
"Could not find a host for consistency group "
"%(group_id)s.") % {'group_id': group_id})
db.consistencygroup_update.assert_called_once_with(
self.context, group_id, {'status': 'error'})
self.manager.driver = original_driver
def setUp(self):
super(NotifierListTestCase, self).setUp()
list_notifier._reset_drivers()
# Mock log to add one to exception_count when log.exception is called
def mock_exception(cls, *args):
self.exception_count += 1
self.exception_count = 0
list_notifier_log = logging.getLogger('cinder.notifier.list_notifier')
self.stubs.Set(list_notifier_log, "exception", mock_exception)
# Mock no_op notifier to add one to notify_count when called.
def mock_notify(cls, *args):
self.notify_count += 1
self.notify_count = 0
self.stubs.Set(cinder.notifier.no_op_notifier, 'notify', mock_notify)
# Mock log_notifier to raise RuntimeError when called.
def mock_notify2(cls, *args):
raise RuntimeError("Bad notifier.")
self.stubs.Set(cinder.notifier.log_notifier, 'notify', mock_notify2)
def log_level(self, level):
"""Set logging level to the specified value."""
log_root = logging.getLogger(None).logger
log_root.setLevel(level)
def __init__(self,
name,
app,
host=None,
port=None,
pool_size=None,
protocol=eventlet.wsgi.HttpProtocol,
backlog=128):
"""Initialize, but do not start, a WSGI server.
:param name: Pretty name for logging.
:param app: The WSGI application to serve.
:param host: IP address to serve the application.
:param port: Port number to server the application.
:param pool_size: Maximum number of eventlets to spawn concurrently.
:returns: None
"""
# Allow operators to customize http requests max header line size.
eventlet.wsgi.MAX_HEADER_LINE = CONF.max_header_line
self.name = name
self.app = app
self._host = host or "0.0.0.0"
self._port = port or 0
self._server = None
self._socket = None
self._protocol = protocol
self.pool_size = pool_size or self.default_pool_size
self._pool = eventlet.GreenPool(self.pool_size)
self._logger = logging.getLogger("eventlet.wsgi.server")
self._wsgi_logger = logging.WritableLogger(self._logger)
if backlog < 1:
raise exception.InvalidInput(
reason='The backlog must be more than 1')
bind_addr = (host, port)
# TODO(dims): eventlet's green dns/socket module does not actually
# support IPv6 in getaddrinfo(). We need to get around this in the
# future or monitor upstream for a fix
try:
info = socket.getaddrinfo(bind_addr[0], bind_addr[1],
socket.AF_UNSPEC, socket.SOCK_STREAM)[0]
family = info[0]
bind_addr = info[-1]
except Exception:
family = socket.AF_INET
cert_file = CONF.ssl_cert_file
key_file = CONF.ssl_key_file
ca_file = CONF.ssl_ca_file
self._use_ssl = cert_file or key_file
if cert_file and not os.path.exists(cert_file):
raise RuntimeError(_("Unable to find cert_file : %s") % cert_file)
if ca_file and not os.path.exists(ca_file):
raise RuntimeError(_("Unable to find ca_file : %s") % ca_file)
if key_file and not os.path.exists(key_file):
raise RuntimeError(_("Unable to find key_file : %s") % key_file)
if self._use_ssl and (not cert_file or not key_file):
raise RuntimeError(
_("When running server in SSL mode, you "
"must specify both a cert_file and "
"key_file option value in your "
"configuration file."))
retry_until = time.time() + 30
while not self._socket and time.time() < retry_until:
try:
self._socket = eventlet.listen(bind_addr,
backlog=backlog,
family=family)
except socket.error as err:
if err.args[0] != errno.EADDRINUSE:
raise
eventlet.sleep(0.1)
if not self._socket:
raise RuntimeError(
_("Could not bind to %(host)s:%(port)s "
"after trying for 30 seconds") % {
'host': host,
'port': port
})
(self._host, self._port) = self._socket.getsockname()[0:2]
LOG.info(
_("%(name)s listening on %(_host)s:%(_port)s") % self.__dict__)
def main():
admin_context = context.get_admin_context()
CONF(sys.argv[1:], project='cinder',
version=version.version_string())
logging.setup("cinder")
LOG = logging.getLogger("cinder")
rpc.init(CONF)
begin, end = utils.last_completed_audit_period()
if CONF.start_time:
begin = datetime.strptime(CONF.start_time, "%Y-%m-%d %H:%M:%S")
if CONF.end_time:
end = datetime.strptime(CONF.end_time, "%Y-%m-%d %H:%M:%S")
if not end > begin:
msg = _("The end time (%(end)s) must be after the start "
"time (%(start)s).") % {'start': begin,
'end': end}
print(msg)
LOG.error(msg)
sys.exit(-1)
print(_("Starting volume usage audit"))
msg = _("Creating usages for %(begin_period)s until %(end_period)s")
print(msg % {"begin_period": str(begin), "end_period": str(end)})
extra_info = {
'audit_period_beginning': str(begin),
'audit_period_ending': str(end),
}
volumes = db.volume_get_active_by_window(admin_context,
begin,
end)
print(_("Found %d volumes") % len(volumes))
for volume_ref in volumes:
try:
LOG.debug("Send exists notification for <volume_id: "
"%(volume_id)s> <project_id %(project_id)s> "
"<%(extra_info)s>" %
{'volume_id': volume_ref.id,
'project_id': volume_ref.project_id,
'extra_info': extra_info})
cinder.volume.utils.notify_about_volume_usage(
admin_context,
volume_ref,
'exists', extra_usage_info=extra_info)
except Exception as e:
LOG.error(_LE("Failed to send exists notification"
" for volume %s.") %
volume_ref.id)
print(traceback.format_exc(e))
if (CONF.send_actions and
volume_ref.created_at > begin and
volume_ref.created_at < end):
try:
local_extra_info = {
'audit_period_beginning': str(volume_ref.created_at),
'audit_period_ending': str(volume_ref.created_at),
}
LOG.debug("Send create notification for "
"<volume_id: %(volume_id)s> "
"<project_id %(project_id)s> <%(extra_info)s>" %
{'volume_id': volume_ref.id,
'project_id': volume_ref.project_id,
'extra_info': local_extra_info})
cinder.volume.utils.notify_about_volume_usage(
admin_context,
volume_ref,
'create.start', extra_usage_info=local_extra_info)
cinder.volume.utils.notify_about_volume_usage(
admin_context,
volume_ref,
'create.end', extra_usage_info=local_extra_info)
except Exception as e:
LOG.error(_LE("Failed to send create notification for "
"volume %s.") % volume_ref.id)
print(traceback.format_exc(e))
if (CONF.send_actions and volume_ref.deleted_at and
volume_ref.deleted_at > begin and
volume_ref.deleted_at < end):
try:
local_extra_info = {
'audit_period_beginning': str(volume_ref.deleted_at),
'audit_period_ending': str(volume_ref.deleted_at),
}
LOG.debug("Send delete notification for "
"<volume_id: %(volume_id)s> "
"<project_id %(project_id)s> <%(extra_info)s>" %
{'volume_id': volume_ref.id,
'project_id': volume_ref.project_id,
'extra_info': local_extra_info})
cinder.volume.utils.notify_about_volume_usage(
admin_context,
volume_ref,
'delete.start', extra_usage_info=local_extra_info)
cinder.volume.utils.notify_about_volume_usage(
admin_context,
volume_ref,
'delete.end', extra_usage_info=local_extra_info)
except Exception as e:
LOG.error(_LE("Failed to send delete notification for volume "
"%s.") % volume_ref.id)
print(traceback.format_exc(e))
snapshots = db.snapshot_get_active_by_window(admin_context,
begin,
end)
print(_("Found %d snapshots") % len(snapshots))
for snapshot_ref in snapshots:
try:
LOG.debug("Send notification for <snapshot_id: %(snapshot_id)s> "
"<project_id %(project_id)s> <%(extra_info)s>" %
{'snapshot_id': snapshot_ref.id,
'project_id': snapshot_ref.project_id,
'extra_info': extra_info})
cinder.volume.utils.notify_about_snapshot_usage(admin_context,
snapshot_ref,
'exists',
extra_info)
except Exception as e:
LOG.error(_LE("Failed to send exists notification "
"for snapshot %s.")
% snapshot_ref.id)
print(traceback.format_exc(e))
if (CONF.send_actions and
snapshot_ref.created_at > begin and
snapshot_ref.created_at < end):
try:
local_extra_info = {
'audit_period_beginning': str(snapshot_ref.created_at),
'audit_period_ending': str(snapshot_ref.created_at),
}
LOG.debug("Send create notification for "
"<snapshot_id: %(snapshot_id)s> "
"<project_id %(project_id)s> <%(extra_info)s>" %
{'snapshot_id': snapshot_ref.id,
'project_id': snapshot_ref.project_id,
'extra_info': local_extra_info})
cinder.volume.utils.notify_about_snapshot_usage(
admin_context,
snapshot_ref,
'create.start', extra_usage_info=local_extra_info)
cinder.volume.utils.notify_about_snapshot_usage(
admin_context,
snapshot_ref,
'create.end', extra_usage_info=local_extra_info)
except Exception as e:
LOG.error(_LE("Failed to send create notification for snapshot"
"%s.") % snapshot_ref.id)
print(traceback.format_exc(e))
if (CONF.send_actions and snapshot_ref.deleted_at and
snapshot_ref.deleted_at > begin and
snapshot_ref.deleted_at < end):
try:
local_extra_info = {
'audit_period_beginning': str(snapshot_ref.deleted_at),
'audit_period_ending': str(snapshot_ref.deleted_at),
}
LOG.debug("Send delete notification for "
"<snapshot_id: %(snapshot_id)s> "
"<project_id %(project_id)s> <%(extra_info)s>" %
{'snapshot_id': snapshot_ref.id,
'project_id': snapshot_ref.project_id,
'extra_info': local_extra_info})
cinder.volume.utils.notify_about_snapshot_usage(
admin_context,
snapshot_ref,
'delete.start', extra_usage_info=local_extra_info)
cinder.volume.utils.notify_about_snapshot_usage(
admin_context,
snapshot_ref,
'delete.end', extra_usage_info=local_extra_info)
except Exception as e:
LOG.error(_LE("Failed to send delete notification for snapshot"
"%s.") % snapshot_ref.id)
print(traceback.format_exc(e))
print(_("Volume usage audit completed"))
def __init__(self, name, app, host=None, port=None, pool_size=None,
protocol=eventlet.wsgi.HttpProtocol, backlog=128):
"""Initialize, but do not start, a WSGI server.
:param name: Pretty name for logging.
:param app: The WSGI application to serve.
:param host: IP address to serve the application.
:param port: Port number to server the application.
:param pool_size: Maximum number of eventlets to spawn concurrently.
:returns: None
"""
# Allow operators to customize http requests max header line size.
eventlet.wsgi.MAX_HEADER_LINE = CONF.max_header_line
self.name = name
self.app = app
self._host = host or "0.0.0.0"
self._port = port or 0
self._server = None
self._socket = None
self._protocol = protocol
self.pool_size = pool_size or self.default_pool_size
self._pool = eventlet.GreenPool(self.pool_size)
self._logger = logging.getLogger("eventlet.wsgi.server")
self._wsgi_logger = logging.WritableLogger(self._logger)
if backlog < 1:
raise exception.InvalidInput(
reason='The backlog must be more than 1')
bind_addr = (host, port)
# TODO(dims): eventlet's green dns/socket module does not actually
# support IPv6 in getaddrinfo(). We need to get around this in the
# future or monitor upstream for a fix
try:
info = socket.getaddrinfo(bind_addr[0],
bind_addr[1],
socket.AF_UNSPEC,
socket.SOCK_STREAM)[0]
family = info[0]
bind_addr = info[-1]
except Exception:
family = socket.AF_INET
cert_file = CONF.ssl_cert_file
key_file = CONF.ssl_key_file
ca_file = CONF.ssl_ca_file
self._use_ssl = cert_file or key_file
if cert_file and not os.path.exists(cert_file):
raise RuntimeError(_("Unable to find cert_file : %s")
% cert_file)
if ca_file and not os.path.exists(ca_file):
raise RuntimeError(_("Unable to find ca_file : %s") % ca_file)
if key_file and not os.path.exists(key_file):
raise RuntimeError(_("Unable to find key_file : %s")
% key_file)
if self._use_ssl and (not cert_file or not key_file):
raise RuntimeError(_("When running server in SSL mode, you "
"must specify both a cert_file and "
"key_file option value in your "
"configuration file."))
retry_until = time.time() + 30
while not self._socket and time.time() < retry_until:
try:
self._socket = eventlet.listen(bind_addr, backlog=backlog,
family=family)
except socket.error as err:
if err.args[0] != errno.EADDRINUSE:
raise
eventlet.sleep(0.1)
if not self._socket:
raise RuntimeError(_("Could not bind to %(host)s:%(port)s "
"after trying for 30 seconds") %
{'host': host, 'port': port})
(self._host, self._port) = self._socket.getsockname()[0:2]
LOG.info(_("%(name)s listening on %(_host)s:%(_port)s") %
{'name': self.name, '_host': self._host, '_port': self._port})
import os
import subprocess
import uuid
from migrate.versioning import repository
import six.moves.urllib.parse as urlparse
import sqlalchemy
import testtools
import cinder.db.migration as migration
import cinder.db.sqlalchemy.migrate_repo
from cinder.db.sqlalchemy.migration import versioning_api as migration_api
from cinder.openstack.common import log as logging
from cinder import test
LOG = logging.getLogger('cinder.tests.test_migrations')
def _get_connect_string(backend,
user="******",
passwd="openstack_citest",
database="openstack_citest"):
"""Return connect string.
Try to get a connection with a very specific set of values, if we get
these then we'll run the tests, otherwise they are skipped.
"""
if backend == "postgres":
backend = "postgresql+psycopg2"
return ("%(backend)s://%(user)s:%(passwd)s@localhost/%(database)s" %
# under the License.
"""
:mod:`nexenta.jsonrpc` -- Nexenta-specific JSON RPC client
=====================================================================
.. automodule:: nexenta.jsonrpc
.. moduleauthor:: Yuriy Taraday <*****@*****.**>
"""
import urllib2
from cinder.openstack.common import jsonutils
from cinder.volume import nexenta
from cinder.openstack.common import log as logging
LOG = logging.getLogger("cinder.volume.nexenta.jsonrpc")
class NexentaJSONException(nexenta.NexentaException):
pass
class NexentaJSONProxy(object):
def __init__(self, url, user, password, auto=False, obj=None, method=None):
self.url = url
self.user = user
self.password = password
self.auto = auto
self.obj = obj
self.method = method
# under the License.
"""
:mod:`nexenta.jsonrpc` -- Nexenta-specific JSON RPC client
=====================================================================
.. automodule:: nexenta.jsonrpc
.. moduleauthor:: Yuriy Taraday <*****@*****.**>
"""
import json
import urllib2
from cinder.volume import nexenta
from cinder.openstack.common import log as logging
LOG = logging.getLogger("cinder.volume.nexenta.jsonrpc")
class NexentaJSONException(nexenta.NexentaException):
pass
class NexentaJSONProxy(object):
def __init__(self, url, user, password, auto=False, obj=None, method=None):
self.url = url
self.user = user
self.password = password
self.auto = auto
self.obj = obj
self.method = method
pass
from cinder import db, quota, exception
from cinder.image import glance
from cinder.openstack.common import excutils
from cinder.openstack.common import timeutils, log as logging
from cinder.volume import volume_types
from cinder.context import get_admin_context
from lunr.cinder.client import LunrClient, LunrError
from lunr.cinder.utils import initialize_connection, terminate_connection, \
attach_volume, detach_volume
from lunr.cinder.flags import CONF
LOG = logging.getLogger('cinder.lunr.lunrrpc')
QUOTAS = quota.QUOTAS
class LunrRPC(object):
def __init__(self):
pass
def create_consumer(self, *args, **kwargs):
pass
def consume_in_thread(self, *args, **kwargs):
pass
def _get_volume_type_id(self, volume_type_name):
"""
import os
import sys
from cinder import exception
from cinder import flags
from cinder.openstack.common import cfg
from cinder.openstack.common import log as logging
from cinder.volume import driver
# Check needed for unit testing on Unix
if os.name == 'nt':
import wmi
LOG = logging.getLogger("cinder.volume.windows.volume")
FLAGS = flags.FLAGS
windows_opts = [
cfg.StrOpt('windows_iscsi_lun_path',
default='C:\iSCSIVirtualDisks',
help='Path to store VHD backed volumes'),
]
FLAGS.register_opts(windows_opts)
class WindowsDriver(driver.ISCSIDriver):
"""Executes volume driver commands on Windows Storage server."""
def __init__(self):
"""
import os
import sys
from cinder import exception
from cinder import flags
from cinder.openstack.common import cfg
from cinder.openstack.common import log as logging
from cinder.volume import driver
# Check needed for unit testing on Unix
if os.name == 'nt':
import wmi
LOG = logging.getLogger("cinder.volume.windows.volume")
FLAGS = flags.FLAGS
windows_opts = [
cfg.StrOpt('windows_iscsi_lun_path',
default='C:\iSCSIVirtualDisks',
help='Path to store VHD backed volumes'),
]
FLAGS.register_opts(windows_opts)
class WindowsDriver(driver.ISCSIDriver):
"""Executes volume driver commands on Windows Storage server."""
This driver requires VPSA with API ver.12.06 or higher.
"""
import httplib
from cinder import exception
from cinder import flags
from cinder.openstack.common import log as logging
from cinder.openstack.common import cfg
from cinder import utils
from cinder.volume import driver
from cinder.volume import iscsi
from lxml import etree
LOG = logging.getLogger("cinder.volume.driver")
zadara_opts = [
cfg.StrOpt('zadara_vpsa_ip',
default=None,
help='Management IP of Zadara VPSA'),
cfg.StrOpt('zadara_vpsa_port',
default=None,
help='Zadara VPSA port number'),
cfg.BoolOpt('zadara_vpsa_use_ssl',
default=False,
help='Use SSL connection'),
cfg.StrOpt('zadara_user', default=None, help='User name for the VPSA'),
cfg.StrOpt('zadara_password', default=None, help='Password for the VPSA'),
cfg.StrOpt('zadara_vpsa_poolname',
default=None,
import os
import subprocess
import urlparse
import uuid
from migrate.versioning import repository
import sqlalchemy
import testtools
import cinder.db.migration as migration
import cinder.db.sqlalchemy.migrate_repo
from cinder.db.sqlalchemy.migration import versioning_api as migration_api
from cinder.openstack.common import log as logging
from cinder import test
LOG = logging.getLogger('cinder.tests.test_migrations')
def _get_connect_string(backend,
user="******",
passwd="openstack_citest",
database="openstack_citest"):
"""Return connect string.
Try to get a connection with a very specific set of values, if we get
these then we'll run the tests, otherwise they are skipped.
"""
if backend == "postgres":
backend = "postgresql+psycopg2"
return ("%(backend)s://%(user)s:%(passwd)s@localhost/%(database)s" %
from cinder import flags
from cinder.openstack.common import cfg
from cinder.openstack.common import importutils
from cinder.openstack.common import log as logging
from cinder.volume.san import san
ibm_xiv_opts = [
cfg.StrOpt('xiv_proxy',
default='xiv_openstack.nova_proxy.XIVNovaProxy',
help='Proxy driver'),
]
FLAGS = flags.FLAGS
FLAGS.register_opts(ibm_xiv_opts)
LOG = logging.getLogger('cinder.volume.xiv')
class XIVDriver(san.SanISCSIDriver):
"""IBM XIV volume driver."""
def __init__(self, *args, **kwargs):
"""Initialize the driver."""
proxy = importutils.import_class(FLAGS.xiv_proxy)
self.xiv_proxy = proxy({
"xiv_user": FLAGS.san_login,
"xiv_pass": FLAGS.san_password,
"xiv_address": FLAGS.san_ip,
"xiv_vol_pool": FLAGS.san_clustername
import mock
import tempfile
from oslo.config import cfg
from cinder import context
from cinder import db
from cinder import exception
from cinder.openstack.common import importutils
from cinder.openstack.common import log as logging
from cinder.openstack.common import timeutils
from cinder import test
CONF = cfg.CONF
LOG = logging.getLogger(__name__)
class FakeBackupException(Exception):
pass
class BackupTestCase(test.TestCase):
"""Test Case for backups."""
def setUp(self):
super(BackupTestCase, self).setUp()
vol_tmpdir = tempfile.mkdtemp()
self.flags(volumes_dir=vol_tmpdir)
self.backup_mgr = \
importutils.import_object(CONF.backup_manager)
self.backup_mgr.host = 'testhost'
:mod:`nexenta.volume` -- Driver to store volumes on Nexenta Appliance
=====================================================================
.. automodule:: nexenta.volume
.. moduleauthor:: Yuriy Taraday <*****@*****.**>
"""
from cinder import exception
from cinder import flags
from cinder.openstack.common import log as logging
from cinder.openstack.common import cfg
from cinder.volume import driver
from cinder.volume import nexenta
from cinder.volume.nexenta import jsonrpc
LOG = logging.getLogger("cinder.volume.nexenta.volume")
FLAGS = flags.FLAGS
nexenta_opts = [
cfg.StrOpt('nexenta_host',
default='',
help='IP address of Nexenta SA'),
cfg.IntOpt('nexenta_rest_port',
default=2000,
help='HTTP port to connect to Nexenta REST API server'),
cfg.StrOpt('nexenta_rest_protocol',
default='auto',
help='Use http or https for REST connection (default auto)'),
cfg.StrOpt('nexenta_user',
default='admin',
help='User name to connect to Nexenta SA'),
"""
import time
import string
import re
from cinder import exception
from cinder import flags
from cinder.openstack.common import log as logging
from cinder.openstack.common import cfg
from cinder.volume import driver
from cinder.volume import volume_types
from cinder.volume import san
LOG = logging.getLogger("cinder.volume.driver")
netapp_direct_opts = [
cfg.StrOpt('netapp_direct_volpool_name',
default='vol0',
help='Storage system storage pool for volumes'),
cfg.StrOpt('netapp_direct_login',
default=None,
help='User name for the netapp system'),
cfg.StrOpt('netapp_direct_igroup_name',
default='openstack',
help='igroup name for the netapp system'),
cfg.StrOpt('netapp_direct_password',
default=None,
help='Password for the netapp system'),
cfg.StrOpt('netapp_direct_host',
from powervc.volume.driver import service
volume_driver_opts = [
# Ignore delete errors so an exception is not thrown during a
# delete. When set to true, this allows the volume to be deleted
# on the hosting OS even if an exception occurs. When set to false,
# exceptions during delete prevent the volume from being deleted
# on the hosting OS.
cfg.BoolOpt('volume_driver_ignore_delete_error', default=False)
]
CONF = config.CONF
CONF.register_opts(volume_driver_opts, group='powervc')
LOG = cinderLogging.getLogger(__name__)
def _load_power_config(argv):
"""
Loads the powervc config.
"""
# Cinder is typically started with the --config-file option.
# This prevents the default config files from loading since
# the olso config code will only load those
# config files as specified on the command line.
# If the cinder is started with the
# --config-file option then append our powervc.conf file to
# the command line so it gets loaded as well.
for arg in argv:
if arg == '--config-file' or arg.startswith('--config-file='):
from cinder.openstack.common import log as oslo_logging
from cinder.openstack.common import timeutils
from cinder import rpc
from cinder import service
from cinder.tests import conf_fixture
from cinder.tests import fake_notifier
test_opts = [
cfg.StrOpt('sqlite_clean_db',
default='clean.sqlite',
help='File name of clean sqlite db'), ]
CONF = cfg.CONF
CONF.register_opts(test_opts)
LOG = oslo_logging.getLogger(__name__)
_DB_CACHE = None
class TestingException(Exception):
pass
class Database(fixtures.Fixture):
def __init__(self, db_session, db_migrate, sql_connection,
sqlite_db, sqlite_clean_db):
self.sql_connection = sql_connection
self.sqlite_db = sqlite_db
self.sqlite_clean_db = sqlite_clean_db
from cinder import flags
from cinder.openstack.common import cfg
from cinder.openstack.common import importutils
from cinder.openstack.common import log as logging
from cinder.volume import san
ibm_xiv_opts = [
cfg.StrOpt('xiv_proxy',
default='xiv_openstack.nova_proxy.XIVNovaProxy',
help='Proxy driver'),
]
FLAGS = flags.FLAGS
FLAGS.register_opts(ibm_xiv_opts)
LOG = logging.getLogger('nova.volume.xiv')
class XIVDriver(san.SanISCSIDriver):
"""IBM XIV volume driver."""
def __init__(self, *args, **kwargs):
"""Initialize the driver."""
proxy = importutils.import_class(FLAGS.xiv_proxy)
self.xiv_proxy = proxy({
"xiv_user": FLAGS.san_login,
"xiv_pass": FLAGS.san_password,
"xiv_address": FLAGS.san_ip,
"xiv_vol_pool": FLAGS.san_clustername
from barbicanclient import client as barbican_client
from keystoneclient.auth import identity
from keystoneclient import session
from oslo.config import cfg
from cinder import exception
from cinder.i18n import _
from cinder.keymgr import key as keymgr_key
from cinder.keymgr import key_mgr
from cinder.openstack.common import excutils
from cinder.openstack.common import log as logging
CONF = cfg.CONF
CONF.import_opt('encryption_auth_url', 'cinder.keymgr.key_mgr', group='keymgr')
CONF.import_opt('encryption_api_url', 'cinder.keymgr.key_mgr', group='keymgr')
LOG = logging.getLogger(__name__)
class BarbicanKeyManager(key_mgr.KeyManager):
"""Key Manager Interface that wraps the Barbican client API."""
def __init__(self):
self._base_url = CONF.keymgr.encryption_api_url
# the barbican endpoint can't have the '/v1' on the end
self._barbican_endpoint = self._base_url.rpartition('/')[0]
self._barbican_client = None
def _get_barbican_client(self, ctxt):
"""Creates a client to connect to the Barbican service.
:param ctxt: the user context for authentication
:mod:`nexenta.volume` -- Driver to store volumes on Nexenta Appliance
=====================================================================
.. automodule:: nexenta.volume
.. moduleauthor:: Yuriy Taraday <*****@*****.**>
"""
from cinder import exception
from cinder import flags
from cinder.openstack.common import log as logging
from cinder.openstack.common import cfg
from cinder.volume import driver
from cinder.volume import nexenta
from cinder.volume.nexenta import jsonrpc
LOG = logging.getLogger("cinder.volume.nexenta.volume")
FLAGS = flags.FLAGS
nexenta_opts = [
cfg.StrOpt('nexenta_host', default='', help='IP address of Nexenta SA'),
cfg.IntOpt('nexenta_rest_port',
default=2000,
help='HTTP port to connect to Nexenta REST API server'),
cfg.StrOpt('nexenta_rest_protocol',
default='auto',
help='Use http or https for REST connection (default auto)'),
cfg.StrOpt('nexenta_user',
default='admin',
help='User name to connect to Nexenta SA'),
cfg.StrOpt('nexenta_password',
default='nexenta',
