OpenStack Restful API框架介绍

$ virtualenv pecan-env
$ cd pecan-env
$ source bin/activate

$ pip install pecan

$ pecan create pecan_test_project

from pecan import expose, redirect
from webob.exc import status_map

class BooksController(object):
    @expose()
    def index(self):
        return "Welcome to book section."

    @expose()
    def bestsellers(self):
        return "We have 5 books in the top 10."

class CatalogController(object):
    @expose()
    def index(self):
        return "Welcome to the catalog."

    books = BooksController()

class RootController(object):

    @expose(generic=True, template=‘index.html‘)
    def index(self):
        return dict()

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

catalog = CatalogController()

class BaseMethodController(object):

    # 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):
        return kw

basemethod = BaseMethodController()

curl http://127.0.0.1:8080/basemethod/
curl http://127.0.0.1:8080/basemethod/ -X POST -d ‘hello=world‘

class Student(object):
    def __init__(self, name):
        self.name = name

class StudentController(object):
    def __init__(self, student):
        self.student = student

    @expose()
    def name(self):
        return self.student.name

class LookupTest(object):
    @expose()
    def _lookup(self, name, *remainder):
        print ‘enr‘
        student = Student(name)
        if student:
            return StudentController(student), remainder
        else:
            abort(404)

look_test = LookupTest()

curl http://127.0.0.1:8080/look_test/66/name

class MyRestController(rest.RestController):
    @expose()
    def get(self, id):
        return id

my_restcontroller = MyRestController()

curl http://127.0.0.1:8080/my_restcontroller/13579

from pecan.hooks import PecanHook

class SimpleHook(PecanHook):

    def on_route(self, state):
        print ‘it is on route‘

    def before(self, state):
        print ‘it is before exec‘

    def after(self, state):
        print ‘it is after exec‘

    def on_error(self, state, exc):
        print ‘it is on error‘

yum install httpd mod_wsgi -y

cd pecan_test_project

python setup.py build

python setup.py install

adduser test1

Listen 0.0.0.0:8080

8080>
  ServerName thinstack-JxRcqm

  ## Vhost docroot
  DocumentRoot "/var/www/simpleapp/"

  "/var/www/simpleapp/">
    Options Indexes FollowSymLinks MultiViews
    AllowOverride None
    Require all granted
  

  ## Logging
  ErrorLog "/var/log/httpd/simpleapp_wsgi_error.log"
  ServerSignature Off
  CustomLog "/var/log/httpd/simpleapp_wsgi_access.log" combined
  SetEnvIf X-Forwarded-Proto https HTTPS=1
  WSGIApplicationGroup %{GLOBAL}
  WSGIDaemonProcess test1 display-name=simpleapp_wsgi group=test1 processes=4 threads=4 user=test1
  WSGIProcessGroup test1
  WSGIScriptAlias / "/var/www/simpleapp/app.wsgi"

# Server Specific Configurations
from pecan_test_project.my_hooks import SimpleHook
server = {
    ‘port‘: ‘8080‘,
    ‘host‘: ‘0.0.0.0‘
}

# Pecan Application Configurations
app = {
    ‘root‘: ‘pecan_test_project.controllers.root.RootController‘,
    #‘hooks‘: lambda: [SimpleHook],
    ‘modules‘: [‘pecan_test_project‘],
    ‘static_root‘: ‘%(confdir)s/public‘,
    ‘template_path‘: ‘%(confdir)s/pecan_test_project/templates‘,
    ‘debug‘: True,
    ‘errors‘: {
        404: ‘/error/404‘,
        ‘__force_dict__‘: True
    }
}

