예제 #1
0
파일: entity.py 프로젝트: rohe/fedservice
def init_app(config_file, name=None, **kwargs) -> Flask:
    name = name or __name__
    app = Flask(name, static_url_path='', **kwargs)

    app.srv_config = create_from_config_file(Configuration,
                                             entity_conf=[{
                                                 "class":
                                                 FedEntityConfiguration,
                                                 "attr":
                                                 "federation",
                                                 "path": ["federation"]
                                             }],
                                             filename=config_file,
                                             base_path=dir_path)

    # app.users = {'test_user': {'name': 'Testing Name'}}

    try:
        from .views import intermediate
    except ImportError:
        from views import intermediate

    app.register_blueprint(intermediate)

    # Initialize the oidc_provider after views to be able to set correct urls
    app.server = init_entity(app.srv_config.federation, dir_path)

    return app
예제 #2
0
    def setUp(self):
        modules.flags_manager.remove_all_flags()

        self.app = Flask(__name__)
        self.app.add_url_rule('/test', 'test', test_api, methods=['POST'])

        init_flask('test_app', self.app, setup_kuber_config_loader=False)

        flags.DEFINE_INTEGER_FLAG("test")
        self.loader = KuberConfigLoader("test_service")
        self.loader.load_config(
            config_pb2.GlobalConfig(
                flags=[{
                    "name": "test",
                    "type": "INTEGER",
                    "value": {
                        "base_value": {
                            "number_value": 1
                        }
                    }
                }],
                experiments={
                    2:
                    ExperimentDefinition(
                        id=2,
                        flag_values={
                            "test": FlagValue(base_value={"number_value": 2})
                        })
                }))

        self.server = Process(target=self.app.run, args=("127.0.0.1", 8008))
        self.server.start()
        sleep(1)
예제 #3
0
def create_app(config_name: str) -> Flask:
    app = Flask(__name__)
    app.config.from_object(config_by_name[config_name])
    db.init_app(app)
    flask_bcrypt.init_app(app)
    ma.init_app(app)
    return app
예제 #4
0
def test_register_handlers_registers_connection_handler_with_bindings_validation(
    server_info: Info,
    faker: Faker,
):
    namespace = f"/{faker.pystr()}"
    spec = AsyncApiSpec(
        asyncapi=faker.pystr(),
        info=server_info,
        channels={
            namespace:
            Channel(bindings=ChannelBindings(
                ws=WebSocketsChannelBindings(method="GET", )), )
        },
    )
    server = new_mock_asynction_socket_io(spec)
    flask_app = Flask(__name__)

    server._register_handlers()
    _, registered_handler, _ = server.handlers[0]

    handler_with_validation = deep_unwrap(registered_handler, depth=1)
    actual_handler = deep_unwrap(registered_handler)

    with flask_app.test_client() as c:
        with patch.object(server, "start_background_task"):
            c.post()  # Inject invalid POST request
            actual_handler()  # actual handler does not raise validation errors
            with pytest.raises(BindingsValidationException):
                handler_with_validation()
예제 #5
0
def app_secured_from_configuration():
    app = Flask(__name__)
    app.config["OPA_SECURED"] = True
    app.config["OPA_URL"] = 'http://localhost:8181/v1/data/examples/allow'
    app.opa = OPA(app, input_function=parse_input)
    init_app(app)
    return app
예제 #6
0
def test_start_background_daemon_task_with_threading_async_mode(
        server_info: Info, faker: Faker):
    spec = AsyncApiSpec(
        asyncapi=faker.pystr(),
        info=server_info,
        channels={f"/{faker.pystr()}": Channel()},
    )
    server = new_mock_asynction_socket_io(spec,
                                          app=Flask(__name__),
                                          async_mode="threading")

    def target():
        # noop
        pass

    args = tuple(faker.pylist())
    kwargs = faker.pydict()

    with patch.object(threading, "Thread") as mock_thread_cls:
        t = server.start_background_task(target, *args, **kwargs)

        mock_thread_cls.assert_called_once_with(target=target,
                                                args=args,
                                                kwargs=kwargs,
                                                daemon=True)
        t.start.assert_called_once_with()  # type: ignore
예제 #7
0
def create_app(spark_context, app):
    global recommendationengine
    recommendationengine = RecommendationEngine(spark_context, app)

    app = Flask(__name__)
    app.register_blueprint(main)
    return app
예제 #8
0
    def __init__(self,
                 dbUri='sqlite:///:memory:',
                 port=5000,
                 verbose=False,
                 serializer=jsonSerializerWithUri):

        self.flaskApp = Flask(__name__,
                              static_url_path='',
                              static_folder=abspath('./static'))

        print 'Using following sqlite database URI:', dbUri
        self.flaskApp.config['SQLALCHEMY_DATABASE_URI'] = dbUri

        self.flaskApp.config['SQLALCHEMY_TRACK_MODIFICATIONS'] = False

        if verbose:
            self.flaskApp.config['SQLALCHEMY_ECHO'] = True

        @self.flaskApp.route('/')
        def index():
            return self.flaskApp.send_static_file('index.html')

        self.port = port
        self.serializer = serializer
        self.namespaces = {}
