コード例 #1
0
ファイル: scripts.py プロジェクト: jssuzanne/AnyBlok
def anyblok_createdb():
    """Create a database and install blok from config"""
    load_init_function_from_entry_points()
    Configuration.load('createdb')
    configuration_post_load()
    BlokManager.load()
    db_name = get_db_name()

    db_template_name = Configuration.get('db_template_name', None)
    url = Configuration.get('get_url')(db_name=db_name)
    create_database(url, template=db_template_name)
    registry = RegistryManager.get(db_name)
    if registry is None:
        return

    if Configuration.get('install_all_bloks'):
        bloks = registry.System.Blok.list_by_state('uninstalled')
    else:
        install_bloks = Configuration.get('install_bloks') or []
        iou_bloks = Configuration.get('install_or_update_bloks') or []
        bloks = list(set(install_bloks + iou_bloks))

    registry.upgrade(install=bloks)
    registry.commit()
    registry.close()
コード例 #2
0
ファイル: scripts.py プロジェクト: jssuzanne/AnyBlok
def createdb(application, configuration_groups, **kwargs):
    """ Create a database and install blok from config

    :param application: name of the application
    :param configuration_groups: list configuration groupe to load
    :param \**kwargs: ArgumentParser named arguments
    """
    format_configuration(configuration_groups,
                         'create_db', 'install-bloks',
                         'install-or-update-bloks')
    load_init_function_from_entry_points()
    Configuration.load(application, configuration_groups=configuration_groups,
                       **kwargs)
    BlokManager.load()
    db_name = Configuration.get('db_name')
    db_template_name = Configuration.get('db_template_name', None)
    url = Configuration.get('get_url')(db_name=db_name)
    create_database(url, template=db_template_name)
    registry = RegistryManager.get(db_name)
    if registry is None:
        return

    if Configuration.get('install_all_bloks'):
        bloks = registry.System.Blok.list_by_state('uninstalled')
    else:
        install_bloks = Configuration.get('install_bloks') or []
        iou_bloks = Configuration.get('install_or_update_bloks') or []
        bloks = list(set(install_bloks + iou_bloks))

    registry.upgrade(install=bloks)
    registry.commit()
    registry.close()
コード例 #3
0
ファイル: scripts.py プロジェクト: AnyBlok/AnyBlok
def anyblok_createdb():
    """Create a database and install blok from config"""
    load_init_function_from_entry_points()
    Configuration.load('createdb')
    configuration_post_load()
    BlokManager.load()
    db_name = get_db_name()

    db_template_name = Configuration.get('db_template_name', None)
    url = Configuration.get('get_url')(db_name=db_name)
    create_database(url, template=db_template_name)
    anyblok_registry = RegistryManager.get(db_name)
    if anyblok_registry is None:
        return

    anyblok_registry.System.Parameter.set(
        "with-demo", Configuration.get('with_demo', False))

    if Configuration.get('install_all_bloks'):
        bloks = anyblok_registry.System.Blok.list_by_state('uninstalled')
    else:
        install_bloks = Configuration.get('install_bloks') or []
        iou_bloks = Configuration.get('install_or_update_bloks') or []
        bloks = list(set(install_bloks + iou_bloks))

    anyblok_registry.upgrade(install=bloks)
    anyblok_registry.commit()
    anyblok_registry.close()
コード例 #4
0
def wsgi():
    """Simple Pyramid wsgi server for development purpose
    """
    load_init_function_from_entry_points()
    Configuration.load('pyramid')
    configuration_post_load()
    BlokManager.load()
    config = Configurator()
    config.include_from_entry_point()
    config.load_config_bloks()

    wsgi_host = Configuration.get('wsgi_host')
    wsgi_port = int(Configuration.get('wsgi_port'))

    app = config.make_wsgi_app()
    server = make_server(wsgi_host, wsgi_port, app)
    preload_databases(loadwithoutmigration=False)

    try:
        from colorama import Fore, Style
        start_msg = ("Pyramid development server running at %shttp://%s:%s%s" %
                     (Fore.BLUE, wsgi_host, wsgi_port, Style.RESET_ALL))
    except ImportError:
        logger.info("`pip install colorama` to get colored link")
        start_msg = "Pyramid development server running at http://%s:%s" % (
            wsgi_host, wsgi_port)

    logger.info(start_msg)
    print(start_msg)

    server.serve_forever()
コード例 #5
0
ファイル: test_blok.py プロジェクト: petrus-v/AnyBlok
 def test_get_invalid_blok(self):
     try:
         BlokManager.load()
         BlokManager.get('invalid blok')
         self.fail('No exception when get invalid blok')
     except BlokManagerException:
         pass
