Python pecan.make_app方法代碼示例

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def setup_app(pecan_config=None, debug=False, argv=None):
    """Creates and returns a pecan wsgi app."""
    if argv is None:
        argv = sys.argv
    octavia_service.prepare_service(argv)
    cfg.CONF.log_opt_values(LOG, logging.DEBUG)

    _init_drivers()

    if not pecan_config:
        pecan_config = get_pecan_config()
    pecan_configuration.set_config(dict(pecan_config), overwrite=True)

    return pecan_make_app(
        pecan_config.app.root,
        wrap_app=_wrap_app,
        debug=debug,
        hooks=pecan_config.app.hooks,
        wsme=pecan_config.wsme
    ) 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def setup_app(pecan_config):
    config = dict(pecan_config)

    config['app']['debug'] = cfg.CONF['service:api'].pecan_debug

    pecan.configuration.set_config(config, overwrite=True)

    app = pecan.make_app(
        pecan_config.app.root,
        debug=getattr(pecan_config.app, 'debug', False),
        force_canonical=getattr(pecan_config.app, 'force_canonical', True),
        request_cls=patches.Request,
        guess_content_type_from_ext=False
    )

    return app 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def setup_app(config=None):
    if not config:
        config = get_pecan_config()

    app_conf = dict(config.app)
    common_config.set_config_defaults()

    app = pecan.make_app(
        app_conf.pop('root'),
        logging=getattr(config, 'logging', {}),
        wrap_app=middleware.ParsableErrorMiddleware,
        guess_content_type_from_ext=False,
        **app_conf
    )

    return app 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def setup_app(root, conf=None):
    app_hooks = [hooks.ConfigHook(),
                 hooks.TranslationHook(),
                 hooks.GCHook(),
                 hooks.RPCHook(),
                 hooks.ContextHook(),
                 hooks.DBHook(),
                 hooks.CoordinatorHook()]

    app = pecan.make_app(
        root,
        hooks=app_hooks,
        guess_content_type_from_ext=False
    )

    return app 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def get_api_app():
    app_conf = get_pecan_config()
    storage_backend = storage.get_storage()

    app_hooks = [
        hooks.RPCHook(),
        hooks.StorageHook(storage_backend),
        hooks.ContextHook(),
    ]

    return pecan.make_app(
        app_conf.app.root,
        static_root=app_conf.app.static_root,
        template_path=app_conf.app.template_path,
        debug=CONF.api.pecan_debug,
        force_canonical=getattr(app_conf.app, 'force_canonical', True),
        hooks=app_hooks,
        guess_content_type_from_ext=False,
    ) 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def setup_app(config=None):
    """Create a WSGI application object."""

    if not config:
        config = get_pecan_config()

    # Setup the hooks for WSGI Application(Like Middleware in Paste).
    #    EG. app_hooks = [hooks.DBHook()]
    app_hooks = []
    # Setup the config for WSGI Application.
    app_conf = dict(config.app)

    # Create and init the WSGI Application.
    app = pecan.make_app(
        app_conf.pop('root'),
        logging=getattr(config, 'logging', {}),
        hooks=app_hooks,
        **app_conf
    )
    return app 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def setUp(self):
        super(SecureControllerSharedPermissionsRegression, self).setUp()

        class Parent(object):
            @expose()
            def index(self):
                return 'hello'

        class UnsecuredChild(Parent):
            pass

        class SecureChild(Parent, SecureController):
            @classmethod
            def check_permissions(cls):
                return False

        class RootController(object):

            secured = SecureChild()
            unsecured = UnsecuredChild()

        self.app = TestApp(make_app(RootController())) 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def test_getall_with_trailing_slash(self):

        class ThingsController(RestController):

            data = ['zero', 'one', 'two', 'three']

            @expose('json')
            def get_all(self):
                return dict(items=self.data)

        class RootController(object):
            things = ThingsController()

        # create the app
        app = TestApp(make_app(RootController()))

        # test get_all
        r = app.get('/things/')
        assert r.status_int == 200
        assert r.body == b_(dumps(dict(items=ThingsController.data))) 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def test_post_with_kwargs_only(self):

        class RootController(RestController):

            @expose()
            def get_all(self):
                return 'INDEX'

            @expose('json')
            def post(self, **kw):
                return kw

        # create the app
        app = TestApp(make_app(RootController()))

        r = app.get('/')
        assert r.status_int == 200
        assert r.body == b_('INDEX')

        kwargs = {'foo': 'bar', 'spam': 'eggs'}
        r = app.post('/', kwargs)
        assert r.status_int == 200
        assert r.namespace['foo'] == 'bar'
        assert r.namespace['spam'] == 'eggs' 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def test_nested_rest_with_default(self):

        class FooController(RestController):

            @expose()
            def _default(self, *remainder):
                return "DEFAULT %s" % remainder

        class RootController(RestController):
            foo = FooController()

        app = TestApp(make_app(RootController()))

        r = app.get('/foo/missing')
        assert r.status_int == 200
        assert r.body == b_("DEFAULT missing") 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def test_rest_with_non_utf_8_body(self):
        if PY3:
            # webob+PY3 doesn't suffer from this bug; the POST parsing in PY3
            # seems to more gracefully detect the bytestring
            return

        class FooController(RestController):

            @expose()
            def post(self):
                return "POST"

        class RootController(RestController):
            foo = FooController()

        app = TestApp(make_app(RootController()))

        data = struct.pack('255h', *range(0, 255))
        r = app.post('/foo/', data, expect_errors=True)
        assert r.status_int == 400 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def test_internal_redirect_with_after_hook(self):
        run_hook = []

        class RootController(object):
            @expose()
            def internal(self):
                redirect('/testing', internal=True)

            @expose()
            def testing(self):
                return 'it worked!'

        class SimpleHook(PecanHook):
            def after(self, state):
                run_hook.append('after')

        app = TestApp(make_app(RootController(), hooks=[SimpleHook()]))
        response = app.get('/internal')
        assert response.body == b_('it worked!')

        assert len(run_hook) == 1 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def setup_app(pecan_config=None, extra_hooks=None):
    if not pecan_config:
        pecan_config = get_pecan_config()

    app_hooks = [hooks.ConfigHook(),
                 hooks.ConductorAPIHook(),
                 hooks.ContextHook(pecan_config.app.acl_public_routes),
                 hooks.PublicUrlHook()]
    if extra_hooks:
        app_hooks.extend(extra_hooks)

    app_conf = dict(pecan_config.app)
    app = pecan.make_app(
        app_conf.pop('root'),
        force_canonical=getattr(pecan_config.app, 'force_canonical', True),
        hooks=app_hooks,
        wrap_app=middleware.ParsableErrorMiddleware,
        **app_conf
    )

    return app 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def _setup_app(root, conf, not_implemented_middleware):
    app = pecan.make_app(
        root,
        hooks=(GnocchiHook(conf),),
        guess_content_type_from_ext=False,
        custom_renderers={"json": JsonRenderer}
    )

    if not_implemented_middleware:
        app = webob.exc.HTTPExceptionMiddleware(NotImplementedMiddleware(app))

    return app 

# 需要導入模塊: import pecan [as 別名]
# 或者: from pecan import make_app [as 別名]
def setup_app(config=None):
    if not config:
        config = get_pecan_config()

    app_conf = dict(config.app)
    common_config.set_config_defaults()

    app = pecan.make_app(
        app_conf.pop('root'),
        logging=getattr(config, 'logging', {}),
        wrap_app=middleware.ParsableErrorMiddleware,
        **app_conf
    )

    return app