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 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 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 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 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 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 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 add_router_interface(self):
context = t_context.extract_context_from_environ()
body = {"core_router_interface": request.context['request_data']}
attr_info = body_validation.RESOURCE_ATTRIBUTE_MAP.get(self.resource)
body_validation.BodyValidationHook.check_request_body(
body, True, "core_router_interface", attr_info)
fabric = request.context['request_data']['fabric']
_uuid = uuidutils.generate_uuid()
try:
with context.session.begin():
core_router_object = core.get_resource_object(
context, models.CoreRouter, self.core_router_id)
new_core_router_interface = core.create_resource(
context, models.CoreRouterInterface, {
'interface_id': _uuid,
'project_id': core_router_object.project_id,
'core_router_id': self.core_router_id,
'fabric': fabric,
})
except t_exceptions.ResourceNotFound as e:
LOG.exception(
'Failed to add core_router_interface : '
'core_router_id %(core_router_id)s ,'
'%(exception)s ', {
'core_router_id': self.core_router_id,
'exception': e
})
return m.CoreRouterNotFound(
core_router_id=self.core_router_id).to_dict()
except db_exc.DBDuplicateEntry as e1:
LOG.exception(
'Failed to create core_router_interface :'
'core_router_id: %(core_router_id)s,'
'fabric: %(fabric)s,'
'%(exception)s ', {
'core_router_id': self.core_router_id,
'fabric': fabric,
'exception': e1
})
return_object = m.CoreRouterInterfaceForFabricExists(fabric=fabric)
return return_object.to_dict()
except Exception as e2:
LOG.exception(
'Failed to create core_router_interface :'
'core_router_id: %(core_router_id)s,'
'fabric: %(fabric)s,'
'%(exception)s ', {
'core_router_id': self.core_router_id,
'fabric': fabric,
'exception': e2
})
return_object = m.FailureMessage()
return return_object.to_dict()
return_object = m.SuccessMessage(
result={'core_router_interface': new_core_router_interface})
return return_object.to_dict()
def remove_router_interface(self):
context = t_context.extract_context_from_environ()
body = {"core_router_interface": request.context['request_data']}
attr_info = body_validation.RESOURCE_ATTRIBUTE_MAP.get(self.resource)
body_validation.BodyValidationHook.check_request_body(
body, True, "core_router_interface", attr_info)
fabric = request.context['request_data']['fabric']
try:
with context.session.begin():
core.get_resource(context, models.CoreRouter,
self.core_router_id)
interface_filters = [{
'key': 'core_router_id',
'comparator': 'eq',
'value': self.core_router_id
}, {
'key': 'fabric',
'comparator': 'eq',
'value': fabric
}]
interfaces = core.query_resource(context,
models.CoreRouterInterface,
interface_filters, [])
if (not len(interfaces) > 0):
raise t_exceptions.CoreRouterInterfaceDeleteNotFound(
core_router_id=self.core_router_id, fabric=fabric)
core.delete_resources(context, models.CoreRouterInterface,
interface_filters)
return_object = m.SuccessMessage(result={})
return return_object.to_dict()
except t_exceptions.ResourceNotFound as e:
LOG.exception(
'Failed to delete core_router_interface : '
'core_router_id %(core_router_id)s ,'
'%(exception)s ', {
'core_router_id': self.core_router_id,
'exception': e
})
return m.CoreRouterNotFound(
core_router_id=self.core_router_id).to_dict()
except t_exceptions.CoreRouterInterfaceDeleteNotFound:
return m.CoreRouterInterfaceNotFound(
core_router_id=self.core_router_id, fabric=fabric).to_dict()
except Exception as e:
LOG.exception(
'Failed to delete core_router_interface :'
'core_router_id: %(core_router_id)s,'
'fabric: %(fabric)s,'
'%(exception)s ', {
'core_router_id': self.core_router_id,
'fabric': fabric,
'exception': e
})
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 core_router'))
return
try:
with context.session.begin():
core_router_object = core.get_resource_object(
context, models.CoreRouter, _id)
if len(core_router_object.interfaces) > 0:
raise t_exceptions.CoreRouterInUseInterfacesException(
core_router_id=_id,
count=len(core_router_object.interfaces))
if len(core_router_object.firewall_bypasss) > 0:
raise t_exceptions.CoreRouterInUseFirewallBypasssException(
core_router_id=_id,
count=len(core_router_object.firewall_bypasss))
core.delete_resource(context, models.CoreRouter, _id)
return_object = m.SuccessMessage(result={})
return return_object.to_dict()
except t_exceptions.ResourceNotFound as e:
LOG.exception(
'Failed to delete 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 t_exceptions.CoreRouterInUse as e:
LOG.exception(
'Failed to delete core_router: '
'%(core_router_id)s,'
'%(exception)s', {
'core_router_id': _id,
'exception': e
})
return_object = m.CoreRouterInUse(str(e))
return return_object.to_dict()
except Exception as e:
LOG.exception(
'Failed to delete core_router: '
'%(core_router_id)s,'
'%(exception)s', {
'core_router_id': _id,
'exception': e
})
return_object = m.FailureMessage()
return return_object.to_dict()
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 route_entry'))
return
try:
return_object = m.SuccessMessage(
result={'route_entrys': db_api.list_route_entrys(context)})
return return_object.to_dict()
except Exception as e:
LOG.exception('Failed to list route_entrys: '
'%(exception)s ', {'exception': e})
return_object = m.FailureMessage()
return return_object.to_dict()
def put(self, _id, **kw):
context = t_context.extract_context_from_environ()
route_entry = request.context['request_data']['route_entry']
try:
with context.session.begin():
core.get_resource_object(context, models.RouteEntry, _id)
if 'destination_cidr_list' in route_entry:
self._update_route_entry_destination_cidrs(
context, _id, route_entry)
route_entry_updated = core.update_resource(
context, models.RouteEntry, _id, route_entry)
return_object = m.SuccessMessage(
result={'route_entry': route_entry_updated})
return return_object.to_dict()
except t_exceptions.ResourceNotFound as e1:
LOG.exception(
'Failed to update route_entry : '
'id%(id)s ,'
'%(exception)s ', {
'id': _id,
'exception': e1
})
return m.RouteEntryNotFound(id=_id).to_dict()
except Exception as e2:
LOG.exception(
'Failed to update route_entry: '
'id: %(id)s,'
'%(exception)s ', {
'id': _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 policy.enforce(context, policy.ADMIN_API_PODS_CREATE):
pecan.abort(401, _('Unauthorized to create core_router'))
return
core_router = request.context['request_data']['core_router']
_uuid = uuidutils.generate_uuid()
dc = core_router.get('dc')
project_id = core_router.get('project_id', '').strip()
core_router_name = core_router.get('core_router_name', '').strip()
admin_state_up = core_router.get('admin_state_up', True)
status = core_router.get('status', "DOWN")
description = core_router.get('description', '').strip()
routes = core_router.get('routes')
try:
with context.session.begin():
new_core_router = core.create_resource(
context, models.CoreRouter, {
'id': _uuid,
'dc': dc,
'project_id': project_id,
'core_router_name': core_router_name,
'admin_state_up': admin_state_up,
'status': status,
'description': description
})
if validators.is_attr_set(routes):
self._create_routerroutes(context, _uuid, routes)
new_core_router = core.get_resource(context, models.CoreRouter,
_uuid)
return_object = m.SuccessMessage(
result={'core_router': new_core_router})
return return_object.to_dict()
except db_exc.DBDuplicateEntry as e1:
LOG.exception(
'Record core_router already exists for '
'dc %(dc)s: '
'%(exception)s', {
'dc': dc,
'exception': e1
})
return_object = m.CoreRouterForDCExists(dc=dc)
return return_object.to_dict()
except Exception as e2:
LOG.exception(
'Failed to create core_router : '
'dc: %(dc)s,'
'project_id %(project_id)s: '
'core_router_name: %(core_router_name)s,'
'%(exception)s ', {
'dc': dc,
'project_id': project_id,
'core_router_name': core_router_name,
'exception': e2
})
return_object = m.FailureMessage()
return return_object.to_dict()
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 route_entry'))
return
route_entry = request.context['request_data']['route_entry']
src_router = route_entry.get('src_router', '').strip()
nxt_router = route_entry.get('nxt_router', '').strip()
project_id = route_entry.get('project_id', '').strip()
destination_cidr_list = route_entry.get('destination_cidr_list', [])
admin_state_up = route_entry.get('admin_state_up', True)
status = route_entry.get('status', "DOWN")
description = route_entry.get('description', '').strip()
_uuid = uuidutils.generate_uuid()
if src_router == nxt_router:
return_object = m.RouteEntryRouterIDSame(src_router=src_router,
nxt_router=nxt_router)
return return_object.to_dict()
try:
with context.session.begin():
new_route_entry = core.create_resource(
context, models.RouteEntry, {
'id': _uuid,
'src_router': src_router,
'nxt_router': nxt_router,
'project_id': project_id,
'admin_state_up': admin_state_up,
'status': status,
'description': description
})
if validators.is_attr_set(destination_cidr_list):
self._create_route_entry_destination_cidrs(
context, _uuid, destination_cidr_list)
new_route_entry = core.get_resource(context, models.RouteEntry,
_uuid)
return_object = m.SuccessMessage(
result={'route_entry': new_route_entry})
return return_object.to_dict()
except db_exc.DBDuplicateEntry as e1:
LOG.exception(
'Record route_entry already exists for '
'src_router %(src_router)s: '
'nxt_router%(nxt_router)s: '
'%(exception)s', {
'src_router': src_router,
'nxt_router': nxt_router,
'exception': e1
})
return_object = m.RouteEntryExists(src_router=src_router,
nxt_router=nxt_router)
return return_object.to_dict()
except Exception as e2:
LOG.exception(
'Failed to create route_entry: '
'src_router: %(src_router)s,'
'nxt_router %(nxt_router)s: '
'%(exception)s ', {
'src_router': src_router,
'nxt_router': nxt_router,
'exception': e2
})
return_object = m.FailureMessage()
return return_object.to_dict()
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 dci'))
return
dci = request.context['request_data']['dci']
fabric = dci.get('fabric', '').strip()
router_id = dci.get('router_id', '').strip()
dci_peering_id = dci.get('dci_peering_id', '').strip()
project_id = dci.get('project_id', '').strip()
dci_type = dci.get('type', '').strip()
name = dci.get('name', '').strip()
admin_state_up = dci.get('admin_state_up', True)
status = dci.get('status', "DOWN")
description = dci.get('description', '').strip()
_uuid = uuidutils.generate_uuid()
if router_id == dci_peering_id:
return_object = m.DCIRouterIDSame(router_id=router_id,
dci_peering_id=dci_peering_id,
type=dci_type)
return return_object.to_dict()
try:
with context.session.begin():
new_dci = core.create_resource(
context, models.DCI, {
'id': _uuid,
'fabric': fabric,
'router_id': router_id,
'dci_peering_id': dci_peering_id,
'type': dci_type,
'name': name,
'project_id': project_id,
'admin_state_up': admin_state_up,
'status': status,
'description': description
})
return_object = m.SuccessMessage(result={'dci': new_dci})
return return_object.to_dict()
except db_exc.DBDuplicateEntry as e1:
LOG.exception(
'Record dci already exists for '
'router_id %(router_id)s, '
'dci_peering_id %(dci_peering_id)s, '
'type %(type)s, '
'fabric %(fabric)s, '
'%(exception)s', {
'router_id': router_id,
'dci_peering_id': dci_peering_id,
'type': dci_type,
'fabric': fabric,
'exception': e1
})
return_object = m.DCIExists(router_id=router_id,
dci_peering_id=dci_peering_id,
type=dci_type)
return return_object.to_dict()
except Exception as e2:
LOG.exception(
'Failed to create dci :'
'router_id: %(router_id)s,'
'dci_peering_id: %(dci_peering_id)s,'
'type %(type)s, '
'fabric %(fabric)s, '
'%(exception)s ', {
'router_id': router_id,
'dci_peering_id': dci_peering_id,
'type': dci_type,
'fabric': fabric,
'exception': e2
})
return_object = m.FailureMessage()
return return_object.to_dict()
