def register(self, proxy, in_addr, zmq_type_in, out_addr=None,
zmq_type_out=None, in_bind=True, out_bind=True,
subscribe=None):
LOG.info(_("Registering reactor"))
if zmq_type_in not in (zmq.PULL, zmq.SUB):
raise RPCException("Bad input socktype")
# Items push in.
inq = ZmqSocket(in_addr, zmq_type_in, bind=in_bind,
subscribe=subscribe)
self.proxies[inq] = proxy
self.sockets.append(inq)
LOG.info(_("In reactor registered"))
if not out_addr:
return
if zmq_type_out not in (zmq.PUSH, zmq.PUB):
raise RPCException("Bad output socktype")
# Items push out.
outq = ZmqSocket(out_addr, zmq_type_out, bind=out_bind)
self.mapping[inq] = outq
self.mapping[outq] = inq
self.sockets.append(outq)
LOG.info(_("Out reactor registered"))
def reconnect(self):
"""Handles reconnecting and re-establishing sessions and queues"""
if self.connection.opened():
try:
self.connection.close()
except qpid_exceptions.ConnectionError:
pass
attempt = 0
delay = 1
while True:
broker = self.brokers[attempt % len(self.brokers)]
attempt += 1
try:
self.connection_create(broker)
self.connection.open()
except qpid_exceptions.ConnectionError, e:
msg_dict = dict(e=e, delay=delay)
msg = _("Unable to connect to AMQP server: %(e)s. "
"Sleeping %(delay)s seconds") % msg_dict
LOG.error(msg)
time.sleep(delay)
delay = min(2 * delay, 60)
else:
LOG.info(_('Connected to AMQP server on %s'), broker)
break
def consume(self, sock):
#TODO(ewindisch): use zero-copy (i.e. references, not copying)
data = sock.recv()
LOG.debug(_("CONSUMER RECEIVED DATA: %s"), data)
if sock in self.mapping:
LOG.debug(_("ROUTER RELAY-OUT %(data)s") % {
'data': data})
self.mapping[sock].send(data)
return
proxy = self.proxies[sock]
if data[2] == 'cast': # Legacy protocol
packenv = data[3]
ctx, msg = _deserialize(packenv)
request = rpc_common.deserialize_msg(msg)
ctx = RpcContext.unmarshal(ctx)
elif data[2] == 'impl_zmq_v2':
packenv = data[4:]
msg = unflatten_envelope(packenv)
request = rpc_common.deserialize_msg(msg)
# Unmarshal only after verifying the message.
ctx = RpcContext.unmarshal(data[3])
else:
LOG.error(_("ZMQ Envelope version unsupported or unknown."))
return
self.pool.spawn_n(self.process, proxy, ctx, request)
def _multi_send(method, context, topic, msg, timeout=None,
envelope=False, _msg_id=None):
"""
Wraps the sending of messages,
dispatches to the matchmaker and sends
message to all relevant hosts.
"""
conf = CONF
LOG.debug(_("%(msg)s") % {'msg': ' '.join(map(pformat, (topic, msg)))})
queues = _get_matchmaker().queues(topic)
LOG.debug(_("Sending message(s) to: %s"), queues)
# Don't stack if we have no matchmaker results
if len(queues) == 0:
LOG.warn(_("No matchmaker results. Not casting."))
# While not strictly a timeout, callers know how to handle
# this exception and a timeout isn't too big a lie.
raise rpc_common.Timeout(_("No match from matchmaker."))
# This supports brokerless fanout (addresses > 1)
for queue in queues:
(_topic, ip_addr) = queue
_addr = "tcp://%s:%s" % (ip_addr, conf.rpc_zmq_port)
if method.__name__ == '_cast':
eventlet.spawn_n(method, _addr, context,
_topic, msg, timeout, envelope,
_msg_id)
return
return method(_addr, context, _topic, msg, timeout,
envelope)
def create_consumer(self, topic, proxy, fanout=False):
# Register with matchmaker.
_get_matchmaker().register(topic, CONF.rpc_zmq_host)
# Subscription scenarios
if fanout:
sock_type = zmq.SUB
subscribe = ('', fanout)[type(fanout) == str]
topic = 'fanout~' + topic.split('.', 1)[0]
else:
sock_type = zmq.PULL
subscribe = None
topic = '.'.join((topic.split('.', 1)[0], CONF.rpc_zmq_host))
if topic in self.topics:
LOG.info(_("Skipping topic registration. Already registered."))
return
# Receive messages from (local) proxy
inaddr = "ipc://%s/zmq_topic_%s" % \
(CONF.rpc_zmq_ipc_dir, topic)
LOG.debug(_("Consumer is a zmq.%s"),
['PULL', 'SUB'][sock_type == zmq.SUB])
self.reactor.register(proxy, inaddr, sock_type,
subscribe=subscribe, in_bind=False)
self.topics.append(topic)
def _process_data(self, ctxt, version, method, args):
"""Process a message in a new thread.
If the proxy object we have has a dispatch method
(see rpc.dispatcher.RpcDispatcher), pass it the version,
method, and args and let it dispatch as appropriate. If not, use
the old behavior of magically calling the specified method on the
proxy we have here.
"""
ctxt.update_store()
try:
rval = self.proxy.dispatch(ctxt, version, method, **args)
# Check if the result was a generator
if inspect.isgenerator(rval):
for x in rval:
ctxt.reply(x, None, connection_pool=self.connection_pool)
else:
ctxt.reply(rval, None, connection_pool=self.connection_pool)
# This final None tells multicall that it is done.
ctxt.reply(ending=True, connection_pool=self.connection_pool)
except rpc_common.ClientException as e:
LOG.debug(_('Expected exception during message handling (%s)') %
e._exc_info[1])
ctxt.reply(None, e._exc_info,
connection_pool=self.connection_pool,
log_failure=False)
except Exception:
# sys.exc_info() is deleted by LOG.exception().
exc_info = sys.exc_info()
LOG.error(_('Exception during message handling'),
exc_info=exc_info)
ctxt.reply(None, exc_info, connection_pool=self.connection_pool)
def __call__(self, message_data):
"""Consumer callback to call a method on a proxy object.
Parses the message for validity and fires off a thread to call the
proxy object method.
Message data should be a dictionary with two keys:
method: string representing the method to call
args: dictionary of arg: value
Example: {'method': 'echo', 'args': {'value': 42}}
"""
# It is important to clear the context here, because at this point
# the previous context is stored in local.store.context
if hasattr(local.store, 'context'):
del local.store.context
rpc_common._safe_log(LOG.debug, _('received %s'), message_data)
self.msg_id_cache.check_duplicate_message(message_data)
ctxt = unpack_context(self.conf, message_data)
method = message_data.get('method')
args = message_data.get('args', {})
version = message_data.get('version', None)
if not method:
LOG.warn(_('no method for message: %s') % message_data)
ctxt.reply(_('No method for message: %s') % message_data,
connection_pool=self.connection_pool)
return
self.pool.spawn_n(self._process_data, ctxt, version, method, args)
def update(self, req, id, body):
LOG.debug(_('Updating app node by id %s' % id))
context = req.environ['vsm.context']
if not self.is_valid_body(body, 'appnode'):
raise exc.HTTPBadRequest()
body = body.get('appnode')
LOG.debug('PUT body: %s' % body)
if id is None:
expl = _('Request body and URI mismatch: No appnode_id')
raise webob.exc.HTTPBadRequest(explanation=expl)
# convert from unicode to str
id = str(id)
status = body.get('ssh_status', None)
log = body.get('log_info', None)
ip = body.get('ip', None)
if not status and not log and not ip:
expl = _('Request body and URI mismatch: ssh_status or log_info required.')
raise webob.exc.HTTPBadRequest(explanation=expl)
appnodes.update(context, id, status, log, ip)
return webob.Response(status_int=201)
def _connect(self, params):
"""Connect to rabbit. Re-establish any queues that may have
been declared before if we are reconnecting. Exceptions should
be handled by the caller.
"""
if self.connection:
LOG.info(_("Reconnecting to AMQP server on "
"%(hostname)s:%(port)d") % params)
try:
self.connection.release()
except self.connection_errors:
pass
# Setting this in case the next statement fails, though
# it shouldn't be doing any network operations, yet.
self.connection = None
self.connection = kombu.connection.BrokerConnection(**params)
self.connection_errors = self.connection.connection_errors
if self.memory_transport:
# Kludge to speed up tests.
self.connection.transport.polling_interval = 0.0
self.consumer_num = itertools.count(1)
self.connection.connect()
self.channel = self.connection.channel()
# work around 'memory' transport bug in 1.1.3
if self.memory_transport:
self.channel._new_queue('ae.undeliver')
for consumer in self.consumers:
consumer.reconnect(self.channel)
LOG.info(_('Connected to AMQP server on %(hostname)s:%(port)d') %
params)
def __init__(self, addr, zmq_type, bind=True, subscribe=None):
self.sock = _get_ctxt().socket(zmq_type)
self.addr = addr
self.type = zmq_type
self.subscriptions = []
# Support failures on sending/receiving on wrong socket type.
self.can_recv = zmq_type in (zmq.PULL, zmq.SUB)
self.can_send = zmq_type in (zmq.PUSH, zmq.PUB)
self.can_sub = zmq_type in (zmq.SUB, )
# Support list, str, & None for subscribe arg (cast to list)
do_sub = {
list: subscribe,
str: [subscribe],
type(None): []
}[type(subscribe)]
for f in do_sub:
self.subscribe(f)
str_data = {'addr': addr, 'type': self.socket_s(),
'subscribe': subscribe, 'bind': bind}
LOG.debug(_("Connecting to %(addr)s with %(type)s"), str_data)
LOG.debug(_("-> Subscribed to %(subscribe)s"), str_data)
LOG.debug(_("-> bind: %(bind)s"), str_data)
try:
if bind:
self.sock.bind(addr)
else:
self.sock.connect(addr)
except Exception:
raise RPCException(_("Could not open socket."))
def _check(self, match, target_dict, cred_dict):
try:
match_kind, match_value = match.split(':', 1)
except Exception:
LOG.exception(_("Failed to understand rule %(match)r") % locals())
# If the rule is invalid, fail closed
return False
func = None
try:
old_func = getattr(self, '_check_%s' % match_kind)
except AttributeError:
func = self._checks.get(match_kind, self._checks.get(None, None))
else:
LOG.warning(_("Inheritance-based rules are deprecated; update "
"_check_%s") % match_kind)
func = lambda brain, kind, value, target, cred: old_func(value,
target,
cred)
if not func:
LOG.error(_("No handler for matches of kind %s") % match_kind)
# Fail closed
return False
return func(self, match_kind, match_value, target_dict, cred_dict)
def create(self, req, body):
"""create app nodes."""
LOG.debug(_('Creating new app nodes %s'), body)
if not self.is_valid_body(body, 'appnodes'):
raise exc.HTTPBadRequest()
context = req.environ['vsm.context']
ip_list = body['appnodes']
if not isinstance(ip_list, list):
expl = _('Invalid Request body: should be a list of IP address.')
raise webob.exc.HTTPBadRequest(explanation=expl)
node_list = appnodes.create(context, ip_list)
node_view = self._view_builder.index(node_list)
for node in node_list:
#LOG.info('Node %s, Node id: %s, Node ip: %s' % (node, node.id, node.ip))
#ssh = utils.SSHClient(ip='10.239.131.170', user='******', key_file=r'~/.ssh/id_rsa')
#ssh = utils.SSHClient(node.ip, 'root', '~/.ssh/id_rsa')
#ret = ssh.check_ssh(retries=1)
#status = 'reachable' if ret else 'unreachable'
status = 'reachable'
appnodes.update(context, node.id, status)
return node_view
def publisher(waiter):
LOG.info(_("Creating proxy for topic: %s"), topic)
try:
# The topic is received over the network,
# don't trust this input.
if self.badchars.search(topic) is not None:
emsg = _("Topic contained dangerous characters.")
LOG.warn(emsg)
raise RPCException(emsg)
out_sock = ZmqSocket("ipc://%s/zmq_topic_%s" %
(ipc_dir, topic),
sock_type, bind=True)
except RPCException:
waiter.send_exception(*sys.exc_info())
return
self.topic_proxy[topic] = eventlet.queue.LightQueue(
CONF.rpc_zmq_topic_backlog)
self.sockets.append(out_sock)
# It takes some time for a pub socket to open,
# before we can have any faith in doing a send() to it.
if sock_type == zmq.PUB:
eventlet.sleep(.5)
waiter.send(True)
while(True):
data = self.topic_proxy[topic].get()
out_sock.send(data)
LOG.debug(_("ROUTER RELAY-OUT SUCCEEDED %(data)s") %
{'data': data})
def update(self, req, id, body):
LOG.debug(_('Updating app node by id %s' % id))
context = req.environ['vsm.context']
if not self.is_valid_body(body, 'appnode'):
raise exc.HTTPBadRequest()
body = body.get('appnode')
LOG.debug('PUT body: %s' % body)
if id is None:
expl = _('Request body and URI mismatch: No appnode_id')
raise webob.exc.HTTPBadRequest(explanation=expl)
# convert from unicode to str
id = str(id)
os_tenant_name = body.get('os_tenant_name', None)
os_username = body.get('os_username', None)
os_password = body.get('os_password', None)
os_auth_url = body.get('os_auth_url', None)
if not os_tenant_name or not os_username or not os_password or not os_auth_url:
expl = _('Request body and URI mismatch: os_tenant_name or os_username or os_password or os_auth_url required.')
raise webob.exc.HTTPBadRequest(explanation=expl)
appnodes.update(context, id, body)
return webob.Response(status_int=201)
def load_physical_driver(physical_driver=None):
"""Load ad physical driver module.
Load the physical driver module specified by the physical_driver
configuration option or, if supplied, the driver name supplied
as an argument.
:param physical_driver: a physical driver name to override the config opt.
:returns: a PhysicalDriver interface.
"""
if not physical_driver:
physical_driver = CONF.physical_driver
if not physical_driver:
LOG.warn(_("Physical driver option required, but not specified"))
raise
try:
# If just write driver.CephDriver
driver = importutils.import_object_ns("vsm.physical", physical_driver)
return utils.check_isinstance(driver, PhysicalDriver)
except ImportError:
try:
# If vsm.physical.driver.CephDriver
driver = importutils.import_object(physical_driver)
return utils.check_isinstance(driver, PhysicalDriver)
except ImportError:
LOG.exception(_("Unable to load the physical driver"))
raise
def consume_in_thread(self):
"""Runs the ZmqProxy service"""
ipc_dir = CONF.rpc_zmq_ipc_dir
consume_in = "tcp://%s:%s" % \
(CONF.rpc_zmq_bind_address,
CONF.rpc_zmq_port)
consumption_proxy = InternalContext(None)
if not os.path.isdir(ipc_dir):
try:
utils.execute('mkdir', '-p', ipc_dir, run_as_root=True)
utils.execute('chown', "%s:%s" % (os.getuid(), os.getgid()),
ipc_dir, run_as_root=True)
utils.execute('chmod', '750', ipc_dir, run_as_root=True)
except utils.ProcessExecutionError:
with excutils.save_and_reraise_exception():
LOG.error(_("Could not create IPC directory %s") %
(ipc_dir, ))
try:
self.register(consumption_proxy,
consume_in,
zmq.PULL,
out_bind=True)
except zmq.ZMQError:
with excutils.save_and_reraise_exception():
LOG.error(_("Could not create ZeroMQ receiver daemon. "
"Socket may already be in use."))
super(ZmqProxy, self).consume_in_thread()
def _error_callback(exc):
if isinstance(exc, qpid_exceptions.Empty):
LOG.debug(_('Timed out waiting for RPC response: %s') %
str(exc))
raise rpc_common.Timeout()
else:
LOG.exception(_('Failed to consume message from queue: %s') %
str(exc))
def _error_callback(exc):
if isinstance(exc, socket.timeout):
LOG.debug(_('Timed out waiting for RPC response: %s') %
str(exc))
raise rpc_common.Timeout()
else:
LOG.exception(_('Failed to consume message from queue: %s') %
str(exc))
info['do_consume'] = True
def update(contxt, appnode_id, appnode):
"""update app node ssh status, log info or deleted"""
if contxt is None:
contxt = context.get_admin_context()
id = utils.int_from_str(appnode_id)
LOG.debug("app node id: %s " % id)
os_tenant_name = appnode["os_tenant_name"]
os_username = appnode["os_username"]
os_password = appnode["os_password"]
os_auth_url = appnode["os_auth_url"]
os_region_name = appnode["os_region_name"]
xtrust_user = appnode["xtrust_user"]
novaclient = nc.Client(os_username, os_password, os_tenant_name, os_auth_url, region_name=os_region_name)
nova_services = novaclient.services.list()
nova_compute_hosts = []
for nova_service in nova_services:
if nova_service.binary == "nova-compute":
nova_compute_hosts.append(nova_service.host)
cinderclient = cc.Client(os_username, os_password, os_tenant_name, os_auth_url, region_name=os_region_name)
cinder_services = cinderclient.services.list()
cinder_volume_hosts = []
for cinder_service in cinder_services:
if cinder_service.binary == "cinder-volume":
cinder_volume_hosts.append(cinder_service.host)
hosts = list(set(nova_compute_hosts + cinder_volume_hosts))
print hosts
for host in hosts:
result, err = utils.execute("check_xtrust_crudini", xtrust_user, host, run_as_root=True)
LOG.info("==============result: %s" % result)
LOG.info("==============result: %s" % err)
if "command not found" in err:
raise Exception("Command not found on %s" % host)
if "Permission denied" in err:
raise Exception("Please check the mutual trust between vsm nodes and openstack nodes")
"""validate openstack access info"""
try:
token_url_id = _get_token(os_tenant_name, os_username, os_password, os_auth_url, os_region_name)
if token_url_id != None:
appnode["ssh_status"] = "reachable"
else:
appnode["ssh_status"] = "no cinder-volume"
except:
LOG.exception(_("Error to access to openstack"))
appnode["ssh_status"] = "unreachable"
try:
return db.appnodes_update(contxt, id, appnode)
except db_exc.DBError as e:
LOG.exception(_("DB Error on updating Appnodes %s" % e))
raise exception.AppNodeFailure()
def delete(self, req, id):
"""delete app node by id."""
LOG.debug(_('Removing app node by id %s' % id))
context = req.environ['vsm.context']
if id is None:
expl = _('Request body and URI mismatch')
raise webob.exc.HTTPBadRequest(explanation=expl)
id = str(id)
appnodes.destroy(context, id)
return webob.Response(status_int=201)
def reconnect(self):
"""Handles reconnecting and re-establishing queues.
Will retry up to self.max_retries number of times.
self.max_retries = 0 means to retry forever.
Sleep between tries, starting at self.interval_start
seconds, backing off self.interval_stepping number of seconds
each attempt.
"""
attempt = 0
while True:
params = self.params_list[attempt % len(self.params_list)]
attempt += 1
try:
self._connect(params)
return
except (IOError, self.connection_errors) as e:
pass
except Exception, e:
# NOTE(comstud): Unfortunately it's possible for amqplib
# to return an error not covered by its transport
# connection_errors in the case of a timeout waiting for
# a protocol response. (See paste link in LP888621)
# So, we check all exceptions for 'timeout' in them
# and try to reconnect in this case.
if 'timeout' not in str(e):
raise
log_info = {}
log_info['err_str'] = str(e)
log_info['max_retries'] = self.max_retries
log_info.update(params)
if self.max_retries and attempt == self.max_retries:
LOG.error(_('Unable to connect to AMQP server on '
'%(hostname)s:%(port)d after %(max_retries)d '
'tries: %(err_str)s') % log_info)
# NOTE(comstud): Copied from original code. There's
# really no better recourse because if this was a queue we
# need to consume on, we have no way to consume anymore.
sys.exit(1)
if attempt == 1:
sleep_time = self.interval_start or 1
elif attempt > 1:
sleep_time += self.interval_stepping
if self.interval_max:
sleep_time = min(sleep_time, self.interval_max)
log_info['sleep_time'] = sleep_time
LOG.error(_('AMQP server on %(hostname)s:%(port)d is '
'unreachable: %(err_str)s. Trying again in '
'%(sleep_time)d seconds.') % log_info)
time.sleep(sleep_time)
def notify(context, publisher_id, event_type, priority, payload):
"""Sends a notification using the specified driver
:param publisher_id: the source worker_type.host of the message
:param event_type: the literal type of event (ex. Instance Creation)
:param priority: patterned after the enumeration of Python logging
levels in the set (DEBUG, WARN, INFO, ERROR, CRITICAL)
:param payload: A python dictionary of attributes
Outgoing message format includes the above parameters, and appends the
following:
message_id
a UUID representing the id for this notification
timestamp
the GMT timestamp the notification was sent at
The composite message will be constructed as a dictionary of the above
attributes, which will then be sent via the transport mechanism defined
by the driver.
Message example::
{'message_id': str(uuid.uuid4()),
'publisher_id': 'compute.host1',
'timestamp': timeutils.utcnow(),
'priority': 'WARN',
'event_type': 'compute.create_instance',
'payload': {'instance_id': 12, ... }}
"""
if priority not in log_levels:
raise BadPriorityException(
_('%s not in valid priorities') % priority)
# Ensure everything is JSON serializable.
payload = jsonutils.to_primitive(payload, convert_instances=True)
msg = dict(message_id=str(uuid.uuid4()),
publisher_id=publisher_id,
event_type=event_type,
priority=priority,
payload=payload,
timestamp=str(timeutils.utcnow()))
for driver in _get_drivers():
try:
driver.notify(context, msg)
except Exception as e:
LOG.exception(_("Problem '%(e)s' attempting to "
"send to notification system. "
"Payload=%(payload)s")
% dict(e=e, payload=payload))
def create(contxt, auth_openstack=None, allow_duplicate=False):
"""create app node from a dict"""
if contxt is None:
contxt = context.get_admin_context()
if not auth_openstack:
raise exception.AppNodeInvalidInfo()
os_controller_host = auth_openstack['os_auth_url'].split(":")[1][2:]
result, err = utils.execute(
'check_xtrust_crudini',
auth_openstack['ssh_user'],
os_controller_host,
run_as_root = True
)
LOG.info("==============result: %s" % result)
LOG.info("==============err: %s" % err)
if "command not found" in err:
raise Exception("Command not found on %s" % os_controller_host)
if "Permission denied" in err:
raise Exception("Please check the mutual trust between vsm controller node "
"and openstack controller node")
if "No passwd entry" in err:
raise Exception("Please check the trust user")
ref = []
"""validate openstack access info"""
try:
token_url_id = _get_token(
auth_openstack['os_tenant_name'],
auth_openstack['os_username'],
auth_openstack['os_password'],
auth_openstack['os_auth_url'],
auth_openstack['os_region_name']
)
if token_url_id != None:
auth_openstack['ssh_status'] = "reachable"
else:
auth_openstack['ssh_status'] = "no cinder-volume"
except:
LOG.exception(_("Error to access to openstack"))
auth_openstack['ssh_status'] = "unreachable"
try:
ref.append(db.appnodes_create(contxt, auth_openstack, allow_duplicate))
except db_exc.DBError as e:
LOG.exception(_("DB Error on creating Appnodes %s" % e))
raise exception.AppNodeFailure()
return ref
def _get_not_supported_column(col_name_col_instance, column_name):
try:
column = col_name_col_instance[column_name]
except Exception:
msg = _("Please specify column %s in col_name_col_instance "
"param. It is required because column has unsupported "
"type by sqlite).")
raise exception.NovaException(msg % column_name)
if not isinstance(column, Column):
msg = _("col_name_col_instance param has wrong type of "
"column instance for column %s It should be instance "
"of sqlalchemy.Column.")
raise exception.NovaException(msg % column_name)
return column
def __exit__(self, exc_type, exc_val, exc_tb):
try:
self.unlock()
self.lockfile.close()
except IOError:
LOG.exception(_("Could not release the acquired lock `%s`"),
self.fname)
def __init__(self, stdout=None, stderr=None, exit_code=None, cmd=None,
description=None):
self.exit_code = exit_code
self.stderr = stderr
self.stdout = stdout
self.cmd = cmd
self.description = description
if description is None:
description = _('Unexpected error while running command.')
if exit_code is None:
exit_code = '-'
message = _('%(description)s\nCommand: %(cmd)s\n'
'Exit code: %(exit_code)s\nStdout: %(stdout)r\n'
'Stderr: %(stderr)r') % locals()
IOError.__init__(self, message)
def deprecated(self, msg, *args, **kwargs):
stdmsg = _("Deprecated: %s") % msg
if CONF.fatal_deprecations:
self.critical(stdmsg, *args, **kwargs)
raise DeprecatedConfig(msg=stdmsg)
else:
self.warn(stdmsg, *args, **kwargs)
def fanout_cast(conf, context, topic, msg, connection_pool):
"""Sends a message on a fanout exchange without waiting for a response."""
LOG.debug(_('Making asynchronous fanout cast...'))
_add_unique_id(msg)
pack_context(msg, context)
with ConnectionContext(conf, connection_pool) as conn:
conn.fanout_send(topic, rpc_common.serialize_msg(msg))
def __init__(self, message=None, **kwargs):
self.kwargs = kwargs
if 'code' not in self.kwargs:
try:
self.kwargs['code'] = self.code
except AttributeError:
pass
if not message:
try:
message = self.message % kwargs
except Exception as e:
# kwargs doesn't match a variable in the message
# log the issue and the kwargs
LOG.exception(_('Exception in string format operation'))
for name, value in kwargs.iteritems():
LOG.error("%s: %s" % (name, value))
if FLAGS.fatal_exception_format_errors:
raise e
else:
# at least get the core message out if something happened
message = self.message
super(VsmException, self).__init__(message)
def create(self, req, body):
LOG.debug(_('Creating new pool usages %s'), body)
LOG.info(' Creating new pool usages')
context = req.environ['vsm.context']
pools = body['poolusages']
cinder_volume_host_list = [pool['cinder_volume_host'] for pool in pools]
# id_list = [pool['id'] for pool in pools]
# check openstack access
host_list = []
count_crudini = 0
count_ssh = 0
for host in cinder_volume_host_list:
(status, output) = commands.getstatusoutput('ssh %s "crudini --version"' % host)
LOG.info(str(status) + "========" + output)
if "command not found" in output:
count_crudini = count_crudini + 1
host_list.append(host)
if "Permission denied" in output:
count_ssh = count_ssh + 1
host_list.append(host)
if count_crudini != 0:
return {'status': 'bad', 'host': list(set(host_list))}
elif count_ssh != 0:
return {'status': 'unreachable', 'host': list(set(host_list))}
else:
info = storagepoolusage.create(context, pools)
LOG.info(' pools_info = %s' % info)
self.scheduler_api.present_storage_pools(context, info)
return {'status': 'ok', 'host': host_list}
class OsdNotFound(NotFound):
code = "E-B676"
message = _("Osd %(osd)s could not be found.")
class MalformedRequestBody(VsmException):
message = _("Malformed message body: %(reason)s")
class SchedulerHostWeigherNotFound(NotFound):
message = _("Scheduler Host Weigher %(weigher_name)s could not be found.")
class InvalidReservationExpiration(Invalid):
message = _("Invalid reservation expiration %(expire)s.")
class QuotaResourceUnknown(QuotaNotFound):
message = _("Unknown quota resources %(unknown)s.")
class HardwareSizeExceedsAvailableQuota(QuotaError):
message = _("Requested storage or snapshot exceeds "
"allowed Gigabytes quota")
class QuotaError(VsmException):
message = _("Quota exceeded") + ": code=%(code)s"
code = 413
headers = {'Retry-After': 0}
safe = True
class WillNotSchedule(VsmException):
message = _("Host %(host)s is not up or doesn't exist.")
class NoValidHost(VsmException):
code = "E-6550"
message = _("No valid host was found. %(reason)s")
class NotAllowed(VsmException):
message = _("Action not allowed.")
class ConfigNotFound(NotFound):
code = "E-89AF"
message = _("Could not find config at %(path)s")
class HardwareTypeExists(Duplicate):
message = _("Hardware Type %(id)s already exists.")
class ProjectQuotaNotFound(QuotaNotFound):
message = _("Quota for project %(project_id)s could not be found.")
class ClassNotFound(NotFound):
message = _("Class %(class_name)s could not be found: %(exception)s")
class QuotaNotFound(NotFound):
message = _("Quota could not be found")
class FileNotFound(NotFound):
code = "E-D55E"
message = _("File %(file_path)s could not be found.")
class InvalidQuotaValue(Invalid):
message = _("Change would make usage less than 0 for the following "
"resources: %(unders)s")
class MigrationNotFoundByStatus(MigrationNotFound):
message = _("Migration not found for instance %(instance_id)s "
"with status %(status)s.")
class HostBinaryNotFound(NotFound):
message = _("Could not find binary %(binary)s on host %(host)s.")
class MigrationNotFound(NotFound):
message = _("Migration %(migration_id)s could not be found.")
class SchedulerHostFilterNotFound(NotFound):
message = _("Scheduler Host Filter %(filter_name)s could not be found.")
class VsmStorageGroupNotFound(NotFound):
code = "E-352E"
message = _("storagegroup %(group)% could not be found.")
class OverQuota(VsmException):
message = _("Quota exceeded for resources: %(overs)s")
class MigrationError(VsmException):
message = _("Migration error") + ": %(reason)s"
class ReservationNotFound(QuotaNotFound):
message = _("Quota reservation %(uuid)s could not be found.")
class QuotaUsageNotFound(QuotaNotFound):
message = _("Quota usage for project %(project_id)s could not be found.")
class VsmOsdNotFound(OsdNotFound):
code = "E-EC04"
message = _("Osd %(osd)s could not be found.")
class QuotaClassNotFound(QuotaNotFound):
message = _("Quota class %(class_name)s could not be found.")
class PasteAppNotFound(NotFound):
message = _("Could not load paste app '%(name)s' from %(path)s")
class KeyPairExists(Duplicate):
message = _("Key pair %(key_name)s already exists.")