예제 #9
0
def create_app(config_name):
    app = Flask(__name__)
    print(__name__)
    app.config.from_object(config[config_name])
    bootstrap.init_app(app)
    mail.init_app(app)
    moment.init_app(app)
    # 初始化db
    db.init_app(app)

    login_manager.init_app(app)
    # 初始化日志配置
    common = LogCommon()
    app = common.init_log(app, 'log')

    # 附加路由和自定义的错误页面
    from app.pyweb.main import main
    app.register_blueprint(main)
    # 定义认证路由
    from app.pyweb.auth import auth
    app.register_blueprint(auth, url_prefix='/auth')
    # 定义Captcha路由
    from app.pyweb.captcha_chinese import captcha
    app.register_blueprint(captcha, url_prefix='/captcha')

    return app
예제 #10
0
def oidc_provider_init_app(config_file, name=None, **kwargs):
    name = name or __name__
    app = Flask(name, static_url_path='', **kwargs)

    app.srv_config = create_from_config_file(Configuration,
                                             entity_conf=[{
                                                 "class": FedRPConfiguration,
                                                 "attr": "rp"
                                             }],
                                             filename=config_file,
                                             base_path=dir_path)

    app.users = {'test_user': {'name': 'Testing Name'}}

    try:
        from .views import oidc_rp_views
    except ImportError:
        from views import oidc_rp_views

    app.register_blueprint(oidc_rp_views)

    # Initialize the oidc_provider after views to be able to set correct urls
    app.rph = init_oidc_rp_handler(app.srv_config.rp, dir_path)

    return app
예제 #11
0
def init_app(name=None):
    name = name or __name__
    app = Flask(name)
    app.config.from_pyfile('application.cfg')
    app.config.from_pyfile('production.cfg')

    app.jinja_env.globals['GIT_HASH'] = get_git_hash()

    #app.ldap_orm = Connection(app.config['LDAP_URL'], app.config['LDAP_BIND_DN'], app.config['LDAP_BIND_PW'], auto_bind=True)
    server = Server(app.config['LDAP_URL'], get_info=ALL)
    app.ldap_conn = Connection(server,
                               app.config['LDAP_BIND_DN'],
                               app.config['LDAP_BIND_PW'],
                               auto_bind=True)
    model.ldap_conn = app.ldap_conn
    model.base_dn = app.config['LDAP_BASE_DN']

    from .model import db
    db.init_app(app)
    with app.app_context():
        db.create_all()

    app.babel = Babel(app)
    init_oauth2(app)
    app.login_manager = LoginManager(app)

    #init hydra admin api
    hydra_config = hydra.Configuration(
        host=app.config['HYDRA_ADMIN_URL'],
        username=app.config['HYDRA_ADMIN_USER'],
        password=app.config['HYDRA_ADMIN_PASSWORD'])
    hydra_client = hydra.ApiClient(hydra_config)
    app.hydra_api = hydra.AdminApi(hydra_client)

    from .views import auth_views, frontend_views, init_login_manager, api_views, pki_views, admin_views
    init_login_manager(app)
    app.register_blueprint(auth_views)
    app.register_blueprint(frontend_views)
    app.register_blueprint(api_views)
    app.register_blueprint(pki_views)
    app.register_blueprint(admin_views)

    @app.before_request
    def befor_request():
        request_start_time = time.time()
        g.request_time = lambda: "%.5fs" % (time.time() - request_start_time)

    from .translations import init_babel

    init_babel(app)

    app.lenticular_services = {}
    for service_name, service_config in app.config[
            'LENTICULAR_CLOUD_SERVICES'].items():
        app.lenticular_services[service_name] = model.Service.from_config(
            service_name, service_config)

    app.pki = Pki(app.config['PKI_PATH'], app.config['DOMAIN'])

    return app
예제 #12
0
def main():
    '''
    This method registers all the end points of the application
    '''
    app = Flask(__name__)
    api = Api(app)
    api.add_resource(MyHanlder, '/api/hello')
    return app
예제 #13
0
def create_app():
    app = Flask(__name__)
    from . import api
    app.register_blueprint(api.bp)
    app.height = int(os.environ.get('PREDICTOR_HEIGHT', '0'))
    app.feature_type = os.environ.get('PREDICTOR_FEATURE_TYPE')
    app.logger.debug(f"Building predictor: {app.feature_type}")
    return app
예제 #14
0
def app():
    """Import the test app"""
    app = Flask(__name__)
    app.config["OPA_SECURED"] = True
    app.config["OPA_URL"] = 'http://localhost:8181/v1/data/examples/allow'
    app.opa = OPA(app, input_function=parse_input).secured()
    init_app(app)
    return app
예제 #15
0
def create_app(config_filename=None):
    app = Flask(__name__)
    app.config.from_object(hepdata_converter_ws)

    from hepdata_converter_ws.api import api
    app.register_blueprint(api)

    return app
