def update(self, req, id, body):
"""Enable/Disable scheduling for a service"""
context = req.environ["manila.context"]
authorize(context)
if id == "enable":
disabled = False
elif id == "disable":
disabled = True
else:
raise webob.exc.HTTPNotFound("Unknown action")
try:
host = body["host"]
service = body["service"]
except (TypeError, KeyError):
raise webob.exc.HTTPBadRequest()
try:
svc = db.service_get_by_args(context, host, service)
if not svc:
raise webob.exc.HTTPNotFound("Unknown service")
db.service_update(context, svc["id"], {"disabled": disabled})
except exception.ServiceNotFound:
raise webob.exc.HTTPNotFound("service not found")
return {"host": host, "service": service, "disabled": disabled}
def update(self, req, id, body):
"""Enable/Disable scheduling for a service."""
context = req.environ['manila.context']
authorize(context)
if id == "enable":
disabled = False
elif id == "disable":
disabled = True
else:
raise webob.exc.HTTPNotFound("Unknown action")
try:
host = body['host']
binary = body['binary']
except (TypeError, KeyError):
raise webob.exc.HTTPBadRequest()
try:
svc = db.service_get_by_args(context, host, binary)
if not svc:
raise webob.exc.HTTPNotFound('Unknown service')
db.service_update(context, svc['id'], {'disabled': disabled})
except exception.ServiceNotFound:
raise webob.exc.HTTPNotFound("service not found")
return {'host': host, 'binary': binary, 'disabled': disabled}
def test_create_share_availability_zone_if_service_down(self):
share_id = 'fake'
fake_share = {'id': share_id,
'availability_zone': 'fake:fake',
'size': 1}
fake_request_spec = {'share_id': share_id,
'share_properties': fake_share}
self.mox.StubOutWithMock(utils, 'service_is_up')
self.mox.StubOutWithMock(db, 'service_get_by_args')
db.service_get_by_args(IsA(context.RequestContext), 'fake',
'manila-share').AndReturn('fake_service')
utils.service_is_up('fake_service').AndReturn(False)
self.mox.ReplayAll()
self.assertRaises(exception.WillNotSchedule,
self.driver.schedule_create_share,
self.admin_context, fake_request_spec, {})
def test_create_share_availability_zone_on_host(self):
share_id = 'fake'
fake_share = {'id': share_id,
'availability_zone': 'fake:fake',
'size': 1}
fake_request_spec = {'share_id': share_id,
'share_properties': fake_share}
self.mox.StubOutWithMock(utils, 'service_is_up')
self.mox.StubOutWithMock(db, 'service_get_by_args')
self.mox.StubOutWithMock(driver, 'share_update_db')
db.service_get_by_args(IsA(context.RequestContext), 'fake',
'manila-share').AndReturn('fake_service')
utils.service_is_up('fake_service').AndReturn(True)
driver.share_update_db(IsA(context.RequestContext), share_id,
'fake').AndReturn(fake_share)
self.mox.ReplayAll()
self.driver.schedule_create_share(self.admin_context,
fake_request_spec, {})
def schedule_create_share(self, context, request_spec, filter_properties):
"""Picks a host that is up and has the fewest shares."""
# TODO(rushiagr) - pick only hosts that run shares
elevated = context.elevated()
share_id = request_spec.get('share_id')
snapshot_id = request_spec.get('snapshot_id')
share_properties = request_spec.get('share_properties')
share_size = share_properties.get('size')
availability_zone = share_properties.get('availability_zone')
zone, host = None, None
if availability_zone:
zone, _x, host = availability_zone.partition(':')
if host and context.is_admin:
service = db.service_get_by_args(elevated, host, CONF.share_topic)
if not utils.service_is_up(service):
raise exception.WillNotSchedule(host=host)
updated_share = driver.share_update_db(context, share_id, host)
self.share_rpcapi.create_share_instance(
context,
updated_share.instance,
host,
request_spec,
None,
snapshot_id=snapshot_id
)
return None
results = db.service_get_all_share_sorted(elevated)
if zone:
results = [(service_g, gigs) for (service_g, gigs) in results
if service_g['availability_zone'] == zone]
for result in results:
(service, share_gigabytes) = result
if share_gigabytes + share_size > CONF.max_gigabytes:
msg = _("Not enough allocatable share gigabytes remaining")
raise exception.NoValidHost(reason=msg)
if utils.service_is_up(service) and not service['disabled']:
updated_share = driver.share_update_db(context, share_id,
service['host'])
self.share_rpcapi.create_share_instance(
context,
updated_share.instance,
service['host'],
request_spec,
None,
snapshot_id=snapshot_id)
return None
msg = _("Is the appropriate service running?")
raise exception.NoValidHost(reason=msg)
def schedule_create_share(self, context, request_spec, filter_properties):
"""Picks a host that is up and has the fewest shares."""
# TODO(rushiagr) - pick only hosts that run shares
elevated = context.elevated()
share_id = request_spec.get('share_id')
snapshot_id = request_spec.get('snapshot_id')
share_properties = request_spec.get('share_properties')
share_size = share_properties.get('size')
availability_zone = share_properties.get('availability_zone')
zone, host = None, None
if availability_zone:
zone, _x, host = availability_zone.partition(':')
if host and context.is_admin:
service = db.service_get_by_args(elevated, host, CONF.share_topic)
if not utils.service_is_up(service):
raise exception.WillNotSchedule(host=host)
updated_share = driver.share_update_db(context, share_id, host)
self.share_rpcapi.create_share(context,
updated_share,
host,
request_spec,
None,
snapshot_id=snapshot_id)
return None
results = db.service_get_all_share_sorted(elevated)
if zone:
results = [(service, gigs) for (service, gigs) in results
if service['availability_zone'] == zone]
for result in results:
(service, share_gigabytes) = result
if share_gigabytes + share_size > CONF.max_gigabytes:
msg = _("Not enough allocatable share gigabytes remaining")
raise exception.NoValidHost(reason=msg)
if utils.service_is_up(service) and not service['disabled']:
updated_share = driver.share_update_db(context, share_id,
service['host'])
self.share_rpcapi.create_share(context,
updated_share,
service['host'],
request_spec,
None,
snapshot_id=snapshot_id)
return None
msg = _("Is the appropriate service running?")
raise exception.NoValidHost(reason=msg)
def start(self):
version_string = version.version_string()
LOG.audit(_('Starting %(topic)s node (version %(version_string)s)'),
{'topic': self.topic, 'version_string': version_string})
self.manager.init_host()
self.model_disconnected = False
ctxt = context.get_admin_context()
try:
service_ref = db.service_get_by_args(ctxt,
self.host,
self.binary)
self.service_id = service_ref['id']
except exception.NotFound:
self._create_service_ref(ctxt)
self.conn = rpc.create_connection(new=True)
LOG.debug(_("Creating Consumer connection for Service %s") %
self.topic)
rpc_dispatcher = self.manager.create_rpc_dispatcher()
# Share this same connection for these Consumers
self.conn.create_consumer(self.topic, rpc_dispatcher, fanout=False)
node_topic = '%s.%s' % (self.topic, self.host)
self.conn.create_consumer(node_topic, rpc_dispatcher, fanout=False)
self.conn.create_consumer(self.topic, rpc_dispatcher, fanout=True)
# Consume from all consumers in a thread
self.conn.consume_in_thread()
if self.report_interval:
pulse = utils.LoopingCall(self.report_state)
pulse.start(interval=self.report_interval,
initial_delay=self.report_interval)
self.timers.append(pulse)
if self.periodic_interval:
if self.periodic_fuzzy_delay:
initial_delay = random.randint(0, self.periodic_fuzzy_delay)
else:
initial_delay = None
periodic = utils.LoopingCall(self.periodic_tasks)
periodic.start(interval=self.periodic_interval,
initial_delay=initial_delay)
self.timers.append(periodic)
def start(self):
version_string = version.version_string()
LOG.info('Starting %(topic)s node (version %(version_string)s)', {
'topic': self.topic,
'version_string': version_string
})
self.model_disconnected = False
ctxt = context.get_admin_context()
if self.coordinator:
coordination.LOCK_COORDINATOR.start()
try:
service_ref = db.service_get_by_args(ctxt, self.host, self.binary)
self.service_id = service_ref['id']
except exception.NotFound:
self._create_service_ref(ctxt)
LOG.debug("Creating RPC server for service %s.", self.topic)
target = messaging.Target(topic=self.topic, server=self.host)
endpoints = [self.manager]
endpoints.extend(self.manager.additional_endpoints)
self.rpcserver = rpc.get_server(target, endpoints)
self.rpcserver.start()
self.manager.init_host()
if self.report_interval:
pulse = loopingcall.FixedIntervalLoopingCall(self.report_state)
pulse.start(interval=self.report_interval,
initial_delay=self.report_interval)
self.timers.append(pulse)
if self.periodic_interval:
if self.periodic_fuzzy_delay:
initial_delay = random.randint(0, self.periodic_fuzzy_delay)
else:
initial_delay = None
periodic = loopingcall.FixedIntervalLoopingCall(
self.periodic_tasks)
periodic.start(interval=self.periodic_interval,
initial_delay=initial_delay)
self.timers.append(periodic)
def start(self):
version_string = version.version_string()
LOG.info('Starting %(topic)s node (version %(version_string)s)',
{'topic': self.topic, 'version_string': version_string})
self.model_disconnected = False
ctxt = context.get_admin_context()
if self.coordinator:
coordination.LOCK_COORDINATOR.start()
try:
service_ref = db.service_get_by_args(ctxt,
self.host,
self.binary)
self.service_id = service_ref['id']
except exception.NotFound:
self._create_service_ref(ctxt)
LOG.debug("Creating RPC server for service %s.", self.topic)
target = messaging.Target(topic=self.topic, server=self.host)
endpoints = [self.manager]
endpoints.extend(self.manager.additional_endpoints)
self.rpcserver = rpc.get_server(target, endpoints)
self.rpcserver.start()
self.manager.init_host()
if self.report_interval:
pulse = loopingcall.FixedIntervalLoopingCall(self.report_state)
pulse.start(interval=self.report_interval,
initial_delay=self.report_interval)
self.timers.append(pulse)
if self.periodic_interval:
if self.periodic_fuzzy_delay:
initial_delay = random.randint(0, self.periodic_fuzzy_delay)
else:
initial_delay = None
periodic = loopingcall.FixedIntervalLoopingCall(
self.periodic_tasks)
periodic.start(interval=self.periodic_interval,
initial_delay=initial_delay)
self.timers.append(periodic)
def _update(self, req, id, body):
"""Enable/Disable scheduling for a service."""
context = req.environ['manila.context']
if id == "enable":
data = {'disabled': False}
elif id == "disable":
data = {'disabled': True}
else:
raise webob.exc.HTTPNotFound("Unknown action '%s'" % id)
try:
data['host'] = body['host']
data['binary'] = body['binary']
except (TypeError, KeyError):
raise webob.exc.HTTPBadRequest()
svc = db.service_get_by_args(context, data['host'], data['binary'])
db.service_update(context, svc['id'], {'disabled': data['disabled']})
return self._view_builder.summary(data)
def _update(self, req, id, body):
"""Enable/Disable scheduling for a service."""
context = req.environ['manila.context']
if id == "enable":
data = {'disabled': False}
elif id == "disable":
data = {'disabled': True}
else:
raise webob.exc.HTTPNotFound("Unknown action '%s'" % id)
try:
data['host'] = body['host']
data['binary'] = body['binary']
except (TypeError, KeyError):
raise webob.exc.HTTPBadRequest()
svc = db.service_get_by_args(context, data['host'], data['binary'])
db.service_update(
context, svc['id'], {'disabled': data['disabled']})
return self._view_builder.summary(data)
