def __init__(self,
networking=None,
config=None,
workingdir=None,
domain_id=None,
loglevel="all",
logname=None):
self.networking = networking
self.core = networking.core
self.stats = networking.core.stats
self.logger = logger.get_logger(key="data_handler",
level=loglevel,
logname=logname)
self.domain_id = domain_id
self.domain_id_str = bbclib.convert_id_to_string(domain_id)
self.config = config
self.working_dir = workingdir
self.storage_root = os.path.join(self.working_dir, self.domain_id_str)
if not os.path.exists(self.storage_root):
os.makedirs(self.storage_root, exist_ok=True)
self.use_external_storage = self.storage_setup()
self.replication_strategy = DataHandler.REPLICATION_ALL
self.db_adaptors = list()
self.dbs = list()
self.db_setup()
def __init__(self,
network=None,
config=None,
domain_id=None,
node_id=None,
loglevel="all",
logname=None):
self.network = network
self.config = config
self.node_id = node_id
self.domain_id = domain_id
self.logger = logger.get_logger(
key="domain:%s" % binascii.b2a_hex(domain_id[:4]).decode(),
level=loglevel,
logname=logname)
if node_id is None:
self.logger.error("node_id must be specified!")
return
self.shortname = binascii.b2a_hex(node_id[:2]) # for debugging
self.default_payload_type = PayloadType.Type_msgpack
self.id_ip_mapping = dict()
self.registered_user_id = dict()
self.user_id_forward_cache = dict()
self.refresh_entry = None
self.set_refresh_timer()
def __init__(self,
domain_id,
namespace_id=default_namespace_id,
port=DEFAULT_CORE_PORT,
logname="-",
loglevel="none"):
self.logger = logger.get_logger(
key="id_lib", level=loglevel,
logname=logname) # FIXME: use the logger
self.domain_id = domain_id
self.namespace_id = namespace_id
self.__app = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT,
loglevel=loglevel)
self.__app.set_user_id(id_publickey_map_user_id)
self.__app.set_domain_id(domain_id)
self.__app.set_callback(bbc_app.Callback())
ret = self.__app.register_to_core()
assert ret
self.__db = app_support_lib.Database()
self.__db.setup_db(domain_id, NAME_OF_DB)
self.__db.create_table_in_db(domain_id,
NAME_OF_DB,
'id_pubkey_table',
id_pubkey_table_definition,
indices=[0, 1])
def __init__(self,
domain_id,
mint_id,
user_id,
idPublickeyMap,
port=DEFAULT_CORE_PORT,
logname="-",
loglevel="none"):
self.logger = logger.get_logger(key="token_lib",
level=loglevel,
logname=logname) # FIXME: use logger
self.condition = 0
self.domain_id = domain_id
self.mint_id = mint_id
self.user_id = user_id
self.idPublickeyMap = idPublickeyMap
self.app = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT,
loglevel=loglevel)
self.app.set_user_id(user_id)
self.app.set_domain_id(domain_id)
self.app.set_callback(MintCallback(logger, self))
ret = self.app.register_to_core()
assert ret
self.store = Store(self.domain_id, self.mint_id, self.app)
self.app.request_insert_completion_notification(self.mint_id)
def __init__(self,
config,
enabled=False,
dbtype="sqlite",
loglevel="all",
logname=None):
"""
Constructs a ledger subsystem. Just supports sqlite3.
:param config: configuration object
:param enabled: if communication with the underlying ledger is enabled
:param dbtype: type of database system
:param loglevel: loggging level
:param logname: name of log
:return:
"""
self.logger = logger.get_logger(key="ledger_subsystem",
level=loglevel,
logname=logname)
self.queue = Queue()
self.config = config
self.enabled = enabled
conf = self.config.get_config()
self.eth = None
self.temp_file = conf['workingdir'] + '/ledger_subsystem.json'
self.capacity = conf['ledger_subsystem']['max_transactions']
self.interval = conf['ledger_subsystem']['max_seconds']
self.dbtype = dbtype
if self.enabled:
self.enable()
thread_loop = threading.Thread(target=self.subsystem_loop)
thread_loop.setDaemon(True)
thread_loop.start()
def __init__(self, dbtype="sqlite", loglevel="all", logname=None):
self.logger = logger.get_logger(key="app_support_db",
level=loglevel,
logname=logname)
self.dbtype = dbtype
self.db_name = dict()
self.db = dict()
self.db_cur = dict()
def __init__(self, networking, domain_id, loglevel="all", logname=None):
self.networking = networking
self.stats = networking.core.stats
self.domain_id = domain_id
self.logger = logger.get_logger(key="user_message_routing",
level=loglevel,
logname=logname)
self.aes_name_list = dict()
self.cross_ref_list = list()
self.registered_users = dict()
self.forwarding_entries = dict()
self.on_going_timers = set()
def __init__(self,
host='127.0.0.1',
port=DEFAULT_CORE_PORT,
logname="-",
loglevel="none"):
self.logger = logger.get_logger(key="bbc_app",
level=loglevel,
logname=logname)
self.connection = socket.create_connection((host, port))
self.callback = Callback(log=self.logger)
self.asset_groups = set()
self.user_id = None
self.query_id = (0).to_bytes(2, 'little')
self.start_receiver_loop()
def __init__(self,
handler=None,
db_name=None,
db_num=0,
loglevel="all",
logname=None):
self.handler = handler
self.db = None
self.db_cur = None
self.db_name = db_name
self.db_num = db_num
self.placeholder = ""
self.logger = logger.get_logger(key="db_adaptor",
level=loglevel,
logname=logname)
def __init__(self, config, core=None, loglevel="all", logname=None):
self.logger = logger.get_logger(key="bbc_storage",
level=loglevel,
logname=logname)
self.config = config
self.core = core
conf = self.config.get_config()
if 'storage' in conf and 'root' in conf['storage']:
if conf['storage']['root'].startswith("/"):
self.storage_root = conf['storage']['root'] + "/"
else:
self.storage_root = conf['workingdir'] + "/"
else:
self.storage_root = conf['workingdir'] + "/"
os.makedirs(self.storage_root, exist_ok=True)
self.storage_type = dict()
self.storage_path = dict()
def __init__(self, network=None, domain_id=None, workingdir=".", loglevel="all", logname=None):
if network is not None:
self.network = network
self.core = network.core
self.stats = network.core.stats
self.data_handler = network.domains[domain_id]['data']
else:
self.stats = BBcStats()
self.repair_log = os.path.join(workingdir, domain_id.hex(), "repair_log.json")
self.logger = logger.get_logger(key="repair_manager", level=loglevel, logname=logname)
self.domain_id = domain_id
self.queue = queue.Queue()
self.requesting_list = dict()
self.loop_flag = True
th_nw_loop = threading.Thread(target=self.manager_loop)
th_nw_loop.setDaemon(True)
th_nw_loop.start()
def __init__(self,
config,
networking=None,
domain_id=None,
enabled=False,
loglevel="all",
logname=None):
"""
Constructs a ledger subsystem. Just supports sqlite3.
:param config: configuration object
:param networking: networking (need access to ledger manager)
:param domain_id:
:param enabled: if communication with the underlying ledger is enabled
:param loglevel: loggging level
:param logname: name of log
:return:
"""
self.networking = networking
self.domain_id = domain_id
if domain_id is None:
return
self.data_handler = self.networking.domains[domain_id]['data']
self.logger = logger.get_logger(key="ledger_subsystem",
level=loglevel,
logname=logname)
self.queue = Queue()
self.enabled = enabled
self.config = config.get_domain_config(self.domain_id)
conf = config.get_config()
self.eth_config = None if "ethereum" not in conf else conf["ethereum"]
self.eth = None
self.capacity = self.config['ledger_subsystem']['max_transactions']
self.interval = self.config['ledger_subsystem']['max_seconds']
self.timer = None
self.temp_file_dic = os.path.join(self.data_handler.storage_root,
'ledger_subsystem.json')
if self.enabled:
self.enable()
thread_loop = threading.Thread(target=self.subsystem_loop)
thread_loop.setDaemon(True)
thread_loop.start()
def __init__(self,
config,
core=None,
p2p_port=None,
external_ip4addr=None,
external_ip6addr=None,
loglevel="all",
logname=None):
self.core = core
self.stats = core.stats
self.logger = logger.get_logger(key="bbc_network",
level=loglevel,
logname=logname)
self.logname = logname
self.loglevel = loglevel
self.config = config
self.domain0manager = None
conf = self.config.get_config()
self.domains = dict()
self.ip_address, self.ip6_address = check_my_IPaddresses()
if external_ip4addr is not None:
self.external_ip4addr = external_ip4addr
else:
self.external_ip4addr = self.ip_address
if external_ip6addr is not None:
self.external_ip6addr = external_ip6addr
else:
self.external_ip6addr = self.ip6_address
if p2p_port is not None:
conf['network']['p2p_port'] = p2p_port
self.config.update_config()
self.port = conf['network']['p2p_port']
self.socket_udp = None
self.socket_udp6 = None
if not self.setup_udp_socket():
self.logger.error("** Fail to setup UDP socket **")
return
self.listen_socket = None
self.listen_socket6 = None
self.max_connections = conf['network']['max_connections']
if not self.setup_tcp_server():
self.logger.error("** Fail to setup TCP server **")
return
def __init__(self,
network=None,
config=None,
domain_id=None,
node_id=None,
loglevel="all",
logname=None):
self.network = network
self.stats = network.core.stats
self.neighbors = network.domains[domain_id]['neighbor']
self.config = config
self.domain_id = domain_id
self.logger = logger.get_logger(
key="topology_manager:%s" %
binascii.b2a_hex(domain_id[:4]).decode(),
level=loglevel,
logname=logname)
self.my_node_id = node_id
self.advertise_wait_entry = None
self.neighbor_refresh_timer_entry = None
self.update_refresh_timer_entry()
def __init__(self,
host='127.0.0.1',
port=DEFAULT_CORE_PORT,
logname="-",
loglevel="none"):
self.logger = logger.get_logger(key="bbc_app",
level=loglevel,
logname=logname)
self.connection = socket.create_connection((host, port))
self.callback = Callback(log=self.logger)
self.callback.set_client(self)
self.domain_keypair = None
self.default_node_keypair = None
self.use_query_id_based_message_wait = False
self.user_id = None
self.domain_id = None
self.query_id = (0).to_bytes(2, 'little')
self.privatekey_for_ecdh = None
self.aes_key_name = None
self.is_secure_connection = False
self.cross_ref_list = list()
self.start_receiver_loop()
def __init__(self, config, dbtype="sqlite", loglevel="all", logname=None):
"""
only support sqlite3
:param dbtype: type of database system
"""
self.config = config
conf = self.config.get_config()
self.logger = logger.get_logger(key="bbc_ledger",
level=loglevel,
logname=logname)
if 'ledger' not in conf:
self.logger.error("No 'ledger' entry in config!!")
os._exit(1)
if 'type' not in conf['ledger']:
self.logger.error("No 'ledger'.'type' entry in config!!")
os._exit(1)
if conf['ledger']['type'] != "sqlite3":
self.logger.error("Currently, only sqlite3 is supported.")
os._exit(1)
self.dbtype = dbtype
self.db_name = dict()
self.db = dict()
self.db_cur = dict()
def __init__(self,
config,
core=None,
p2p_port=None,
use_global=True,
loglevel="all",
logname=None):
self.core = core
self.logger = logger.get_logger(key="bbc_network",
level=loglevel,
logname=logname)
self.logname = logname
self.config = config
self.use_global = use_global
conf = self.config.get_config()
self.domains = dict()
self.asset_groups_to_advertise = set()
self.ip_address, self.ip6_address = check_my_IPaddresses()
if p2p_port is not None:
conf['network']['p2p_port'] = p2p_port
self.config.update_config()
self.port = conf['network']['p2p_port']
self.socket_udp = None
self.socket_udp6 = None
if not self.setup_udp_socket():
self.logger.error("** Fail to setup UDP socket **")
return
self.listen_socket = None
self.listen_socket6 = None
self.max_connections = conf['network']['max_connections']
if not self.setup_tcp_server():
self.logger.error("** Fail to setup TCP server **")
return
if 'domains' not in conf:
return
for dm in conf['domains'].keys():
domain_id = bbclib.convert_idstring_to_bytes(dm)
if not self.use_global and domain_id == bbclib.domain_global_0:
continue
c = conf['domains'][dm]
nw_module = c.get('module', 'simple_cluster')
self.create_domain(domain_id=domain_id, network_module=nw_module)
if 'special_domain' in c:
c.pop('storage_type', None)
c.pop('storage_path', None)
else:
self.core.ledger_manager.add_domain(domain_id)
for asset_group_id_str, info in c['asset_group_ids'].items():
asset_group_id = bbclib.convert_idstring_to_bytes(
asset_group_id_str)
self.core.asset_group_setup(
domain_id, asset_group_id,
c.get('storage_type', StorageType.FILESYSTEM),
c.get('storage_path', None),
c.get('advertise_in_domain0', False))
for nd, info in c['static_nodes'].items():
node_id, ipv4, ipv6, port = bbclib.convert_idstring_to_bytes(
nd), info[0], info[1], info[2]
self.add_static_node_to_domain(domain_id, node_id, ipv4, ipv6,
port)
for nd, info in c['peer_list'].items():
node_id, ipv4, ipv6, port = bbclib.convert_idstring_to_bytes(
nd), info[0], info[1], info[2]
self.domains[domain_id].add_peer_node_ip46(
node_id, ipv4, ipv6, port)