コード例 #6
0
ファイル: scripts.py プロジェクト: jssuzanne/Anyblok_Pyramid
def anyblok_wsgi(application, configuration_groups, **kwargs):
    """
    :param application: name of the application
    :param configuration_groups: list configuration groupe to load
    :param \**kwargs: ArgumentParser named arguments
    """
    format_configuration(configuration_groups, 'preload', 'pyramid-debug',
                         'wsgi')
    load_init_function_from_entry_points()
    Configuration.load(application,
                       configuration_groups=configuration_groups, **kwargs)
    BlokManager.load()
    config = Configurator()
    config.include_from_entry_point()
    config.load_config_bloks()

    wsgi_host = Configuration.get('wsgi_host')
    wsgi_port = int(Configuration.get('wsgi_port'))

    app = config.make_wsgi_app()
    server = make_server(wsgi_host, wsgi_port, app)
    preload_databases()

    logger.info("Serve forever on %r:%r" % (wsgi_host, wsgi_port))
    server.serve_forever()
コード例 #7
0
ファイル: gunicorn.py プロジェクト: AnyBlok/Anyblok_Pyramid
 def load(self):
     BlokManager.load()
     preload_databases()
     config = Configurator()
     config.include_from_entry_point()
     config.load_config_bloks()
     return config.make_wsgi_app()
コード例 #8
0
ファイル: test_blok_manager.py プロジェクト: zakibelm/AnyBlok
 def test_reload(self):
     BlokManager.load()
     BlokManager.set('invalid blok', None)
     BlokManager.get('invalid blok')
     BlokManager.reload()
     with pytest.raises(BlokManagerException):
         BlokManager.get('invalid blok')
コード例 #9
0
ファイル: plugins.py プロジェクト: jssuzanne/AnyBlok
    def load_registry(self):
        if self.enabled and self.registryLoaded is False:
            # Load the registry here not in configuration,
            # because the configuration are not load in order of score
            self.registryLoaded = True
            BlokManager.load()
            load_init_function_from_entry_points(unittest=True)
            Configuration.load_config_for_test()
            Configuration.parse_options(self.AnyBlokOptions, ('bloks',))
            db_name = Configuration.get('db_name')
            if not db_name:
                raise Exception("No database defined to run Test")

            registry = RegistryManager.get(db_name)
            if registry:
                installed_bloks = registry.System.Blok.list_by_state(
                    "installed")
                selected_bloks = Configuration.get('selected_bloks')
                if not selected_bloks:
                    selected_bloks = installed_bloks

                unwanted_bloks = Configuration.get('unwanted_bloks')
                if unwanted_bloks is None:
                    unwanted_bloks = []

                self.bloks_path = [BlokManager.getPath(x)
                                   for x in BlokManager.ordered_bloks]

                self.authoried_bloks_test_files = [
                    path for blok in installed_bloks
                    if blok in selected_bloks and blok not in unwanted_bloks
                    for path in [join(BlokManager.getPath(blok), 'tests')]
                    if exists(path)]
                registry.close()  # free the registry to force create it again
コード例 #10
0
ファイル: gunicorn.py プロジェクト: petrus-v/Anyblok_Pyramid
 def load(self):
     BlokManager.load()
     preload_databases()
     config = Configurator()
     config.include_from_entry_point()
     config.load_config_bloks()
     return config.make_wsgi_app()
コード例 #11
0
def anyblok_wsgi(application, configuration_groups, **kwargs):
    """
    :param application: name of the application
    :param configuration_groups: list configuration groupe to load
    :param \**kwargs: ArgumentParser named arguments
    """
    format_configuration(configuration_groups, 'preload', 'pyramid-debug',
                         'wsgi')
    load_init_function_from_entry_points()
    Configuration.load(application,
                       configuration_groups=configuration_groups,
                       **kwargs)
    BlokManager.load()
    config = Configurator()
    config.include_from_entry_point()
    config.load_config_bloks()

    wsgi_host = Configuration.get('wsgi_host')
    wsgi_port = int(Configuration.get('wsgi_port'))

    app = config.make_wsgi_app()
    server = make_server(wsgi_host, wsgi_port, app)
    preload_databases()

    logger.info("Serve forever on %r:%r" % (wsgi_host, wsgi_port))
    server.serve_forever()