예제 #16
0
def create_app(config_name):
    app = Flask(__name__)
    app.config.from_object(config[config_name])
    bootstrap.init_app(app)
    db.init_app(app)

    from .main import main as main_blueprint
    app.register_blueprint(main_blueprint)
    return app
예제 #17
0
def create_app(config_object: Type[Config] = DevConfig) -> Flask:

    app = Flask(__name__)
    app.config.from_object(config_object)
    chained_function = chain(register_commands, register_blueprints,
                             register_extensions, register_handlers)
    app = chained_function(app)

    return app
예제 #18
0
 def __create_server(self):
     host = CONFIG.get_rest_api_host()
     port = CONFIG.get_rest_api_port()
     self.flask = Flask(__name__)
     self.__werkzeug = make_server(host=host if host else self.DEFAULT_HOST,
                                   port=port if port else self.DEFAULT_PORT,
                                   app=self.flask)
     # Suppress low level logging
     logging.getLogger("werkzeug").setLevel(logging.WARNING)
예제 #19
0
        def _create_json_record(xml_record):
            object_record = create_record(etree.XML(xml_record))
            app = Flask('hepcrawl')
            app.config.update(self.settings.getdict('MARC_TO_HEP_SETTINGS',
                                                    {}))
            with app.app_context():
                dojson_record = hep.do(object_record)

            return dojson_record
예제 #20
0
def create_app():
    app = Flask(__name__)
    from . import api
    app.register_blueprint(api.bp)
    app.identifier = os.environ.get('VECTORIZER_IDENTIFIER')
    app.width = int(os.environ.get('VECTORIZER_WIDTH', '0'))
    app.constructor = os.environ.get('VECTORIZER_CONSTRUCTOR')
    app.logger.debug(f"Building vectorizer: {app.constructor}")
    return app
예제 #21
0
    def create_app(self):
        from openbrokerapi.api import get_blueprint

        app = Flask(__name__)
        self.broker = Mock()

        app.register_blueprint(
            get_blueprint(self.broker, BrokerCredentials("", ""),
                          basic_config(level=logging.WARN)))
        return app
예제 #22
0
def create_app(config_name: str = "default") -> Flask:
    app = Flask(__name__)
    init_config(app, config_name)

    with app.app_context():
        init_extensions(app)
        init_blueprints(app)
        init_commands(app)

    return app
예제 #23
0
def main():
    '''
    This method registers all the end points of the application
    '''
    app = Flask(__name__)
    app.secret_key = 'some_secret_key'
    api = Api(app)
    jwt = JWT(app, validate_user, get_user_based_on_identity)
    api.add_resource(MyHanlder, '/api/hello')
    return app
예제 #24
0
def create_app():
    application = Flask(__name__)
    application.secret_key = gen_random_password()
    Bootstrap(application)

    application.register_blueprint(base_bp)
    application.register_blueprint(files_bp)
    application.register_blueprint(helpers_bp)

    return application
예제 #25
0
    def setUp(self):
        app = Flask(__name__)
        app.testing = True
        app.config["TESTING"] = True

        setup_rest_api(app)
        self.client = app.test_client

        # Init db
        DbSessionHolder(TestV1API.REST_TEST_DB).reset()
예제 #26
0
        def _create_json_record(xml_record):
            object_record = create_record(etree.XML(xml_record))
            app = Flask('hepcrawl')
            app.config.update(self.settings.getdict('MARC_TO_HEP_SETTINGS',
                                                    {}))
            with app.app_context():
                dojson_record = hep.do(object_record)
                base_uri = self.settings['SCHEMA_BASE_URI']
                dojson_record['$schema'] = base_uri + 'hep.json'

            return dojson_record
예제 #27
0
def test_opa_create_with_staticmethod_deny_access():
    app = Flask(__name__)
    opa_url = 'http://localhost:8181/v1/data/dm/allow'
    app.opa = OPA.secure(app, input_function=parse_input, url=opa_url)
    init_app(app)

    responses.add(responses.POST, opa_url, json={'result': False}, status=200)

    response = app.test_client().get('/')

    assert 403 == response.status_code
예제 #28
0
def init_app():
    app = Flask(__name__)
    app.config.from_object(config)
    app.template_folder = config.template_folder
    handler = RotatingFileHandler(config.log_path,
                                  maxBytes=10000,
                                  backupCount=1)
    handler.setLevel(logging.INFO)
    app.logger.addHandler(handler)
    register_blueprints(app)
    return app
예제 #29
0
    def _create_environment(self, **kwargs):
        if FLASK_VERSION < '0.7':
            # Older Flask versions do not support the
            # static_folder argument, which we need to use
            # a temporary folder for static files, without
            # having to do sys.path hacking.
            raise SkipTest()

        if not hasattr(self, 'app'):
            self.app = Flask(__name__, static_folder=self.tempdir, **kwargs)
        self.env = Environment(self.app)
        return self.env
예제 #30
0
def create_app():
    app = Flask(__name__)
    bootstrap = Bootstrap(app)

    app.config.from_object(Config)

    # login manager inicializando la app
    login_manager.init_app(app)

    # Se registra el nuevo blueprint auth
    app.register_blueprint(auth)

    return app