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,
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, 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,
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.upgraded_from = DB_VERSION
self.db_adaptors = list()
self._db_setup()
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, 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,
config,
networking=None,
domain_id=None,
enabled=False,
loglevel="all",
logname=None):
"""Constructs a ledger subsystem. Currently just supports sqlite3.
Args:
config (BBcConfig): The configuration object
networking: The networking (need access to ledger manager)
domain_id (bytes): The domain ID.
enabled (bool): If communication with the subsystem is enabled.
loglevel (str): The loggging level.
logname (str): The name of the log.
"""
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)
if 'ethereum' in self.config:
self.eth_config = self.config['ethereum']
else:
conf = config.get_config()
self.eth_config = \
None if 'ethereum' not in conf else conf['ethereum']
self.eth = None
if 'ledger_subsystem' not in self.config:
self.config['ledger_subsystem'] = {
'subsystem': DEFAULT_SUBSYSTEM,
'max_transactions': DEFAULT_CAPACITY,
'max_seconds': DEFAULT_INTERVAL,
}
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, 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, domain_id_str=None, config=None, workingdir=None):
self.logger = logger.get_logger("dummy")
self.config = config
self.working_dir = workingdir
self.storage_root = os.path.join(self.working_dir, domain_id_str)
if not os.path.exists(self.storage_root):
os.makedirs(self.storage_root, exist_ok=True)
self.stats = bbc_stats.BBcStats() # dummy
self.upgraded_from = data_handler.DB_VERSION
self.db_adaptors = list()
self.dbs = list()
self._db_setup()
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, networking=None, node_id=None, loglevel="all", logname=None):
self.networking = networking
self.stats = networking.core.stats
self.my_node_id = node_id
self.logger = logger.get_logger(key="domain0", level=loglevel, logname=logname)
self.domains_belong_to = set()
self.domain_list = dict() # {domain_id: list(node_id,,,)}
self.node_domain_list = dict() # {node_id: {domain_id: expiration_time}}
self.domain_accept_margin = dict()
self.requested_cross_refs = dict()
self.remove_lock = threading.Lock()
self.advertise_timer_entry = None
self._update_advertise_timer_entry()
self.cross_ref_timer_entry = None
self._update_cross_ref_timer_entry()
def __init__(self, dbtype="sqlite", loglevel="all", logname=None):
"""Initializes the object.
Args:
dbtype (str): The type of database. "sqlite" by default.
loglevel (str): The logging level. "all" by default.
logname (str): The logger name. None by default.
"""
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,
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,
domain_id,
namespace_id=default_namespace_id,
port=DEFAULT_CORE_PORT,
logname="-",
loglevel="none",
default_key_type=bbclib.DEFAULT_CURVETYPE):
"""Initializes the object.
Args:
domain_id (bytes): The application domain.
namespace_id (bytes): The name space. default_namespace_id exists.
port (int): The port to the core. DEFAULT_CORE_PORT by default.
logname (str): The name of the log.
loglevel (str): The logging level. "none" by default.
default_key_type (int): Default public key type.
"""
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.default_key_type = default_key_type
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=[IDX_USER_ID, IDX_PUBLIC_KEY])
def __init__(self,
host='127.0.0.1',
port=DEFAULT_CORE_PORT,
multiq=True,
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.keypair = None
self.node_keypair = None
self.use_query_id_based_message_wait = multiq
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()