コード例 #12
0
 def test_get_invalid_blok(self):
     try:
         BlokManager.load()
         BlokManager.get('invalid blok')
         self.fail('No exception when get invalid blok')
     except BlokManagerException:
         pass
コード例 #13
0
 def setUp(self):
     super(TestBlok, self).setUp()
     self.__class__.init_configuration_manager()
     self.__class__.createdb(keep_existing=False)
     BlokManager.load(entry_points=('bloks', 'test_bloks'))
     registry = RegistryManager.get(Configuration.get('db_name'))
     registry.commit()
     registry.close()
コード例 #14
0
ファイル: test_blok.py プロジェクト: petrus-v/AnyBlok
    def test_load_anyblok(self):
        BlokManager.load()
        if not BlokManager.list():
            self.fail('No blok load')
        if not BlokManager.has('anyblok-core'):
            self.fail("The blok 'anyblok-core' is missing")

        BlokManager.get('anyblok-core')
コード例 #15
0
    def test_load_anyblok(self):
        BlokManager.load()
        if not BlokManager.list():
            self.fail('No blok load')
        if not BlokManager.has('anyblok-core'):
            self.fail("The blok 'anyblok-core' is missing")

        BlokManager.get('anyblok-core')
コード例 #16
0
ファイル: test_blok.py プロジェクト: petrus-v/AnyBlok
 def test_reload(self):
     BlokManager.load()
     BlokManager.set('invalid blok', None)
     BlokManager.get('invalid blok')
     BlokManager.reload()
     try:
         BlokManager.get('invalid blok')
         self.fail("Reload classmethod doesn't reload the bloks")
     except BlokManagerException:
         pass
コード例 #17
0
 def test_reload(self):
     BlokManager.load()
     BlokManager.set('invalid blok', None)
     BlokManager.get('invalid blok')
     BlokManager.reload()
     try:
         BlokManager.get('invalid blok')
         self.fail("Reload classmethod doesn't reload the bloks")
     except BlokManagerException:
         pass
コード例 #18
0
ファイル: testcase.py プロジェクト: gracinet/AnyBlok
    def setUpClass(cls):
        """ Intialialise the configuration manager """

        super(DBTestCase, cls).setUpClass()
        cls.init_configuration_manager()
        if cls.createdb(keep_existing=True):
            BlokManager.load(entry_points=('bloks', 'test_bloks'))
            registry = cls.getRegistry()
            registry.commit()
            registry.close()
            BlokManager.unload()
コード例 #19
0
ファイル: testcase.py プロジェクト: jssuzanne/AnyBlok
    def setUpClass(cls):
        """ Intialialise the configuration manager """

        super(DBTestCase, cls).setUpClass()
        cls.init_configuration_manager()
        if cls.createdb(keep_existing=True):
            BlokManager.load(entry_points=('bloks', 'test_bloks'))
            registry = cls.getRegistry()
            registry.commit()
            registry.close()
            BlokManager.unload()
コード例 #20
0
def base_loaded(request):
    url = Configuration.get('get_url')()
    if not database_exists(url):
        db_template_name = Configuration.get('db_template_name', None)
        create_database(url, template=db_template_name)

    BlokManager.load()
    registry = init_registry_with_bloks([], None)
    registry.commit()
    registry.close()
    BlokManager.unload()
コード例 #21
0
ファイル: testcase.py プロジェクト: gracinet/AnyBlok
    def setUpClass(cls):
        """ Initialize the registry.
        """
        super(BlokTestCase, cls).setUpClass()
        additional_setting = cls.additional_setting()
        if cls.registry is None:
            if len(BlokManager.list()) == 0:
                BlokManager.load()

            cls.registry = RegistryManager.get(Configuration.get('db_name'),
                                               **additional_setting)

        cls.registry.commit()
コード例 #22
0
ファイル: testcase.py プロジェクト: jssuzanne/AnyBlok
    def setUpClass(cls):
        """ Initialize the registry.
        """
        super(BlokTestCase, cls).setUpClass()
        additional_setting = cls.additional_setting()
        if cls.registry is None:
            if len(BlokManager.list()) == 0:
                BlokManager.load()

            cls.registry = RegistryManager.get(Configuration.get('db_name'),
                                               **additional_setting)

        cls.registry.commit()
コード例 #23
0
def base_loaded(request, configuration_loaded):
    if sgdb_in(['MySQL', 'MariaDB']):
        return

    url = Configuration.get('get_url')()
    if not database_exists(url):
        db_template_name = Configuration.get('db_template_name', None)
        create_database(url, template=db_template_name)

    BlokManager.load()
    registry = init_registry_with_bloks([], None)
    registry.commit()
    registry.close()
    BlokManager.unload()
