@expose()
def _lookup(self, collection, *remainder):
controller = manager.NeutronManager.get_controller_for_resource(collection)
if not controller:
LOG.warn(_LW("No controller found for: %s - returning response " "code 404"), collection)
pecan.abort(404)
# Store resource name in pecan request context so that hooks can
# leverage it if necessary
request.context["resource"] = controller.resource
return controller, remainder
# This controller cannot be specified directly as a member of RootController
# as its path is not a valid python identifier
pecan.route(RootController, "v2.0", V2Controller())
class ExtensionController(object):
def __init__(self, alias):
self.alias = alias
@expose()
def index(self):
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
ext = ext_mgr.extensions.get(self.alias, None)
if not ext:
pecan.abort(404, detail=_("Extension with alias %s " "does not exist") % self.alias)
return {"extension": extensions.ExtensionController._translate(ext)}
# Copyright 2017 DataCentred Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import pecan
from sentinel.api.controllers.volume.v2 import quota_sets
from sentinel.api.controllers.volume.v2 import volumes
class VolumeV2Controller(object):
def __init__(self):
self.volumes = volumes.VolumeV2VolumesController()
pecan.route(VolumeV2Controller, 'os-quota-sets',
quota_sets.VolumeV2QuotaSetsController())
# vi: ts=4 et:
link.Link.make_link('describedby',
'http://docs.openstack.org',
'developer/valence/dev',
'api-spec-v1.html',
bookmark=True,
type='text/html')
]
v1.media_types = [
MediaType(base='application/json',
type='application/vnd.openstack.valence.v1+json')
]
v1.services = [
link.Link.make_link('self', request.host_url, 'services', ''),
link.Link.make_link('bookmark',
request.host_url,
'services',
'',
bookmark=True)
]
return v1
class V1Controller(object):
@expose('json')
def index(self):
return V1.convert()
route(V1Controller, 'person', v1person.PersonController())
route(V1Controller, 'book', v1book.BookController())
'validate': types.Text.validate
},
'description': {
'validate': types.Text.validate
},
'versions': {
'validate': types.List(types.Custom(Version)).validate
},
'default_version': {
'validate': types.Custom(Version).validate
},
}
@staticmethod
def convert():
root = Root()
root.name = "OpenStack Valence API"
root.description = ("Valence is an OpenStack project")
root.versions = [Version.convert('v1')]
root.default_version = Version.convert('v1')
return root
class RootController(object):
@expose('json')
def index(self):
return Root.convert()
route(RootController, 'v1', v1controller.V1Controller())
import pecan
LOG = log.getLogger(__name__)
class V1Controller(secure.SecureController):
"""Version 1 API controller root."""
plans = plans.PlansController()
triage_tool = triage.TriageController()
load_latency_rules = latency_reduction_loader.LatencyLoaderController()
load_latency_country_rules = latency_country_rules_loader.LatencyCountryRulesLoaderController(
)
@classmethod
def check_permissions(cls):
"""SecureController permission check callback"""
return True
# error('/errors/unauthorized', msg)
@pecan.expose(generic=True, template='json')
def index(self):
"""Catchall for unallowed methods"""
message = _('The %s method is not allowed.') % pecan.request.method
kwargs = {}
error('/errors/not_allowed', message, **kwargs)
#TODO(larry): understand pecan and change the following code
pecan.route(V1Controller, 'release-orders', release_orders.LocksController())
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
import pecan
from sentinel.api.controllers.network.v2 import root as v2
class NetworkController(object):
def __init__(self):
pass
pecan.route(NetworkController, 'v2.0', v2.NetworkV2Controller())
class Service(object):
service_name = u'neutron'
service_type = u'network'
service_endpoint = u'/network'
@staticmethod
def controller():
return NetworkController()
# vi: ts=4 et:
'developer/plasma/dev',
'api-spec-v1.html',
bookmark=True,
type='text/html')
]
v1.media_types = [
MediaType(base='application/json',
type='application/vnd.openstack.plasma.v1+json')
]
v1.services = [
link.Link.make_link('self', request.host_url, 'services', ''),
link.Link.make_link('bookmark',
request.host_url,
'services',
'',
bookmark=True)
]
return v1
class V1Controller(object):
@expose('json')
def index(self):
return V1.convert()
route(V1Controller, 'flavor', v1flavor.FlavorController())
route(V1Controller, 'nodes', v1nodes.NodesController())
route(V1Controller, 'power', v1nodes.NodePowerController())
route(V1Controller, 'bootsource', v1nodes.NodeBootSourceController())
fields = {
'id': {
'validate': types.Text.validate
},
'description': {
'validate': types.Text.validate
},
'versions': {
'validate': types.List(types.Custom(Version)).validate
},
'default_version': {
'validate': types.Custom(Version).validate
},
}
@staticmethod
def convert():
root = Root()
root.name = "OpenStack Plasma API"
root.description = ("Plasma is an OpenStack project")
root.versions = [Version.convert('v1')]
root.default_version = Version.convert('v1')
return root
class RootController(object):
@expose('json')
def index(self):
return Root.convert()
route(RootController, 'v1', v1controller.V1Controller())
# distributed under the License is distributed on an "AS IS" BASIS,
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
#
# -------------------------------------------------------------------------
#
from oslo_log import log
import pecan
from pecan import expose
from conductor.api import latency_dataloader
LOG = log.getLogger(__name__)
class LatencyLoadController(object):
def __init__(self):
pass
@expose(generic=True, template='json')
def index(self):
return 'call to get method'
@index.when(method='POST', template='json')
def index_POST(self, **kwargs):
return kwargs['data']
pecan.route(LatencyLoadController, 'data-loader',
latency_dataloader.LatencyDataLoader())
#coding=utf-8
#
# Copyright (c) 2021 Wind River Systems, Inc.
#
# SPDX-License-Identifier: Apache-2.0
#
from pecan import expose, redirect, rest, route, response
from webob.exc import status_map
from wsme import types as wtypes
from wsmeext.pecan import wsexpose
class HealthController(rest.RestController):
@wsexpose(wtypes.text)
def get(self):
return {'health': True}
class RootController(object):
pass
route(RootController, 'health', HealthController())
# Copyright 2017 DataCentred Ltd
#
# Licensed under the Apache License, Version 2.0 (the "License"); you may
# not use this file except in compliance with the License. You may obtain
# a copy of the License at
#
# http://www.apache.org/licenses/LICENSE-2.0
#
# Unless required by applicable law or agreed to in writing, software
# distributed under the License is distributed on an "AS IS" BASIS, WITHOUT
# WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the
# License for the specific language governing permissions and limitations
# under the License.
"""Root controller for /compute/v2"""
import pecan
from sentinel.api.controllers.compute.v2 import quota_sets
from sentinel.api.controllers.compute.v2 import servers
class ComputeV2Controller(object):
def __init__(self):
self.servers = servers.ComputeV2ServersController()
pecan.route(ComputeV2Controller, 'os-quota-sets',
quota_sets.ComputeV2QuotaSetsController())
# vi: ts=4 et:
@expose('json')
@expose('text_template.html', content_type='text/plain')
@expose('html_template.html')
def hellostack(self):
return {'msg': 'Hello!'}
@expose(route='some-path1')
def some_path1(self):
return dict()
@expose(route='some-path2')
def some_path2(self):
return dict()
# HTTP GET /
@expose(generic=True, template='json')
def index(self):
return dict()
# HTTP POST /
@index.when(method='POST', template='json')
def index_POST(self, **kw):
uuid = 'uuid'
return dict(uuid=uuid)
# /catalog
pecan.route(RootController, 'catalog', CatalogController())
# /some-path
pecan.route('some-path2', RootController.some_path2)
import pecan
from imagehub.controllers import hub
from pecan import expose
class RootController(object):
@expose(template='json')
def _default(self):
return 'url path is wrong'
pecan.route(RootController, 'image-hub', hub.ImageHubController())
except client_exception.ResourceNotAvailable as ex:
LOG.warning("Resource is not available:{0}".format(str(ex)))
abort(404)
except oslo_messaging.exceptions.MessagingTimeout as ex:
LOG.warning("Resource is not reachable:{0}".format(str(ex)))
abort(404)
except HTTPException as ex:
LOG.warning("Client side error:{0},{1}".format(type(ex), str(ex)))
# raise ex
abort(400)
except HTTPServerError as ex:
LOG.error("Server side error:{0},{1}".format(type(ex), str(ex)))
# raise ex
abort(500)
except Exception as ex:
LOG.error("Exception:{0}@{1}".format(type(ex), str(ex)))
abort(500)
class PtpController(rest.RestController):
def __init__(self):
pass
@wsexpose(wtypes.text)
def get(self):
return 'ptp'
route(PtpController, 'CurrentState', CurrentStateController())
route(PtpController, 'currentstate', CurrentStateController())
@staticmethod
def convert():
v1 = V1()
v1.id = "v1"
v1.links = [link.Link.make_link('self', request.host_url,
'v1', '', bookmark=True),
link.Link.make_link('describedby',
'http://docs.openstack.org',
'developer/plasma/dev',
'api-spec-v1.html',
bookmark=True, type='text/html')]
v1.media_types = [MediaType(base='application/json',
type='application/vnd.openstack.plasma.v1+json')]
v1.services = [link.Link.make_link('self', request.host_url,
'services', ''),
link.Link.make_link('bookmark',
request.host_url,
'services', '',
bookmark=True)]
return v1
class V1Controller(object):
@expose('json')
def index(self):
return V1.convert()
route(V1Controller, 'flavor', v1flavor.FlavorController())
route(V1Controller, 'nodes', v1nodes.NodesController())
return [{'level': record.levelname,
'time':
self.catchall_lg_log_handler.formatter.formatTime(record),
'name': record.name,
'message': record.msg}
for record in self.catchall_lg_log_handler.get_records()]
class RootController(object):
@expose(generic=True)
def index(self):
return {}
@when(index, method='POST')
@when(index, method='PUT')
@when(index, method='DELETE')
def not_supported(self):
pecan.abort(405)
ping = PingController()
attach_localport = AttachController()
detach_localport = DetachController()
def stop(self):
VPNManagerController.stop()
# there is a '-' in the LOOKING_GLASS_BASE name, so we have to use pecan.route
pecan.route(RootController, LOOKING_GLASS_BASE, LookingGlassController())
import pecan
from pecan import rest
from wsme import types as wtypes
from wsmeext import pecan as wsme_pecan
from octavia.api.v1 import controllers as v1_controller
from octavia.api.v2 import controllers as v2_controller
class RootController(rest.RestController):
"""The controller in which the pecan wsgi app should be created with."""
v1 = v1_controller.V1Controller()
@wsme_pecan.wsexpose(wtypes.text)
def get(self):
# TODO(blogan): once a decision is made on how to do versions, do that
# here
return {'versions': [{'status': 'CURRENT',
'updated': '2014-12-11T00:00:00Z',
'id': 'v1'},
{'status': 'EXPERIMENTAL',
'updated': '2016-12-11T00:00:00Z',
'id': 'v2.0'}
]}
# This controller cannot be specified directly as a member of RootController
# as its path is not a valid python identifier
pecan.route(RootController, 'v2.0', v2_controller.V2Controller())
class RootController(object):
@expose(generic=True, template='index.html')
def index(self):
return dict()
@expose('json', route='hello_asd')
def hello(self):
return {'msg': 'Hello!'}
@index.when(method='POST')
def index_post(self, q):
redirect('https://pecan.readthedocs.io/en/latest/search.html?q=%s' % q)
@expose('error.html')
def error(self, status):
try:
status = int(status)
except ValueError: # pragma: no cover
status = 500
message = getattr(status_map.get(status), 'explanation', '')
return dict(status=status, message=message)
class ChildController(object):
@expose()
def child(self):
return {'msg': 'Child!'}
route(RootController, 'child', ChildController())
controller = manager.NeutronManager.get_controller_for_resource(
collection)
if not controller:
LOG.warn(_LW("No controller found for: %s - returning response "
"code 404"), collection)
pecan.abort(404)
# Store resource and collection names in pecan request context so that
# hooks can leverage them if necessary
request.context['resource'] = controller.resource
request.context['collection'] = collection
return controller, remainder
# This controller cannot be specified directly as a member of RootController
# as its path is not a valid python identifier
pecan.route(RootController, 'v2.0', V2Controller())
class ExtensionController(object):
def __init__(self, alias):
self.alias = alias
@utils.expose()
def index(self):
ext_mgr = extensions.PluginAwareExtensionManager.get_instance()
ext = ext_mgr.extensions.get(self.alias, None)
if not ext:
pecan.abort(
404, detail=_("Extension with alias %s "
"does not exist") % self.alias)
class RootController(rest.RestController):
@pecan.expose()
def _route(self, args):
"""Overrides the default routing behavior.
It redirects the request to the default version of the magnum API
if the version number is not specified in the url.
"""
return super(RootController, self)._route(args)
#pass
#@pecan.expose("json")
#def _route(self, args):
# ver = version.Version(pecan.request.headers, MIN_VER_STR, MAX_VER_STR)
# # settign the basic version header
# pecan.response.headers[version.Version.min_string] = MIN_VER_STR
# pecan.response.headers[version.Version.max_string] = MAX_VER_STR
# pecan.request.version = ver
# return super(RootController, self)._route(args)
pecan.route(RootController, 'api', api.ApiController())
pecan.route(api.ApiController, 'v1', routed_controller.RoutedController())