logging = {
    ‘root‘: {‘level‘: ‘INFO‘, ‘handlers‘: [‘console‘]},
    ‘loggers‘: {
        ‘pecan_test_project‘: {‘level‘: ‘DEBUG‘, ‘handlers‘: [‘console‘], ‘propagate‘: False},
        ‘pecan‘: {‘level‘: ‘DEBUG‘, ‘handlers‘: [‘console‘], ‘propagate‘: False},
        ‘py.warnings‘: {‘handlers‘: [‘console‘]},
        ‘__force_dict__‘: True
    },
    ‘handlers‘: {
        ‘console‘: {
            ‘level‘: ‘DEBUG‘,
            ‘class‘: ‘logging.StreamHandler‘,
            ‘formatter‘: ‘color‘
        },
    },
    ‘formatters‘: {
        ‘simple‘: {
            ‘format‘: (‘%(asctime)s %(levelname)-5.5s [%(name)s]‘
                       ‘[%(threadName)s] %(message)s‘)
        },
        ‘color‘: {
            ‘()‘: ‘pecan.log.ColorFormatter‘,
            ‘format‘: (‘%(asctime)s [%(padded_color_levelname)s] [%(name)s]‘
                       ‘[%(threadName)s] %(message)s‘),
        ‘__force_dict__‘: True
        }
    }
}

from pecan.deploy import deploy
application = deploy(‘/var/www/simpleapp/config.py‘)

systemctl start httpd

pip install soupsieve

############
# Metadata #
############
[composite:metadata]
use = egg:Paste#urlmap
/: meta

[pipeline:meta]
pipeline = cors metaapp

[app:metaapp]
paste.app_factory = nova.api.metadata.handler:MetadataRequestHandler.factory

[composite:osapi_compute]
use = call:nova.api.openstack.urlmap:urlmap_factory
/: oscomputeversions
/v2: openstack_compute_api_v21_legacy_v2_compatible
/v2.1: openstack_compute_api_v21

[composite:openstack_compute_api_v21]
use = call:nova.api.auth:pipeline_factory_v21
noauth2 = cors http_proxy_to_wsgi compute_req_id faultwrap sizelimit osprofiler noauth2 osapi_compute_app_v21
keystone = cors http_proxy_to_wsgi compute_req_id faultwrap sizelimit osprofiler authtoken keystonecontext osapi_compute_app_v21

[composite:openstack_compute_api_v21_legacy_v2_compatible]
use = call:nova.api.auth:pipeline_factory_v21
noauth2 = cors http_proxy_to_wsgi compute_req_id faultwrap sizelimit osprofiler noauth2 legacy_v2_compatible osapi_compute_app_v21
keystone = cors http_proxy_to_wsgi compute_req_id faultwrap sizelimit osprofiler authtoken keystonecontext legacy_v2_compatible osapi_compute_app_v21

[filter:request_id]
paste.filter_factory = oslo_middleware:RequestId.factory

[filter:compute_req_id]
paste.filter_factory = nova.api.compute_req_id:ComputeReqIdMiddleware.factory

[filter:faultwrap]
paste.filter_factory = nova.api.openstack:FaultWrapper.factory

[filter:noauth2]
paste.filter_factory = nova.api.openstack.auth:NoAuthMiddleware.factory

[filter:osprofiler]
paste.filter_factory = nova.profiler:WsgiMiddleware.factory

[filter:sizelimit]
paste.filter_factory = oslo_middleware:RequestBodySizeLimiter.factory

[filter:http_proxy_to_wsgi]
paste.filter_factory = oslo_middleware.http_proxy_to_wsgi:HTTPProxyToWSGI.factory

[filter:legacy_v2_compatible]
paste.filter_factory = nova.api.openstack:LegacyV2CompatibleWrapper.factory

[app:osapi_compute_app_v21]
paste.app_factory = nova.api.openstack.compute:APIRouterV21.factory

[pipeline:oscomputeversions]
pipeline = cors faultwrap http_proxy_to_wsgi oscomputeversionapp

[app:oscomputeversionapp]
paste.app_factory = nova.api.openstack.compute.versions:Versions.factory

##########
# Shared #
##########

[filter:cors]
paste.filter_factory = oslo_middleware.cors:filter_factory
oslo_config_project = nova

[filter:keystonecontext]
paste.filter_factory = nova.api.auth:NovaKeystoneContext.factory