コード例 #24
0
 def test_anyblok_core_loaded(self):
     BlokManager.load()
     is_exist = 'anyblok-core' in RegistryManager.loaded_bloks
     self.assertEqual(is_exist, True)
     anyblokcore = RegistryManager.loaded_bloks['anyblok-core']
     self.assertEqual(len(anyblokcore['Core']['Base']), 1)
     self.assertEqual(len(anyblokcore['Core']['SqlBase']), 1)
     self.assertEqual(len(anyblokcore['Core']['SqlViewBase']), 1)
     self.assertEqual(len(anyblokcore['Core']['Session']), 1)
     self.assertEqual(len(anyblokcore['Core']['Query']), 1)
     self.assertEqual(len(anyblokcore['Core']['InstrumentedList']), 1)
     is_exist = 'Model.System' in anyblokcore['Model']
     self.assertEqual(is_exist, True)
     BlokManager.unload()
コード例 #25
0
 def test_anyblok_core_loaded(self):
     BlokManager.load()
     is_exist = 'anyblok-core' in RegistryManager.loaded_bloks
     assert is_exist
     anyblokcore = RegistryManager.loaded_bloks['anyblok-core']
     assert len(anyblokcore['Core']['Base']) == 1
     assert len(anyblokcore['Core']['SqlBase']) == 1
     assert len(anyblokcore['Core']['SqlViewBase']) == 1
     assert len(anyblokcore['Core']['Session']) == 1
     assert len(anyblokcore['Core']['Query']) == 1
     assert len(anyblokcore['Core']['InstrumentedList']) == 1
     is_exist = 'Model.System' in anyblokcore['Model']
     assert is_exist
     BlokManager.unload()
コード例 #26
0
 def test_anyblok_core_loaded(self):
     BlokManager.load()
     is_exist = 'anyblok-core' in RegistryManager.loaded_bloks
     self.assertEqual(is_exist, True)
     anyblokcore = RegistryManager.loaded_bloks['anyblok-core']
     self.assertEqual(len(anyblokcore['Core']['Base']), 1)
     self.assertEqual(len(anyblokcore['Core']['SqlBase']), 1)
     self.assertEqual(len(anyblokcore['Core']['SqlViewBase']), 1)
     self.assertEqual(len(anyblokcore['Core']['Session']), 1)
     self.assertEqual(len(anyblokcore['Core']['Query']), 1)
     self.assertEqual(len(anyblokcore['Core']['InstrumentedList']), 1)
     is_exist = 'Model.System' in anyblokcore['Model']
     self.assertEqual(is_exist, True)
     BlokManager.unload()
コード例 #27
0
ファイル: scripts.py プロジェクト: AnyBlok/anyblok_dramatiq
def worker_process(worker_id, logging_fd):
    """consume worker to process messages and execute the actor"""
    # TODO preload registries
    db_name = Configuration.get('db_name')
    try:
        logging_pipe = os.fdopen(logging_fd, "w")
        broker = prepare_broker(withmiddleware=True)
        broker.emit_after("process_boot")
        BlokManager.load()
        registry = RegistryManager.get(db_name, loadwithoutmigration=True)
        if registry is None:
            logger.critical("No registry found for %s", db_name)
            return os._exit(4)

        worker = Worker(
            broker, worker_threads=Configuration.get('dramatiq_threads', 1))
        worker.start()
        print('worker started')
    except ImportError as e:
        logger.critical(e)
        return os._exit(2)
    except ConnectionError as e:
        logger.critical("Broker connection failed. %s", e)
        return os._exit(3)

    def termhandler(signum, frame):
        nonlocal running
        BlokManager.unload()
        if running:
            logger.info("Stopping worker process...")
            running = False
        else:
            logger.warning("Killing worker process...")
            return os._exit(1)

    logger.info("Worker process is ready for action.")
    signal.signal(signal.SIGINT, signal.SIG_IGN)
    signal.signal(signal.SIGTERM, termhandler)
    signal.signal(signal.SIGHUP, termhandler)

    running = True
    while running:
        time.sleep(1)

    worker.stop()
    broker.close()
    logging_pipe.close()
