def delete(self, _id):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_PODS_DELETE):
pecan.abort(401, _('Unauthorized to delete dcs'))
return
try:
with context.session.begin():
region_object = core.get_resource_object(context, models.DC, _id)
if len(region_object.fabrics) >0:
raise t_exceptions.InUse("Specified dc has fabric(s)")
if len(region_object.core_routers) >0:
raise t_exceptions.InUse("Specified dc has core_router(s)")
core.delete_resource(context, models.DC, _id)
pecan.response.status = 200
return {}
except t_exceptions.InUse:
return Response(_('Specified region has dcs/core_routers'), 400)
except t_exceptions.ResourceNotFound:
return Response(_('DC not found'), 404)
except Exception as e:
LOG.exception('Failed to delete dc: %(dc_id)s,'
'%(exception)s',
{'dc_id': _id,
'exception': e})
return Response(_('Failed to delete dc'), 500)
def get_one(self, _id):
context = t_context.extract_context_from_environ()
network = self.client.get_networks(context, _id)
if not network:
pecan.abort(404, 'Network not found')
return
return {'network': self._construct_network_entry(network)}
def put(self, _id, **kw):
context = t_context.extract_context_from_environ()
dci = request.context['request_data']['dci']
try:
with context.session.begin():
core.get_resource_object(context, models.DCI, _id)
connection_updated = core.update_resource(
context, models.DCI, _id, dci)
return_object = m.SuccessMessage(
result={'dci': connection_updated})
return return_object.to_dict()
except t_exceptions.ResourceNotFound as e:
LOG.exception(
'Failed to update dci: '
'dci_id %(dci_id)s ,'
'%(exception)s ', {
'dci_id': _id,
'exception': e
})
return m.DCINotFound(dci_id=_id).to_dict()
except Exception as e:
LOG.exception('Failed to update dci: '
'%(exception)s ', {'exception': e})
return_object = m.FailureMessage()
return return_object.to_dict()
def delete(self, _id):
context = t_context.extract_context_from_environ()
if not t_context.is_admin_context(context):
pecan.abort(400, _('Admin role required to delete pods'))
return
try:
with context.session.begin():
pod = core.get_resource(context, models.Pod, _id)
if pod is not None:
ag_name = utils.get_ag_name(pod['pod_name'])
ag = az_ag.get_ag_by_name(context, ag_name)
if ag is not None:
az_ag.delete_ag(context, ag['id'])
core.delete_resource(context, models.Pod, _id)
pecan.response.status = 200
except t_exc.ResourceNotFound:
return Response(_('Pod not found'), 404)
except Exception as e:
LOG.exception(
_LE('Failed to delete pod: %(pod_id)s,'
'%(exception)s'), {
'pod_id': _id,
'exception': e
})
return Response(_('Failed to delete pod'), 500)
def post(self, **kw):
context = t_context.extract_context_from_environ()
if not context.is_admin:
return utils.format_nova_error(
403, _("Policy doesn't allow os_compute_api:os-aggregates:"
"index to be performed."))
if 'aggregate' not in kw:
return utils.format_nova_error(
400, _('aggregate is not set'))
host_aggregate = kw['aggregate']
name = host_aggregate['name'].strip()
avail_zone = host_aggregate.get('availability_zone')
if avail_zone:
avail_zone = avail_zone.strip()
try:
with context.session.begin():
aggregate = az_ag.create_ag_az(context,
ag_name=name,
az_name=avail_zone)
except db_exc.DBDuplicateEntry:
return utils.format_nova_error(
409, _('Aggregate %s already exists.') % name)
except Exception:
return utils.format_nova_error(
500, _('Fail to create aggregate'))
return {'aggregate': aggregate}
def get_one(self, _id):
context = t_context.extract_context_from_environ()
image = self.client.get_images(context, _id)
if not image:
pecan.abort(404, 'Image not found')
return
return {'image': image}
def post(self, **kw):
context = t_context.extract_context_from_environ()
if 'region' not in kw:
pecan.abort(400, _('Request body region not found'))
return
print 'MaXiao kw '+str(request.context['request_data'])
region = request.context['request_data']['region']
region_name = region.get('region_name', '').strip()
_uuid = uuidutils.generate_uuid()
try:
with context.session.begin():
new_region = core.create_resource(
context, models.Region,
{'id': _uuid,
'region_name': region_name})
except db_exc.DBDuplicateEntry as e1:
LOG.exception('Record already exists on %(region_name)s: '
'%(exception)s',
{'region_name': region_name,
'exception': e1})
return Response(_('Record already exists'), 409)
except Exception as e2:
LOG.exception('Failed to create region: %(region_name)s,'
'%(exception)s ',
{'region_name': region_name,
'exception': e2})
return Response(_('Failed to create region'), 500)
return {'region': new_region}
def get_all(self):
context = t_context.extract_context_from_environ()
networks = self.client.list_networks(context)
return {
'networks':
[self._construct_network_entry(network) for network in networks]
}
def get_one(self, _id):
# NOTE(zhiyuan) this function handles two kinds of requests
# GET /flavors/flavor_id
# GET /flavors/detail
context = t_context.extract_context_from_environ()
if _id == 'detail':
with context.session.begin():
flavors = core.query_resource(context, models.InstanceTypes,
[], [])
for flavor in flavors:
flavor['id'] = flavor['flavorid']
del flavor['flavorid']
return {'flavors': flavors}
else:
with context.session.begin():
flavors = core.query_resource(context, models.InstanceTypes,
[{'key': 'flavorid',
'comparator': 'eq',
'value': _id}], [])
if not flavors:
pecan.abort(404, 'Flavor not found')
return
flavor = flavors[0]
flavor['id'] = flavor['flavorid']
del flavor['flavorid']
return {'flavor': flavor}
def delete(self, _id):
context = t_context.extract_context_from_environ()
# TODO(joehuang): get the release of top and bottom
t_release = cons.R_MITAKA
b_release = cons.R_MITAKA
s_ctx = hclient.get_res_routing_ref(context, _id, request.url,
cons.ST_CINDER)
if not s_ctx:
return utils.format_cinder_error(
404,
_('Volume %s could not be found.') % _id)
if s_ctx['b_url'] == '':
return utils.format_cinder_error(
404, _('Bottom Pod endpoint incorrect'))
b_headers = hclient.convert_header(t_release, b_release,
request.headers)
resp = hclient.forward_req(context, 'DELETE', b_headers,
s_ctx['b_url'], request.body)
response.status = resp.status_code
# don't remove the resource routing for delete is async. operation
# remove the routing when query is executed but not find
# No content in the resp actually
return response
def put(self, _id, **kw):
context = t_context.extract_context_from_environ()
firewall_bypass = request.context['request_data']['firewall_bypass']
try:
with context.session.begin():
core.get_resource_object(context, models.FirewallBypass, _id)
firewall_bypass_updated = core.update_resource(
context, models.FirewallBypass, _id, firewall_bypass)
return_object = m.SuccessMessage(
result={'firewall_bypass': firewall_bypass_updated})
return return_object.to_dict()
except t_exceptions.ResourceNotFound as e1:
LOG.exception(
'Failed to update firewall_bypass : '******'id%(id)s ,'
'%(exception)s ', {
'id': _id,
'exception': e1
})
return m.FirewallBypassNotFound(id=_id).to_dict()
except Exception as e2:
LOG.exception(
'Failed to update firewall_bypass: '******'id: %(id)s,'
'%(exception)s ', {
'id': _id,
'exception': e2
})
return_object = m.FailureMessage()
return return_object.to_dict()
def delete(self, _id):
context = t_context.extract_context_from_environ()
# TODO(joehuang): get the release of top and bottom
t_release = cons.R_MITAKA
b_release = cons.R_MITAKA
s_ctx = self._get_res_routing_ref(context, _id, request.url)
if not s_ctx:
return Response(_('Failed to find resource'), 404)
if s_ctx['b_url'] == '':
return Response(_('bottom pod endpoint incorrect'), 404)
b_headers = self._convert_header(t_release, b_release, request.headers)
resp = hclient.forward_req(context, 'DELETE', b_headers,
s_ctx['b_url'], request.body)
response.status = resp.status_code
# don't remove the resource routing for delete is async. operation
# remove the routing when query is executed but not find
# No content in the resp actually
return response
def delete(self, _id):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_PODS_DELETE):
pecan.abort(401, _('Unauthorized to delete firewall_bypass'))
return
try:
with context.session.begin():
core.delete_resource(context, models.FirewallBypass, _id)
return_object = m.SuccessMessage(result={})
return return_object.to_dict()
except t_exceptions.ResourceNotFound as e1:
LOG.exception(
'Failed to delete firewall_bypass : '******'id%(id)s ,'
'%(exception)s ', {
'id': _id,
'exception': e1
})
return m.FirewallBypassNotFound(id=_id).to_dict()
except Exception as e2:
LOG.exception(
'Failed to delete firewall_bypass: '******'id: %(id)s,'
'%(exception)s ', {
'id': _id,
'exception': e2
})
return_object = m.FailureMessage()
return return_object.to_dict()
def get_one(self, _id):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_PODS_SHOW):
pecan.abort(401, _('Unauthorized to show firewall_bypass'))
return
try:
return_object = m.SuccessMessage(result={
'firewall_bypass':
db_api.get_firewall_bypass(context, _id)
})
return return_object.to_dict()
except t_exceptions.ResourceNotFound as e1:
LOG.exception(
'Failed to show firewall_bypass : '******'id%(id)s ,'
'%(exception)s ', {
'id': _id,
'exception': e1
})
return m.FirewallBypassNotFound(id=_id).to_dict()
except Exception as e2:
LOG.exception(
'Failed to show firewall_bypass: '******'id: %(id)s,'
'%(exception)s ', {
'id': _id,
'exception': e2
})
return_object = m.FailureMessage()
return return_object.to_dict()
def delete(self, _id):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_PODS_DELETE):
pecan.abort(401, _('Unauthorized to delete pods'))
return
try:
with context.session.begin():
pod = core.get_resource(context, models.Pod, _id)
if pod is not None:
ag_name = utils.get_ag_name(pod['pod_name'])
ag = az_ag.get_ag_by_name(context, ag_name)
if ag is not None:
az_ag.delete_ag(context, ag['id'])
core.delete_resource(context, models.Pod, _id)
pecan.response.status = 200
return {}
except t_exc.ResourceNotFound:
return Response(_('Pod not found'), 404)
except Exception as e:
LOG.exception(_LE('Failed to delete pod: %(pod_id)s,'
'%(exception)s'),
{'pod_id': _id,
'exception': e})
return Response(_('Failed to delete pod'), 500)
def put(self, _id, **kw):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_PODS_CREATE):
pecan.abort(401, _('Unauthorized to put core_router'))
return
core_router = request.context['request_data']['core_router']
try:
with context.session.begin():
core.get_resource(context, models.CoreRouter, _id)
if 'routes' in core_router:
self._update_core_router_routes(context, _id, core_router)
router_updated = core.update_resource(context,
models.CoreRouter, _id,
core_router)
return_object = m.SuccessMessage(
result={'core_router': router_updated})
return return_object.to_dict()
except t_exceptions.ResourceNotFound as e:
LOG.exception(
'Failed to update core_router : '
'core_router_id %(core_router_id)s ,'
'%(exception)s ', {
'core_router_id': _id,
'exception': e
})
return m.CoreRouterNotFound(core_router_id=_id).to_dict()
except Exception as e:
LOG.exception('Failed to update core_router : '
'%(exception)s ', {'exception': e})
return_object = m.FailureMessage()
return return_object.to_dict()
def post(self, **kw):
context = t_context.extract_context_from_environ()
if not context.is_admin:
pecan.abort(400, 'Admin role required to create aggregates')
return
if 'aggregate' not in kw:
pecan.abort(400, 'Request body not found')
return
host_aggregate = kw['aggregate']
name = host_aggregate['name'].strip()
avail_zone = host_aggregate.get('availability_zone')
if avail_zone:
avail_zone = avail_zone.strip()
try:
with context.session.begin():
aggregate = az_ag.create_ag_az(context,
ag_name=name,
az_name=avail_zone)
except db_exc.DBDuplicateEntry:
pecan.abort(409, 'Aggregate already exists')
return
except Exception:
pecan.abort(500, 'Fail to create host aggregate')
return
return {'aggregate': aggregate}
def get_all(self, **kwargs):
"""Get all the jobs. Using filters, only get a subset of jobs.
:param kwargs: job filters
:return: a list of jobs
"""
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_JOB_LIST):
return utils.format_api_error(
403, _('Unauthorized to show all jobs'))
is_valid_filter, filters = self._get_filters(kwargs)
if not is_valid_filter:
msg = (_('Unsupported filter type: %(filters)s') % {
'filters': ', '.join([filter_name for filter_name in filters])
})
return utils.format_api_error(400, msg)
filters = [{'key': key,
'comparator': 'eq',
'value': value} for key, value in six.iteritems(filters)]
try:
jobs_in_job_table = db_api.list_jobs(context, filters)
jobs_in_job_log_table = db_api.list_jobs_from_log(context, filters)
jobs = jobs_in_job_table + jobs_in_job_log_table
return {'jobs': [self._get_more_readable_job(job) for job in jobs]}
except Exception as e:
LOG.exception('Failed to show all asynchronous jobs: '
'%(exception)s ', {'exception': e})
return utils.format_api_error(
500, _('Failed to show all asynchronous jobs'))
def get_all(self):
# TODO(joehuang): here should return link instead,
# now combined with 'detail'
context = t_context.extract_context_from_environ()
return {'volumes': self._get_all(context)}
def post(self, **kw):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_PODS_CREATE):
pecan.abort(401, _('Unauthorized to create firewall_gateway'))
return
firewall_gateway = request.context['request_data']['firewall_gateway']
fabric = firewall_gateway.get('fabric', '').strip()
firewall_id = firewall_gateway.get('firewall_id', '').strip()
router_id = firewall_gateway.get('router_id', '').strip()
project_id = firewall_gateway.get('project_id', '').strip()
admin_state_up = firewall_gateway.get('admin_state_up', True)
status = firewall_gateway.get('status', "DOWN")
description = firewall_gateway.get('description', '').strip()
_uuid = uuidutils.generate_uuid()
try:
with context.session.begin():
new_firewall_gateway = core.create_resource(
context, models.FirewallGateway, {
'id': _uuid,
'fabric': fabric,
'firewall_id': firewall_id,
'router_id': router_id,
'project_id': project_id,
'admin_state_up': admin_state_up,
'status': status,
'description': description
})
return_object = m.SuccessMessage(
result={'firewall_gateway': new_firewall_gateway})
return return_object.to_dict()
except db_exc.DBDuplicateEntry as e1:
LOG.exception(
'Record firewall_gateway already exists for '
'router_id %(router_id)s: '
'firewall_id%(firewall_id)s: '
'%(exception)s', {
'router_id': router_id,
'firewall_id': firewall_id,
'exception': e1
})
return_object = m.FirewallGatewayExists(router_id=router_id,
firewall_id=firewall_id)
return return_object.to_dict()
except Exception as e2:
LOG.exception(
'Failed to create firewall_gateway: '
'router_id: %(router_id)s,'
'firewall_id %(firewall_id)s: '
'%(exception)s ', {
'router_id': router_id,
'firewall_id': firewall_id,
'exception': e2
})
return_object = m.FailureMessage()
return return_object.to_dict()
def post(self, **kw):
context = t_context.extract_context_from_environ()
if not context.is_admin:
pecan.abort(400, 'Admin role required to create aggregates')
return
if 'aggregate' not in kw:
pecan.abort(400, 'Request body not found')
return
host_aggregate = kw['aggregate']
name = host_aggregate['name'].strip()
avail_zone = host_aggregate.get('availability_zone')
if avail_zone:
avail_zone = avail_zone.strip()
try:
with context.session.begin():
aggregate = az_ag.create_ag_az(context,
ag_name=name,
az_name=avail_zone)
except db_exc.DBDuplicateEntry:
pecan.abort(409, 'Aggregate already exists')
return
except Exception:
pecan.abort(500, 'Fail to create host aggregate')
return
return {'aggregate': aggregate}
def delete(self, _id):
"""Marks volume types as deleted.
:param _id: id of volume type to be deleted
"""
context = t_context.extract_context_from_environ()
if not context.is_admin:
return utils.format_cinder_error(
403,
_("Policy doesn't allow volume_extension:types_manage "
"to be performed."))
session = core.get_session()
with session.begin():
try:
db_api.volume_type_get(context, _id, session)
except exceptions.VolumeTypeNotFound as e:
return utils.format_cinder_error(404, e.message)
try:
db_api.volume_type_delete(context, _id, session)
except Exception as e:
LOG.exception(
_LE('Fail to update volume type: %(id)s,'
'%(exception)s'), {
'id': _id,
'exception': e
})
return utils.format_cinder_error(
500, _('Fail to delete volume type.'))
pecan.response.status = 202
return pecan.response
def delete(self, _id):
context = t_context.extract_context_from_environ()
# TODO(joehuang): get the release of top and bottom
t_release = 'MITATA'
b_release = 'MITATA'
s_ctx = self._get_res_routing_ref(context, _id, request.url)
if not s_ctx:
return Response(_('Failed to find resource'), 404)
if s_ctx['b_url'] == '':
return Response(_('bottom pod endpoint incorrect'), 404)
b_headers = self._convert_header(t_release,
b_release,
request.headers)
resp = hclient.forward_req(context, 'DELETE',
b_headers,
s_ctx['b_url'],
request.body)
response.status = resp.status_code
# don't remove the resource routing for delete is async. operation
# remove the routing when query is executed but not find
# No content in the resp actually
return {}
def delete(self, _id):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_PODS_DELETE):
pecan.abort(401, _('Unauthorized to delete regions'))
return
try:
with context.session.begin():
print "MaXiao 111 delete region has dcs "
region_object = core.get_resource_object(context, models.Region, _id)
print "MaXiao delete region has dcs :"+str(region_result)
if len(region_object.dcs)>0:
raise t_exceptions.InUse("Specified region has dc(s)")
core.delete_resource(context, models.Region, _id)
pecan.response.status = 200
return {}
except t_exceptions.InUse:
return Response(_('Specified region has dcs'), 400)
except t_exceptions.ResourceNotFound:
return Response(_('Region not found'), 404)
except Exception as e:
LOG.exception('Failed to delete region: %(region_id)s,'
'%(exception)s',
{'region_id': _id,
'exception': e})
return Response(_('Failed to delete region'), 500)
def put(self, _id, **kw):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_ROUTINGS_PUT):
return utils.format_api_error(
403, _('Unauthorized to update resource routing'))
try:
db_api.get_resource_routing(context, _id)
except t_exceptions.ResourceNotFound:
return utils.format_api_error(404, _('Resource routing not found'))
if 'routing' not in kw:
return utils.format_api_error(400, _('Request body not found'))
update_dict = kw['routing']
# values to be updated should not be empty
for field in update_dict:
value = update_dict.get(field)
if value is None or len(value.strip()) == 0:
return utils.format_api_error(
400,
_("Field %(field)s can not be empty") % {'field': field})
# the resource type should be properly provisioned.
if 'resource_type' in update_dict:
if not constants.is_valid_resource_type(
update_dict['resource_type']):
return utils.format_api_error(
400, _('There is no such resource type'))
# the pod with new pod_id should exist in pod table
if 'pod_id' in update_dict:
new_pod_id = update_dict.get('pod_id')
try:
# find the pod through the pod_id and verify whether it exists
db_api.get_pod(context, new_pod_id)
except t_exceptions.ResourceNotFound:
return utils.format_api_error(
400,
_("The pod %(new_pod_id)s doesn't"
" exist") % {'new_pod_id': new_pod_id})
except Exception as e:
LOG.exception(
'Failed to update resource routing: '
'%(exception)s ', {'exception': e})
return utils.format_api_error(
500, _('Failed to update resource routing'))
try:
routing_updated = db_api.update_resource_routing(
context, _id, update_dict)
return {'routing': routing_updated}
except Exception as e:
LOG.exception(
'Failed to update resource routing: '
'%(exception)s ', {'exception': e})
return utils.format_api_error(
500, _('Failed to update resource routing'))
def get_one(self, _id):
context = t_context.extract_context_from_environ()
network = self.client.get_networks(context, _id)
if not network:
pecan.abort(404, 'Network not found')
return
return {'network': self._construct_network_entry(network)}
def get_all(self):
# TODO(joehuang): here should return link instead,
# now combined with 'detail'
context = t_context.extract_context_from_environ()
return {'volumes': self._get_all(context)}
def get_one(self, _id):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_PODS_SHOW):
pecan.abort(401, _('Unauthorized to show dci'))
return
try:
dci = db_api.get_dci(context, _id)
return_object = m.SuccessMessage(result={'dci': dci})
return return_object.to_dict()
except t_exceptions.ResourceNotFound as e:
LOG.exception(
'Failed to get dci: '
'dci_id %(dci_id)s ,'
'%(exception)s ', {
'dci_id': _id,
'exception': e
})
return m.DCINotFound(dci_id=_id).to_dict()
except Exception as e:
LOG.exception('Failed to get dci: %(dci_id)s,'
'%(exception)s', {
'dci_id': _id,
'exception': e
})
return_object = m.FailureMessage()
return return_object.to_dict()
def get_one(self, _id):
context = t_context.extract_context_from_environ()
image = self.client.get_images(context, _id)
if not image:
pecan.abort(404, 'Image not found')
return
return {'image': self._construct_show_image_entry(context, image)}
def get_one(self, _id):
context = t_context.extract_context_from_environ()
if _id == 'detail':
return {'volumes': self._get_all(context)}
# TODO(joehuang): get the release of top and bottom
t_release = cons.R_MITAKA
b_release = cons.R_MITAKA
b_headers = hclient.convert_header(t_release, b_release,
request.headers)
s_ctx = hclient.get_res_routing_ref(context, _id, request.url,
cons.ST_CINDER)
if not s_ctx:
return utils.format_cinder_error(
404,
_('Volume %s could not be found.') % _id)
if s_ctx['b_url'] == '':
return utils.format_cinder_error(
404, _('Bottom Pod endpoint incorrect'))
resp = hclient.forward_req(context, 'GET', b_headers, s_ctx['b_url'],
request.body)
b_ret_body = jsonutils.loads(resp.content)
b_status = resp.status_code
response.status = b_status
if b_status == 200:
if b_ret_body.get('volume') is not None:
b_vol_ret = b_ret_body['volume']
ret_vol = hclient.convert_object(b_release,
t_release,
b_vol_ret,
res_type=cons.RT_VOLUME)
pod = utils.get_pod_by_top_id(context, _id)
if pod:
ret_vol['availability_zone'] = pod['az_name']
return {'volume': ret_vol}
# resource not find but routing exist, remove the routing
if b_status == 404:
filters = [{
'key': 'top_id',
'comparator': 'eq',
'value': _id
}, {
'key': 'resource_type',
'comparator': 'eq',
'value': cons.RT_VOLUME
}]
with context.session.begin():
core.delete_resources(context, models.ResourceRouting, filters)
return b_ret_body
def put(self, _id, **kw):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_ROUTINGS_PUT):
return utils.format_api_error(
403, _('Unauthorized to update resource routing'))
try:
db_api.get_resource_routing(context, _id)
except t_exceptions.ResourceNotFound:
return utils.format_api_error(404,
_('Resource routing not found'))
if 'routing' not in kw:
return utils.format_api_error(
400, _('Request body not found'))
update_dict = kw['routing']
# values to be updated should not be empty
for field in update_dict:
value = update_dict.get(field)
if value is None or len(value.strip()) == 0:
return utils.format_api_error(
400, _("Field %(field)s can not be empty") % {
'field': field})
# the resource type should be properly provisioned.
if 'resource_type' in update_dict:
if not constants.is_valid_resource_type(
update_dict['resource_type']):
return utils.format_api_error(
400, _('There is no such resource type'))
# the pod with new pod_id should exist in pod table
if 'pod_id' in update_dict:
new_pod_id = update_dict.get('pod_id')
try:
# find the pod through the pod_id and verify whether it exists
db_api.get_pod(context, new_pod_id)
except t_exceptions.ResourceNotFound:
return utils.format_api_error(
400, _("The pod %(new_pod_id)s doesn't"
" exist") % {'new_pod_id': new_pod_id})
except Exception as e:
LOG.exception('Failed to update resource routing: '
'%(exception)s ', {'exception': e})
return utils.format_api_error(
500, _('Failed to update resource routing'))
try:
routing_updated = db_api.update_resource_routing(
context, _id, update_dict)
return {'routing': routing_updated}
except Exception as e:
LOG.exception('Failed to update resource routing: '
'%(exception)s ', {'exception': e})
return utils.format_api_error(
500, _('Failed to update resource routing'))
def post(self, **kw):
context = t_context.extract_context_from_environ()
if not t_context.is_admin_context(context):
pecan.abort(400, _('Admin role required to create bindings'))
return
if 'pod_binding' not in kw:
pecan.abort(400, _('Request body not found'))
return
pod_b = kw['pod_binding']
tenant_id = pod_b.get('tenant_id', '').strip()
pod_id = pod_b.get('pod_id', '').strip()
_uuid = uuidutils.generate_uuid()
if tenant_id == '' or pod_id == '':
return Response(_('Tenant_id and pod_id can not be empty'), 422)
# the az_pod_map_id should be exist for in the pod map table
try:
with context.session.begin():
pod = core.get_resource(context, models.Pod, pod_id)
if pod.get('az_name') == '':
return Response(_('Top region can not be bound'), 422)
except t_exc.ResourceNotFound:
return Response(_('pod_id not found in pod'), 422)
except Exception as e:
LOG.exception(
_LE('Failed to get_resource for pod_id: '
'%(pod_id)s ,'
'%(exception)s '), {
'pod_id': pod_id,
'exception': e
})
pecan.abort(500, _('Failed to create pod binding'))
return
try:
with context.session.begin():
pod_binding = core.create_resource(context, models.PodBinding,
{
'id': _uuid,
'tenant_id': tenant_id,
'pod_id': pod_id
})
except db_exc.DBDuplicateEntry:
return Response(_('Pod binding already exists'), 409)
except db_exc.DBConstraintError:
return Response(_('pod_id not exists in pod'), 422)
except db_exc.DBReferenceError:
return Response(_('DB reference not exists in pod'), 422)
except Exception as e:
LOG.exception(_LE('Failed to create pod binding: %(exception)s '),
{'exception': e})
pecan.abort(500, _('Failed to create pod binding'))
return
return {'pod_binding': pod_binding}
def get_one(self, _id):
context = t_context.extract_context_from_environ()
if _id == 'detail':
return self.get_all()
image = self.client.get_images(context, _id)
if not image:
return utils.format_nova_error(404, _('Image not found'))
return {'image': self._construct_show_image_entry(context, image)}
def get_all(self):
context = t_context.extract_context_from_environ()
images = self.client.list_images(context)
ret_images = [
self._construct_list_image_entry(context, image)
for image in images
]
return {'images': ret_images}
def get_all(self):
context = t_context.extract_context_from_environ()
with context.session.begin():
flavors = core.query_resource(context, models.InstanceTypes,
[], [])
return {'flavors': [dict(
[('id', flavor['flavorid']),
('name', flavor['name'])]) for flavor in flavors]}
def get_one(self, _id):
context = t_context.extract_context_from_environ()
try:
with context.session.begin():
aggregate = az_ag.get_one_ag(context, _id)
return {'aggregate': aggregate}
except t_exc.ResourceNotFound:
pecan.abort(404, 'Aggregate not found')
return
def delete(self, _id):
context = t_context.extract_context_from_environ()
try:
with context.session.begin():
az_ag.delete_ag(context, _id)
pecan.response.status = 200
except t_exc.ResourceNotFound:
pecan.abort(404, 'Aggregate not found')
return
def get_one(self, _id):
context = t_context.extract_context_from_environ()
try:
with context.session.begin():
aggregate = az_ag.get_one_ag(context, _id)
return {'aggregate': aggregate}
except t_exc.ResourceNotFound:
pecan.abort(404, 'Aggregate not found')
return
def put(self, **kw):
context = t_context.extract_context_from_environ()
if not context.is_admin:
# TODO(joahuang): changed to policy control later
# to support reseller admin mode
return Response(_('Admin role required to update quota'), 409)
return self._quota_action('put', **kw)
def index(self):
if pecan.request.method != 'GET':
pecan.abort(405)
context = ctx.extract_context_from_environ()
payload = '#result from xjob rpc'
return self.xjobapi.test_rpc(context, payload)
def get_all(self):
context = t_context.extract_context_from_environ()
try:
with context.session.begin():
aggregates = az_ag.get_all_ag(context)
except Exception:
pecan.abort(500, 'Fail to get all host aggregates')
return
return {'aggregates': aggregates}
def post(self, **kw):
context = t_context.extract_context_from_environ()
if not t_context.is_admin_context(context):
pecan.abort(400, _('Admin role required to create bindings'))
return
if 'pod_binding' not in kw:
pecan.abort(400, _('Request body not found'))
return
pod_b = kw['pod_binding']
tenant_id = pod_b.get('tenant_id', '').strip()
pod_id = pod_b.get('pod_id', '').strip()
_uuid = uuidutils.generate_uuid()
if tenant_id == '' or pod_id == '':
return Response(
_('Tenant_id and pod_id can not be empty'),
422)
# the az_pod_map_id should be exist for in the pod map table
try:
with context.session.begin():
pod = core.get_resource(context, models.Pod,
pod_id)
if pod.get('az_name') == '':
return Response(_('Top region can not be bound'), 422)
except t_exc.ResourceNotFound:
return Response(_('pod_id not found in pod'), 422)
except Exception as e:
LOG.error(_LE('Fail to create pod binding: %(exception)s'),
{'exception': e})
pecan.abort(500, _('Fail to create pod binding'))
return
try:
with context.session.begin():
pod_binding = core.create_resource(context, models.PodBinding,
{'id': _uuid,
'tenant_id': tenant_id,
'pod_id': pod_id})
except db_exc.DBDuplicateEntry:
return Response(_('Pod binding already exists'), 409)
except db_exc.DBConstraintError:
return Response(_('pod_id not exists in pod'), 422)
except db_exc.DBReferenceError:
return Response(_('DB reference not exists in pod'), 422)
except Exception as e:
LOG.error(_LE('Fail to create pod binding: %(exception)s'),
{'exception': e})
pecan.abort(500, _('Fail to create pod binding'))
return
return {'pod_binding': pod_binding}
def get_one(self, _id):
context = t_context.extract_context_from_environ()
if _id == 'detail':
return {'volumes': self._get_all(context)}
# TODO(joehuang): get the release of top and bottom
t_release = 'MITATA'
b_release = 'MITATA'
b_headers = self._convert_header(t_release,
b_release,
request.headers)
s_ctx = self._get_res_routing_ref(context, _id, request.url)
if not s_ctx:
return Response(_('Failed to find resource'), 404)
if s_ctx['b_url'] == '':
return Response(_('bottom pod endpoint incorrect'), 404)
resp = hclient.forward_req(context, 'GET',
b_headers,
s_ctx['b_url'],
request.body)
b_ret_body = jsonutils.loads(resp.content)
b_status = resp.status_code
response.status = b_status
if b_status == 200:
if b_ret_body.get('volume') is not None:
b_vol_ret = b_ret_body['volume']
ret_vol = self._convert_object(b_release, t_release,
b_vol_ret,
res_type=cons.RT_VOLUME)
pod = self._get_pod_by_top_id(context, _id)
if pod:
ret_vol['availability_zone'] = pod['az_name']
return {'volume': ret_vol}
# resource not find but routing exist, remove the routing
if b_status == 404:
filters = [{'key': 'top_id', 'comparator': 'eq', 'value': _id},
{'key': 'resource_type',
'comparator': 'eq',
'value': cons.RT_VOLUME}]
with context.session.begin():
core.delete_resources(context,
models.ResourceRouting,
filters)
return b_ret_body
def post(self, **kw):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_BINDINGS_CREATE):
pecan.abort(401, _('Unauthorized to create bindings'))
return
if 'pod_binding' not in kw:
pecan.abort(400, _('Request body not found'))
return
pod_b = kw['pod_binding']
tenant_id = pod_b.get('tenant_id', '').strip()
pod_id = pod_b.get('pod_id', '').strip()
if tenant_id == '' or pod_id == '':
return Response(
_('Tenant_id and pod_id can not be empty'),
422)
# the az_pod_map_id should be exist for in the pod map table
try:
with context.session.begin():
pod = core.get_resource(context, models.Pod,
pod_id)
if pod.get('az_name') == '':
return Response(_('Top region can not be bound'), 422)
except t_exc.ResourceNotFound:
return Response(_('pod_id not found in pod'), 422)
except Exception as e:
LOG.exception(_LE('Failed to get_resource for pod_id: '
'%(pod_id)s ,'
'%(exception)s '),
{'pod_id': pod_id,
'exception': e})
pecan.abort(500, _('Failed to create pod binding'))
return
try:
pod_binding = db_api.create_pod_binding(
context, tenant_id, pod_id)
except db_exc.DBDuplicateEntry:
return Response(_('Pod binding already exists'), 409)
except db_exc.DBConstraintError:
return Response(_('pod_id not exists in pod'), 422)
except db_exc.DBReferenceError:
return Response(_('DB reference not exists in pod'), 422)
except Exception as e:
LOG.exception(_LE('Failed to create pod binding: %(exception)s '),
{'exception': e})
pecan.abort(500, _('Failed to create pod binding'))
return
return {'pod_binding': pod_binding}
def get_one(self, _id):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_PODS_SHOW):
pecan.abort(401, _('Unauthorized to show pods'))
return
try:
return {'pod': db_api.get_pod(context, _id)}
except t_exc.ResourceNotFound:
pecan.abort(404, _('Pod not found'))
return
def get_one(self, _id):
context = t_context.extract_context_from_environ()
if not t_context.is_admin_context(context):
pecan.abort(400, _('Admin role required to show pods'))
return
try:
return {'pod': db_api.get_pod(context, _id)}
except t_exc.ResourceNotFound:
pecan.abort(404, _('Pod not found'))
return
def get_one(self, _id):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_ROUTINGS_SHOW):
return utils.format_api_error(
403, _('Unauthorized to show the resource routing'))
try:
return {'routing': db_api.get_resource_routing(context, _id)}
except t_exc.ResourceNotFound:
return utils.format_api_error(
404, _('Resource routing not found'))
def delete(self, _id):
context = t_context.extract_context_from_environ()
if not t_context.is_admin_context(context):
pecan.abort(400, _('Admin role required to delete bindings'))
return
try:
with context.session.begin():
core.delete_resource(context, models.PodBinding, _id)
pecan.response.status = 200
except t_exc.ResourceNotFound:
pecan.abort(404, _('Pod binding not found'))
return
def post(self, **kw):
context = t_context.extract_context_from_environ()
if 'volumeAttachment' not in kw:
pecan.abort(400, 'Request body not found')
return
body = kw['volumeAttachment']
if 'volumeId' not in body:
pecan.abort(400, 'Volume not set')
return
server_mappings = db_api.get_bottom_mappings_by_top_id(
context, self.server_id, constants.RT_SERVER)
if not server_mappings:
pecan.abort(404, 'Server not found')
return
volume_mappings = db_api.get_bottom_mappings_by_top_id(
context, body['volumeId'], constants.RT_VOLUME)
if not volume_mappings:
pecan.abort(404, 'Volume not found')
return
server_pod_name = server_mappings[0][0]['pod_name']
volume_pod_name = volume_mappings[0][0]['pod_name']
if server_pod_name != volume_pod_name:
LOG.error(_LE('Server %(server)s is in pod %(server_pod)s and '
'volume %(volume)s is in pod %(volume_pod)s, which '
'are not the same.'),
{'server': self.server_id,
'server_pod': server_pod_name,
'volume': body['volumeId'],
'volume_pod': volume_pod_name})
pecan.abort(400, 'Server and volume not in the same pod')
return
device = None
if 'device' in body:
device = body['device']
# this regular expression is copied from nova/block_device.py
match = re.match('(^/dev/x{0,1}[a-z]{0,1}d{0,1})([a-z]+)[0-9]*$',
device)
if not match:
pecan.abort(400, 'Invalid device path')
return
client = self._get_client(server_pod_name)
volume = client.action_server_volumes(
context, 'create_server_volume',
server_mappings[0][1], volume_mappings[0][1], device)
return {'volumeAttachment': volume.to_dict()}
def get_all(self):
context = t_context.extract_context_from_environ()
if not t_context.is_admin_context(context):
pecan.abort(400, _('Admin role required to list pods'))
return
try:
return {'pods': db_api.list_pods(context)}
except Exception as e:
LOG.error(_LE('Fail to list pod: %(exception)s'),
{'exception': e})
pecan.abort(500, _('Fail to list pod'))
return
def delete(self, _id):
context = t_context.extract_context_from_environ()
with context.session.begin():
flavors = core.query_resource(context, models.InstanceTypes,
[{'key': 'flavorid',
'comparator': 'eq',
'value': _id}], [])
if not flavors:
pecan.abort(404, 'Flavor not found')
return
core.delete_resource(context,
models.InstanceTypes, flavors[0]['id'])
pecan.response.status = 202
return
def _quota_action(self, action, **kw):
context = t_context.extract_context_from_environ()
context.project_id = self.owner_tenant_id
target_tenant_id = self.target_tenant_id
target_user_id = request.params.get('user_id', None)
if target_user_id:
target_user_id.strip()
qs = quota.QuotaSetOperation(target_tenant_id,
target_user_id)
quotas = {}
try:
if action == 'put':
quotas = qs.update(context, **kw)
elif action == 'delete':
qs.delete(context)
response.status = 202
return
elif action == 'defaults':
quotas = qs.show_default_quota(context)
elif action == 'detail':
quotas = qs.show_detail_quota(context, show_usage=True)
# remove the allocated field which is not visible in Nova
for k, v in quotas['quota_set'].iteritems():
if k != 'id':
v.pop('allocated', None)
elif action == 'quota-show':
quotas = qs.show_detail_quota(context, show_usage=False)
else:
return Response('Resource not found', 404)
except t_exceptions.NotFound as e:
msg = str(e)
LOG.exception(msg=msg)
return Response(msg, 404)
except (t_exceptions.AdminRequired,
t_exceptions.NotAuthorized,
t_exceptions.HTTPForbiddenError) as e:
msg = str(e)
LOG.exception(msg=msg)
return Response(msg, 403)
except Exception as e:
msg = str(e)
LOG.exception(msg=msg)
return Response(msg, 400)
return {'quota_set': self._build_visible_quota(quotas['quota_set'])}
def get_all(self):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_PODS_LIST):
pecan.abort(401, _('Unauthorized to list pods'))
return
try:
return {'pods': db_api.list_pods(context)}
except Exception as e:
LOG.exception(_LE('Failed to list all pods: %(exception)s '),
{'exception': e})
pecan.abort(500, _('Failed to list pods'))
return
def delete(self, _id):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_BINDINGS_DELETE):
pecan.abort(401, _('Unauthorized to delete bindings'))
return
try:
with context.session.begin():
core.delete_resource(context, models.PodBinding, _id)
pecan.response.status = 200
return {}
except t_exc.ResourceNotFound:
pecan.abort(404, _('Pod binding not found'))
return
def get_one(self, _id):
context = t_context.extract_context_from_environ()
if not t_context.is_admin_context(context):
pecan.abort(400, _('Admin role required to show bindings'))
return
try:
with context.session.begin():
pod_binding = core.get_resource(context,
models.PodBinding,
_id)
return {'pod_binding': pod_binding}
except t_exc.ResourceNotFound:
pecan.abort(404, _('Tenant pod binding not found'))
return
def get_one(self, _id):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_BINDINGS_SHOW):
pecan.abort(401, _('Unauthorized to show bindings'))
return
try:
with context.session.begin():
pod_binding = core.get_resource(context,
models.PodBinding,
_id)
return {'pod_binding': pod_binding}
except t_exc.ResourceNotFound:
pecan.abort(404, _('Tenant pod binding not found'))
return
def post(self, **kw):
context = t_context.extract_context_from_environ()
if not policy.enforce(context, policy.ADMIN_API_ROUTINGS_CREATE):
return utils.format_api_error(
403, _("Unauthorized to create resource routing"))
if 'routing' not in kw:
return utils.format_api_error(
400, _("Request body not found"))
routing = kw['routing']
for field in ('top_id', 'bottom_id', 'pod_id',
'project_id', 'resource_type'):
value = routing.get(field)
if value is None or len(value.strip()) == 0:
return utils.format_api_error(
400, _("Field %(field)s can not be empty") % {
'field': field})
# the resource type should be properly provisioned.
resource_type = routing.get('resource_type').strip()
if not constants.is_valid_resource_type(resource_type):
return utils.format_api_error(
400, _('There is no such resource type'))
try:
top_id = routing.get('top_id').strip()
bottom_id = routing.get('bottom_id').strip()
pod_id = routing.get('pod_id').strip()
project_id = routing.get('project_id').strip()
routing = db_api.create_resource_mapping(context, top_id,
bottom_id, pod_id,
project_id,
resource_type)
if not routing:
return utils.format_api_error(
409, _('Resource routing already exists'))
except Exception as e:
LOG.exception('Failed to create resource routing: '
'%(exception)s ', {'exception': e})
return utils.format_api_error(
500, _('Failed to create resource routing'))
return {'routing': routing}