[filter:authtoken]
paste.filter_factory = keystonemiddleware.auth_token:filter_factory

[composite:osapi_compute]
use = call:nova.api.openstack.urlmap:urlmap_factory
/: oscomputeversions
/v2: openstack_compute_api_v21_legacy_v2_compatible
/v2.1: openstack_compute_api_v21

def urlmap_factory(loader, global_conf, **local_conf):
    if ‘not_found_app‘ in local_conf:
        not_found_app = local_conf.pop(‘not_found_app‘)
    else:
        not_found_app = global_conf.get(‘not_found_app‘)
    if not_found_app:
        not_found_app = loader.get_app(not_found_app, global_conf=global_conf)
    urlmap = URLMap(not_found_app=not_found_app)
    for path, app_name in local_conf.items():
        path = paste.urlmap.parse_path_expression(path)
        app = loader.get_app(app_name, global_conf=global_conf)
        urlmap[path] = app
return urlmap

[composite:openstack_compute_api_v21]
use = call:nova.api.auth:pipeline_factory_v21
noauth2 = cors http_proxy_to_wsgi compute_req_id faultwrap sizelimit osprofiler noauth2 osapi_compute_app_v21
keystone = cors http_proxy_to_wsgi compute_req_id faultwrap sizelimit osprofiler authtoken keystonecontext osapi_compute_app_v21

def pipeline_factory_v21(loader, global_conf, **local_conf):
    """A paste pipeline replica that keys off of auth_strategy."""
return _load_pipeline(loader, local_conf[CONF.api.auth_strategy].split())

def _load_pipeline(loader, pipeline):
    filters = [loader.get_filter(n) for n in pipeline[:-1]]
    app = loader.get_app(pipeline[-1])
    filters.reverse()
    for filter in filters:
        app = filter(app)
return app

[app:osapi_compute_app_v21]
paste.app_factory = nova.api.openstack.compute:APIRouterV21.factory

@classmethod
    def factory(cls, global_config, **local_config):
        """Simple paste factory, :class:`nova.wsgi.Router` doesn‘t have one."""
        return cls()

def __init__(self):
        self._loaded_extension_info = extension_info.LoadedExtensionInfo()
        super(APIRouterV21, self).__init__()

def __init__(self):
        def _check_load_extension(ext):
            return self._register_extension(ext)

        self.api_extension_manager = stevedore.enabled.EnabledExtensionManager(
            namespace=self.api_extension_namespace(),
            check_func=_check_load_extension,
            invoke_on_load=True,
            invoke_kwds={"extension_info": self.loaded_extension_info})

        mapper = ProjectMapper()

        self.resources = {}

        # NOTE(cyeoh) Core API support is rewritten as extensions
        # but conceptually still have core
        if list(self.api_extension_manager):
            # NOTE(cyeoh): Stevedore raises an exception if there are
            # no plugins detected. I wonder if this is a bug.
            self._register_resources_check_inherits(mapper)
            self.api_extension_manager.map(self._register_controllers)

        LOG.info(_LI("Loaded extensions: %s"),
                 sorted(self.loaded_extension_info.get_extensions().keys()))
        super(APIRouterV21, self).__init__(mapper)

[filter:keystonecontext]
paste.filter_factory = nova.api.auth:NovaKeystoneContext.factory

# --*-- coding:utf8 --*--
import webob
from webob import exc
from nova import compute
from nova.api.openstack.compute.schemas import groups
from nova.api.openstack import extensions
from nova.api.openstack import wsgi
from nova.api import validation
from nova import exception
from nova import db
from nova.i18n import _
from nova.policies import groups as groups_policies
#from thvmware.manage import VCenterManagement
from nova import context
from oslo_log import log as logging
from nova.console import type as ctype
import nova.conf
from oslo_utils import uuidutils
from nova.consoleauth import rpcapi as consoleauth_rpcapi
import requests
import traceback

CONF = nova.conf.CONF
LOG = logging.getLogger(__name__)

ALIAS = ‘groups‘