コード例 #28
0
ファイル: test_migration.py プロジェクト: jssuzanne/AnyBlok
    def setUpClass(cls):
        super(TestMigration, cls).setUpClass()
        cls.init_configuration_manager()
        cls.createdb()
        BlokManager.load()

        register = Declarations.register
        Model = Declarations.Model

        cls.loaded_bloks = deepcopy(RegistryManager.loaded_bloks)
        EnvironmentManager.set('current_blok', 'anyblok-core')

        @register(Model)
        class Test:
            integer = Int(primary_key=True)
            other = Str()

        @register(Model)
        class TestUnique:
            integer = Int(primary_key=True)
            other = Str(unique=True)

        @register(Model)
        class TestFKTarget:
            integer = Int(primary_key=True)

        @register(Model)
        class TestFK:
            integer = Int(primary_key=True)
            other = Int(foreign_key=Model.TestFKTarget.use('integer'))

        @register(Model)
        class TestM2M1:
            idmodel1 = Int(primary_key=True)

        @register(Model)
        class TestM2M2:
            idmodel2 = Int(primary_key=True)
            rel_m2m = Many2Many(label="Rel", model=Model.TestM2M1,
                                join_table='reltable',
                                remote_columns='idmodel1',
                                m2m_remote_columns='idmodel1',
                                local_columns='idmodel2',
                                m2m_local_columns='idmodel2',
                                many2many='rel_m2m_inv')

        EnvironmentManager.set('current_blok', None)
コード例 #29
0
def asgi() -> None:
    """uvicorn ASGI dev server"""

    load_init_function_from_entry_points()
    argv: List[str] = copy(sys.argv)
    Configuration.load("uvicorn")
    sys.argv = argv
    configuration_post_load()
    BlokManager.load()

    kwargs = {
        "app": create_app(preload_database(loadwithoutmigration=False)),
        "host": Configuration.get("host"),
        "port": Configuration.get("port"),
        # "uds": uds,
        # "fd": fd,
        # "loop": loop,
        # "http": http,
        # "ws": ws,
        # "lifespan": lifespan,
        # "env_file": env_file,
        # "log_config": LOGGING_CONFIG if log_config is None else log_config,
        # "log_level": log_level,
        # "access_log": access_log,
        # "interface": interface,
        # "debug": debug,
        # "reload": reload,
        # "reload_dirs": reload_dirs if reload_dirs else None,
        # "workers": workers,
        # "proxy_headers": proxy_headers,
        # "forwarded_allow_ips": forwarded_allow_ips,
        # "root_path": root_path,
        # "limit_concurrency": limit_concurrency,
        # "backlog": backlog,
        # "limit_max_requests": limit_max_requests,
        # "timeout_keep_alive": timeout_keep_alive,
        # "ssl_keyfile": ssl_keyfile,
        # "ssl_certfile": ssl_certfile,
        # "ssl_version": ssl_version,
        # "ssl_cert_reqs": ssl_cert_reqs,
        # "ssl_ca_certs": ssl_ca_certs,
        # "ssl_ciphers": ssl_ciphers,
        # "headers": list([header.split(":") for header in headers]),
        # "use_colors": use_colors,
    }

    run(**kwargs)
コード例 #30
0
def update_project():
    anyblok.load_init_function_from_entry_points()
    Configuration.load('update-project')
    anyblok.configuration_post_load()
    BlokManager.load()
    db_name = Configuration.get('db_name')
    logger.info("update project: db_name=%r", db_name)

    to_install = []
    to_update = []
    to_uninstall = []

    url = get_url()
    options = {}
    if not database_exists(url):
        db_template_name = Configuration.get('db_template_name', None)
        create_database(url, template=db_template_name)
        to_install.append('team')
        version = None
    else:
        options.update(dict(loadwithoutmigration=True))

    registry = RegistryManager.get(db_name, **options)
    registry.update_blok_list()  # case, new blok added
    version = registry.System.Blok.query().filter_by(
        name='team').one().installed_version

    if version is None:
        pass
    else:
        to_update.append('team')

    registry.upgrade(install=to_install,
                     update=to_update,
                     uninstall=to_uninstall)

    if version is None:
        registry.Pyramid.User.insert(login='******')
        registry.Pyramid.CredentialStore.insert(login='******',
                                                password='******')

    registry.commit()
    registry.close()
    logger.info("Project updated: db_name=%r", db_name)
