@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())