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)