コード例 #31
0
ファイル: plugins.py プロジェクト: zakibelm/AnyBlok
    def load_registry(self):
        if not self.enabled or self.registryLoaded:
            return

        from anyblok.config import Configuration, get_db_name
        from anyblok import (
            load_init_function_from_entry_points,
            configuration_post_load,
        )
        from anyblok.blok import BlokManager
        from anyblok.registry import RegistryManager, return_list

        # Load the registry here not in configuration,
        # because the configurations are not loaded in order of score
        self.registryLoaded = True
        load_init_function_from_entry_points(unittest=True)
        Configuration.load_config_for_test()
        Configuration.parse_options(self.AnyBlokOptions)
        configuration_post_load()
        BlokManager.load()
        db_name = get_db_name()

        registry = RegistryManager.get(db_name)
        if not registry:
            return

        installed_bloks = registry.System.Blok.list_by_state("installed")
        selected_bloks = return_list(
            Configuration.get('selected_bloks')) or installed_bloks

        unwanted_bloks = return_list(Configuration.get('unwanted_bloks')) or []

        self.authorized_blok_paths = set(
            BlokManager.getPath(b) for b in BlokManager.list()
            if b in selected_bloks and b not in unwanted_bloks)

        test_dirs = self.authorized_blok_test_dirs = set()
        for startpath in self.authorized_blok_paths:
            for root, dirs, _ in walk(startpath):
                if 'tests' in dirs:
                    test_dirs.add(join(root, 'tests'))

        registry.close()  # free the registry to force create it again
コード例 #32
0
ファイル: scripts.py プロジェクト: fjouatte/Anyblok_Pyramid
def wsgi():
    """Simple wsgi server for dev
    """
    load_init_function_from_entry_points()
    Configuration.load('pyramid')
    configuration_post_load()
    BlokManager.load()
    config = Configurator()
    config.include_from_entry_point()
    config.load_config_bloks()

    wsgi_host = Configuration.get('wsgi_host')
    wsgi_port = int(Configuration.get('wsgi_port'))

    app = config.make_wsgi_app()
    server = make_server(wsgi_host, wsgi_port, app)
    preload_databases(loadwithoutmigration=False)

    logger.info("Serve forever on %r:%r" % (wsgi_host, wsgi_port))
    server.serve_forever()
コード例 #33
0
ファイル: scripts.py プロジェクト: AnyBlok/Anyblok_Pyramid
def wsgi():
    """Simple wsgi server for dev
    """
    load_init_function_from_entry_points()
    Configuration.load('pyramid')
    configuration_post_load()
    BlokManager.load()
    config = Configurator()
    config.include_from_entry_point()
    config.load_config_bloks()

    wsgi_host = Configuration.get('wsgi_host')
    wsgi_port = int(Configuration.get('wsgi_port'))

    app = config.make_wsgi_app()
    server = make_server(wsgi_host, wsgi_port, app)
    preload_databases(loadwithoutmigration=False)

    logger.info("Serve forever on %r:%r" % (wsgi_host, wsgi_port))
    server.serve_forever()
コード例 #34
0
def init_session(request, configuration_loaded):
    # Init registry
    additional_setting = {'unittest': True}

    if len(BlokManager.list()) == 0:
        BlokManager.load()
    registry = RegistryManager.get(Configuration.get('db_name'),
                                   **additional_setting)
    registry.commit()
    # Add savepoint
    registry.begin_nested()

    @event.listens_for(registry.session, 'after_transaction_end')
    def restart_savepoint(session, transaction):
        if transaction.nested and not transaction._parent.nested:
            session.expire_all()
            session.begin_nested()

    logger.info('Creating registry')
    yield registry

    request.addfinalizer(registry.session.close)
コード例 #35
0
ファイル: plugins.py プロジェクト: gracinet/AnyBlok
    def load_registry(self):
        if self.enabled and self.registryLoaded is False:
            # Load the registry here not in configuration,
            # because the configuration are not load in order of score
            self.registryLoaded = True
            load_init_function_from_entry_points(unittest=True)
            Configuration.load_config_for_test()
            Configuration.parse_options(self.AnyBlokOptions)
            configuration_post_load()
            BlokManager.load()
            db_name = get_db_name()

            registry = RegistryManager.get(db_name)
            if registry:
                installed_bloks = registry.System.Blok.list_by_state(
                    "installed")
                selected_bloks = return_list(
                    Configuration.get('selected_bloks')) or installed_bloks

                unwanted_bloks = return_list(
                    Configuration.get('unwanted_bloks')) or []

                self.bloks_path = [BlokManager.getPath(x)
                                   for x in BlokManager.ordered_bloks]

                self.authoried_bloks_test_files = []
                for blok in installed_bloks:
                    if blok not in selected_bloks or blok in unwanted_bloks:
                        continue

                    startpath = BlokManager.getPath(blok)
                    for root, dirs, _ in walk(startpath):
                        if 'tests' in dirs:
                            self.authoried_bloks_test_files.append(
                                join(root, 'tests'))

                registry.close()  # free the registry to force create it again
