def get_chaindb_manager(trinity_config: TrinityConfig,
base_db: BaseAtomicDB) -> BaseManager:
chain_config = trinity_config.get_chain_config()
chaindb = AsyncChainDB(base_db)
if not is_database_initialized(chaindb):
initialize_database(chain_config, chaindb, base_db)
headerdb = AsyncHeaderDB(base_db)
class DBManager(BaseManager):
pass
DBManager.register('get_db',
callable=lambda: TracebackRecorder(base_db),
proxytype=DBProxy)
DBManager.register(
'get_chaindb',
callable=lambda: TracebackRecorder(chaindb),
proxytype=ChainDBProxy,
)
DBManager.register(
'get_headerdb',
callable=lambda: TracebackRecorder(headerdb),
proxytype=AsyncHeaderDBProxy,
)
manager = DBManager(address=str(
trinity_config.database_ipc_path)) # type: ignore
return manager
def get_base_db(boot_info: BootInfo) -> LevelDB:
app_config = boot_info.trinity_config.get_app_config(Eth1AppConfig)
base_db = LevelDB(db_path=app_config.database_dir)
chaindb = ChainDB(base_db)
if not is_database_initialized(chaindb):
chain_config = app_config.get_chain_config()
initialize_database(chain_config, chaindb, base_db)
return base_db
def get_chaindb_manager(trinity_config: TrinityConfig,
base_db: BaseAtomicDB) -> BaseManager:
chaindb = AsyncChainDB(base_db)
if not is_database_initialized(chaindb):
initialize_database(trinity_config, chaindb)
chain_class: Type[BaseChain]
chain: BaseChain
if trinity_config.network_id == MAINNET_NETWORK_ID:
chain_class = MainnetChain
chain = chain_class(base_db)
elif trinity_config.network_id == ROPSTEN_NETWORK_ID:
chain_class = RopstenChain
chain = chain_class(base_db)
else:
raise NotImplementedError(
"Only the ropsten and mainnet chains are supported")
headerdb = AsyncHeaderDB(base_db)
header_chain = AsyncHeaderChain(base_db)
class DBManager(BaseManager):
pass
# Typeshed definitions for multiprocessing.managers is incomplete, so ignore them for now:
# https://github.com/python/typeshed/blob/85a788dbcaa5e9e9a62e55f15d44530cd28ba830/stdlib/3/multiprocessing/managers.pyi#L3
DBManager.register( # type: ignore
'get_db',
callable=lambda: TracebackRecorder(base_db),
proxytype=DBProxy)
DBManager.register( # type: ignore
'get_chaindb',
callable=lambda: TracebackRecorder(chaindb),
proxytype=ChainDBProxy,
)
DBManager.register( # type: ignore
'get_chain',
callable=lambda: TracebackRecorder(chain),
proxytype=ChainProxy)
DBManager.register( # type: ignore
'get_headerdb',
callable=lambda: TracebackRecorder(headerdb),
proxytype=AsyncHeaderDBProxy,
)
DBManager.register( # type: ignore
'get_header_chain',
callable=lambda: TracebackRecorder(header_chain),
proxytype=AsyncHeaderChainProxy,
)
manager = DBManager(address=str(
trinity_config.database_ipc_path)) # type: ignore
return manager
def get_chain(trinity_config: TrinityConfig) -> ChainAPI:
app_config = trinity_config.get_app_config(Eth1AppConfig)
ensure_eth1_dirs(app_config)
base_db = LevelDB(db_path=app_config.database_dir)
chain_config = app_config.get_chain_config()
chain = chain_config.full_chain_class(AtomicDB(base_db))
initialize_database(chain_config, chain.chaindb, base_db)
return chain
def get_chaindb_manager(trinity_config: TrinityConfig,
base_db: BaseAtomicDB) -> BaseManager:
chaindb = AsyncChainDB(base_db)
if not is_database_initialized(chaindb):
initialize_database(trinity_config, chaindb)
chain_class: Type[BaseChain]
chain: BaseChain
if trinity_config.network_id == MAINNET_NETWORK_ID:
chain_class = MainnetChain
chain = chain_class(base_db)
elif trinity_config.network_id == ROPSTEN_NETWORK_ID:
chain_class = RopstenChain
chain = chain_class(base_db)
else:
raise NotImplementedError(
"Only the ropsten and mainnet chains are supported")
headerdb = AsyncHeaderDB(base_db)
header_chain = AsyncHeaderChain(base_db)
class DBManager(BaseManager):
pass
DBManager.register('get_db',
callable=lambda: TracebackRecorder(base_db),
proxytype=DBProxy)
DBManager.register(
'get_chaindb',
callable=lambda: TracebackRecorder(chaindb),
proxytype=ChainDBProxy,
)
DBManager.register('get_chain',
callable=lambda: TracebackRecorder(chain),
proxytype=ChainProxy)
DBManager.register(
'get_headerdb',
callable=lambda: TracebackRecorder(headerdb),
proxytype=AsyncHeaderDBProxy,
)
DBManager.register(
'get_header_chain',
callable=lambda: TracebackRecorder(header_chain),
proxytype=AsyncHeaderChainProxy,
)
manager = DBManager(address=str(
trinity_config.database_ipc_path)) # type: ignore
return manager
def _run() -> None:
from eth.db.backends.level import LevelDB
from eth.db.chain import ChainDB
from trinity.cli_parser import parser
from trinity.config import Eth1AppConfig, TrinityConfig
from trinity.constants import APP_IDENTIFIER_ETH1
from trinity.initialization import (
initialize_data_dir,
is_data_dir_initialized,
is_database_initialized,
initialize_database,
ensure_eth1_dirs,
)
# Require a root dir to be specified as we don't want to mess with the default one.
for action in parser._actions:
if action.dest == 'trinity_root_dir':
action.required = True
break
args = parser.parse_args()
# FIXME: Figure out a way to avoid having to set this.
args.sync_mode = "full"
logging.basicConfig(level=logging.INFO,
format='%(asctime)s %(levelname)s: %(message)s',
datefmt='%H:%M:%S')
for name, level in args.log_levels.items():
logging.getLogger(name).setLevel(level)
trinity_config = TrinityConfig.from_parser_args(args, APP_IDENTIFIER_ETH1,
(Eth1AppConfig, ))
trinity_config.trinity_root_dir.mkdir(exist_ok=True)
if not is_data_dir_initialized(trinity_config):
initialize_data_dir(trinity_config)
with trinity_config.process_id_file('database'):
app_config = trinity_config.get_app_config(Eth1AppConfig)
ensure_eth1_dirs(app_config)
base_db = LevelDB(db_path=app_config.database_dir)
chaindb = ChainDB(base_db)
if not is_database_initialized(chaindb):
chain_config = app_config.get_chain_config()
initialize_database(chain_config, chaindb, base_db)
manager = DBManager(base_db)
with manager.run(trinity_config.database_ipc_path):
try:
manager.wait_stopped()
except KeyboardInterrupt:
pass
def run_database_process(trinity_config: TrinityConfig,
db_class: Type[LevelDB]) -> None:
with trinity_config.process_id_file('database'):
app_config = trinity_config.get_app_config(Eth1AppConfig)
base_db = db_class(db_path=app_config.database_dir)
chaindb = ChainDB(base_db)
if not is_database_initialized(chaindb):
chain_config = app_config.get_chain_config()
initialize_database(chain_config, chaindb, base_db)
manager = DBManager(base_db)
with manager.run(trinity_config.database_ipc_path):
try:
manager.wait_stopped()
except KeyboardInterrupt:
pass
def create_db_server_manager(trinity_config: TrinityConfig,
base_db: BaseAtomicDB) -> BaseManager:
eth1_app_config = trinity_config.get_app_config(Eth1AppConfig)
chain_config = eth1_app_config.get_chain_config()
chaindb = ChainDB(base_db)
if not is_database_initialized(chaindb):
initialize_database(chain_config, chaindb, base_db)
headerdb = HeaderDB(base_db)
# This enables connection when clients launch from another process on the shell
multiprocessing.current_process().authkey = AUTH_KEY
class DBManager(BaseManager):
pass
DBManager.register('get_db',
callable=lambda: TracebackRecorder(base_db),
proxytype=AsyncDBProxy)
DBManager.register(
'get_chaindb',
callable=lambda: TracebackRecorder(chaindb),
proxytype=AsyncChainDBProxy,
)
DBManager.register(
'get_headerdb',
callable=lambda: TracebackRecorder(headerdb),
proxytype=AsyncHeaderDBProxy,
)
manager = DBManager(address=str(
trinity_config.database_ipc_path)) # type: ignore
return manager
def test_initialize_database(eth1_app_config, chaindb, base_db):
assert not is_database_initialized(chaindb)
initialize_database(eth1_app_config.get_chain_config(), chaindb, base_db)
assert is_database_initialized(chaindb)
def test_initialize_database(trinity_config, chaindb):
assert not is_database_initialized(chaindb)
initialize_database(trinity_config, chaindb)
assert is_database_initialized(chaindb)