class GroupsController(wsgi.Controller):

    def __init__(self):
        super(GroupsController, self).__init__()
        self.context = context.get_admin_context()
        self.consoleauth_rpcapi = consoleauth_rpcapi.ConsoleAuthAPI()
        self.compute_api = compute.API()

    @extensions.expected_errors(404)
    @validation.schema(groups.create)
    def create(self, req, body):
        context = req.environ[‘nova.context‘]
        context.can(groups_policies.BASE_POLICY_NAME)
        context.can(groups_policies.POLICY_ROOT % ‘create‘)
        LOG.info(body)

    @extensions.expected_errors((400, 404))
    def add_group(self, req, body):
        context = req.environ[‘nova.context‘]
        ret = {‘ret_state‘:‘failed‘}
        values = body[‘group‘]
        if not values.has_key(‘group_id‘) or values[‘group_id‘] == ‘‘:
            values[‘group_id‘] = uuidutils.generate_uuid()
        try:
            db.add_instance_group(context, values)
        except Exception,e:
            LOG.error(‘%s‘, traceback.format_exc())
            ret[‘error‘] = e.message
            return ret
        ret[‘ret_state‘] = ‘success‘
        return ret

    @extensions.expected_errors(())
    def get_groups(self, req):
        ret = {‘ret_state‘: ‘failed‘}
        context = req.environ[‘nova.context‘]
        try:
            groups = db.get_groups(context)
            ret[‘data‘] = groups
        except Exception, e:
            LOG.error(‘%s‘, traceback.format_exc())
            ret[‘error‘] = e.message
            return ret
        ret[‘ret_state‘] = ‘success‘
        return ret

class Groups(extensions.V21APIExtensionBase):
    """extended common support."""

    name = "Groups"
    alias = ALIAS
    version = 1

    def get_resources(self):
        member_actions = {‘update‘: ‘POST‘, ‘detail‘: ‘GET‘}

        collection_actions = {‘add_group‘: ‘POST‘,
                              ‘get_groups‘: ‘GET‘}
        resources = []
        # mapper = Route name Methods Path
        # mapper.connect = >
        # # 示例：
        # # map.resource("message", "messages", collection={"rss": "GET"})
        # # "GET /message/rss"  =>  ``Messages.rss()``.
        # # map.resource(‘message‘, ‘messages‘, member={‘mark‘:‘POST‘})
        # # "POST /message/1/mark"  =>  ``Messages.mark(1)``
        res = extensions.ResourceExtension(
            ALIAS,
            GroupsController(),
            collection_actions=collection_actions,
            member_actions=member_actions)
        resources.append(res)

        return resources

    def get_controller_extensions(self):
        return []

from nova.api.validation import parameter_types

create = {
    ‘type‘: ‘object‘,
    ‘properties‘: {
        ‘MyTest‘: {
            ‘type‘: ‘object‘,
            ‘properties‘: {
                ‘myhost‘: parameter_types.hostname,
            },
            ‘additionalProperties‘: False,
        },
    },
    ‘additionalProperties‘: False,
}

from oslo_policy import policy
from nova.policies import base

BASE_POLICY_NAME = ‘os_compute_api:groups‘
POLICY_ROOT = ‘os_compute_api:groups:%s‘

groups_policies = [
    policy.RuleDefault(
        name=BASE_POLICY_NAME,
        check_str=base.RULE_ADMIN_API),
    policy.RuleDefault(
        name=POLICY_ROOT % ‘create‘,
        check_str=base.RULE_ANY),
    policy.RuleDefault(
        name=POLICY_ROOT % ‘discoverable‘,
        check_str=base.RULE_ANY),
    policy.RuleDefault(
        name=POLICY_ROOT % ‘show‘,
        check_str=base.RULE_ANY),
]

def list_rules():
return groups_policies

from nova.policies import groups
......
def list_rules():
    return itertools.chain(
        ......
        groups.list_rules(),
        ......

[nova.api.v21.extensions]
........
groups = nova.api.openstack.compute.groups:Groups
........