コード例 #36
0
def bloks_loaded(request):
    request.addfinalizer(BlokManager.unload)
    BlokManager.load()
コード例 #37
0
ファイル: blok.py プロジェクト: gracinet/AnyBlok
def setup(app):
    BlokManager.load()
    app.add_autodocumenter(AnyBlokDeclarationDocumenter)
    app.add_autodocumenter(AnyBlokMethodDocumenter)
    return {'version': version, 'parallel_read_safe': True}
コード例 #38
0
 def load(self) -> "FastAPI":
     BlokManager.load(entry_points=("bloks", ))
     return create_app(preload_database())
コード例 #39
0
def bloks_loaded(request, configuration_loaded):
    request.addfinalizer(BlokManager.unload)
    BlokManager.load()
コード例 #40
0
ファイル: wsgi.py プロジェクト: jssuzanne/Anyblok_Pyramid
from os import environ, path
from appdirs import AppDirs
from anyblok import load_init_function_from_entry_points

if BlokManager.bloks:
    # AnyBlok already load, the state are not sure, better to stop here
    sys.exit(1)


load_init_function_from_entry_points()
# load default files
ad = AppDirs('AnyBlok')
# load the global configuration file
Configuration.parse_configfile(path.join(ad.site_config_dir, 'conf.cfg'), ())
# load the user configuration file
Configuration.parse_configfile(path.join(ad.user_config_dir, 'conf.cfg'), ())
# load config file in environment variable
configfile = environ.get('ANYBLOK_CONFIGFILE')
if configfile:
    Configuration.parse_configfile(configfile, ())

if 'logging_level' in Configuration.configuration:
    Configuration.initialize_logging()

BlokManager.load()
preload_databases()
config = Configurator()
config.include_from_entry_point()
config.load_config_bloks()
app = config.make_wsgi_app()
コード例 #41
0
ファイル: testcase.py プロジェクト: jssuzanne/AnyBlok
 def setUp(self):
     """ Create a database and load the blok manager """
     self.registry = None
     super(DBTestCase, self).setUp()
     BlokManager.load(entry_points=self.blok_entry_points)
コード例 #42
0
ファイル: testcase.py プロジェクト: gracinet/AnyBlok
 def setUp(self):
     """ Create a database and load the blok manager """
     self.registry = None
     super(DBTestCase, self).setUp()
     BlokManager.load(entry_points=self.blok_entry_points)
コード例 #43
0
 def test_load_without_blok_group(self):
     try:
         BlokManager.load(entry_points=())
         self.fail('No watchdog to load without blok groups')
     except BlokManagerException:
         pass
コード例 #44
0
 def test_load_with_invalid_blok_group(self):
     try:
         BlokManager.load(entry_points=('Invalid blok group', ))
         self.fail('Load with invalid blok group')
     except BlokManagerException:
         pass
コード例 #45
0
ファイル: test_migration.py プロジェクト: AnyBlok/AnyBlok
    def setUpClass(cls):
        super(TestMigration, cls).setUpClass()
        cls.init_configuration_manager()
        cls.createdb()
        BlokManager.load()

        register = Declarations.register
        Model = Declarations.Model

        cls.loaded_bloks = deepcopy(RegistryManager.loaded_bloks)
        EnvironmentManager.set('current_blok', 'anyblok-core')

        @register(Model)
        class Test:
            integer = Int(primary_key=True)
            other = Str()

        @register(Model)
        class TestUnique:
            integer = Int(primary_key=True)
            other = Str(unique=True)

        @register(Model)
        class TestIndex:
            integer = Int(primary_key=True)
            other = Str(index=True)

        @register(Model)
        class TestCheck:
            integer = Int(primary_key=True)

            @classmethod
            def define_table_args(cls):
                table_args = super(TestCheck, cls).define_table_args()
                return table_args + (
                    CheckConstraint('integer > 0', name='test'),)

        @register(Model)
        class TestCheckLongConstraintName:
            integer = Int(primary_key=True)

            @classmethod
            def define_table_args(cls):
                table_args = super(TestCheckLongConstraintName,
                                   cls).define_table_args()
                return table_args + (
                    CheckConstraint('integer > 0', name=(
                        'long_long_long_long_long_long_long_long_long_long_'
                        'long_long_long_long_long_long_long_long_test')),)

        @register(Model)
        class TestFKTarget:
            integer = Int(primary_key=True)

        @register(Model)
        class TestFK:
            integer = Int(primary_key=True)
            other = Int(
                foreign_key=Model.TestFKTarget.use('integer'))

        @register(Model)
        class TestFK2:
            integer = Int(primary_key=True)
            other = Int(
                foreign_key=Model.TestFKTarget.use('integer').options(
                    ondelete='cascade'))

        @register(Model)
        class TestM2M1:
            idmodel1 = Int(primary_key=True)

        @register(Model)
        class TestM2M2:
            idmodel2 = Int(primary_key=True)
            rel_m2m = Many2Many(label="Rel", model=Model.TestM2M1,
                                join_table='reltable',
                                remote_columns='idmodel1',
                                m2m_remote_columns='idmodel1',
                                local_columns='idmodel2',
                                m2m_local_columns='idmodel2',
                                many2many='rel_m2m_inv')

        EnvironmentManager.set('current_blok', None)
コード例 #46
0
ファイル: test_blok.py プロジェクト: petrus-v/AnyBlok
 def test_load_without_blok_group(self):
     try:
         BlokManager.load(entry_points=())
         self.fail('No watchdog to load without blok groups')
     except BlokManagerException:
         pass
コード例 #47
0
ファイル: test_blok.py プロジェクト: petrus-v/AnyBlok
 def test_load_with_invalid_blok_group(self):
     try:
         BlokManager.load(entry_points=('Invalid blok group',))
         self.fail('Load with invalid blok group')
     except BlokManagerException:
         pass
コード例 #48
0
    def setUpClass(cls):
        super(TestMigration, cls).setUpClass()
        cls.init_configuration_manager()
        cls.createdb()
        BlokManager.load()

        register = Declarations.register
        Model = Declarations.Model

        cls.loaded_bloks = deepcopy(RegistryManager.loaded_bloks)
        EnvironmentManager.set('current_blok', 'anyblok-core')

        @register(Model)
        class Test:
            integer = Int(primary_key=True)
            other = Str()

        @register(Model)
        class TestUnique:
            integer = Int(primary_key=True)
            other = Str(unique=True)

        @register(Model)
        class TestIndex:
            integer = Int(primary_key=True)
            other = Str(index=True)

        @register(Model)
        class TestCheck:
            integer = Int(primary_key=True)

            @classmethod
            def define_table_args(cls):
                table_args = super(TestCheck, cls).define_table_args()
                return table_args + (CheckConstraint('integer > 0',
                                                     name='test'), )

        @register(Model)
        class TestCheckLongConstraintName:
            integer = Int(primary_key=True)

            @classmethod
            def define_table_args(cls):
                table_args = super(TestCheckLongConstraintName,
                                   cls).define_table_args()
                return table_args + (CheckConstraint(
                    'integer > 0',
                    name=('long_long_long_long_long_long_long_long_long_long_'
                          'long_long_long_long_long_long_long_long_test')), )

        @register(Model)
        class TestFKTarget:
            integer = Int(primary_key=True)

        @register(Model)
        class TestFK:
            integer = Int(primary_key=True)
            other = Int(foreign_key=Model.TestFKTarget.use('integer'))

        @register(Model)
        class TestFK2:
            integer = Int(primary_key=True)
            other = Int(foreign_key=Model.TestFKTarget.use('integer').options(
                ondelete='cascade'))

        @register(Model)
        class TestM2M1:
            idmodel1 = Int(primary_key=True)

        @register(Model)
        class TestM2M2:
            idmodel2 = Int(primary_key=True)
            rel_m2m = Many2Many(label="Rel",
                                model=Model.TestM2M1,
                                join_table='reltable',
                                remote_columns='idmodel1',
                                m2m_remote_columns='idmodel1',
                                local_columns='idmodel2',
                                m2m_local_columns='idmodel2',
                                many2many='rel_m2m_inv')

        EnvironmentManager.set('current_blok', None)
コード例 #49
0
ファイル: blok.py プロジェクト: AnyBlok/AnyBlok
def setup(app):
    BlokManager.load()
    app.add_autodocumenter(AnyBlokDeclarationDocumenter)
    app.add_autodocumenter(AnyBlokMethodDocumenter)
    return {'version': version, 'parallel_read_safe': True}
コード例 #50
0
 def test_reload_blok(self):
     BlokManager.load()
     try:
         RegistryManager.reload()
     finally:
         BlokManager.unload()
コード例 #51
0
 def test_reload_blok(self):
     BlokManager.load()
     try:
         RegistryManager.reload()
     finally:
         BlokManager.unload()