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 make_client(index,
core_port_increment,
callback=None,
connect_to_core=True,
domain_id=None):
keypair = bbclib.KeyPair()
keypair.generate()
clients[index]['user_id'] = bbclib.get_new_id("user_%i" % index)
clients[index]['keypair'] = keypair
clients[index]['app'] = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT +
core_port_increment,
multiq=False,
loglevel=loglv)
if connect_to_core:
if domain_id is None:
global common_domain_id
domain_id = common_domain_id
clients[index]['app'].set_user_id(clients[index]['user_id'])
clients[index]['app'].set_domain_id(domain_id)
if callback is not None:
clients[index]['app'].set_callback(callback)
working_dir = ".bbc1-%i/" % (DEFAULT_CORE_PORT + core_port_increment)
if os.path.exists(os.path.join(working_dir, "node_key.pem")):
clients[index]['app'].set_node_key(
os.path.join(working_dir, "node_key.pem"))
time.sleep(1)
print("[%i] user_id = %s" %
(index, binascii.b2a_hex(clients[index]['user_id'])))
def setup():
tmpclient = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT, multiq=False,
loglevel="all")
tmpclient.domain_setup(domain_id)
tmpclient.callback.synchronize()
tmpclient.unregister_from_core()
print("domain %s is created." % (binascii.b2a_hex(domain_id[:4]).decode()))
def setup_bbc_client(domain_id, user_id):
bbc_app_client = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT, multiq=False, loglevel="all")
bbc_app_client.set_user_id(user_id)
bbc_app_client.set_domain_id(domain_id)
bbc_app_client.set_callback(bbc_app.Callback())
ret = bbc_app_client.register_to_core()
assert ret
return bbc_app_client
def domain_setup():
tmpclient = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT, multiq=False, loglevel="all")
if os.path.exists("node_key.pem"):
tmpclient.set_node_key("node_key.pem")
tmpclient.domain_setup(domain_id)
tmpclient.callback.synchronize()
tmpclient.unregister_from_core()
print("Domain %s is created." % (binascii.b2a_hex(domain_id[:4]).decode()))
print("Setup is done.")
def setup():
g.store.setup()
tmpclient = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT, multiq=False,
loglevel="all")
tmpclient.domain_setup(domain_id)
tmpclient.callback.synchronize()
tmpclient.unregister_from_core()
return jsonify({'domain_id': binascii.b2a_hex(domain_id).decode()})
def setup_bbc_client(port_increase=0, user_id=None):
bbc_app_client = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT + port_increase, multiq=False, loglevel="all")
bbc_app_client.set_user_id(user_id)
bbc_app_client.set_domain_id(domain_id)
bbc_app_client.set_callback(bbc_app.Callback())
if os.path.exists(os.path.join(".bbc1-900%d" % port_increase, "node_key.pem")):
bbc_app_client.set_node_key(os.path.join(".bbc1-900%d" % port_increase, "node_key.pem"))
bbc_app_client.domain_setup(domain_id)
bbc_app_client.callback.synchronize()
return bbc_app_client
def default_domain_id():
domain_id = bbclib.get_new_id("test_id_lib", include_timestamp=False)
tmpclient = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT,
multiq=False,
loglevel="all")
tmpclient.domain_setup(domain_id)
tmpclient.callback.synchronize()
tmpclient.unregister_from_core()
return domain_id
def run_client():
client = bbc_app.BBcAppClient(port=bbc_config.DEFAULT_CORE_PORT,
multiq=False,
loglevel='all')
client.set_user_id(
bbclib.get_new_id('examples.certify_web', include_timestamp=False))
client.set_domain_id(domain_id)
client.set_callback(bbc_app.Callback())
ret = client.register_to_core()
assert ret
return client
def connect_core_to_domain():
tmpclient = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT,
multiq=False,
loglevel='all')
tmpclient.domain_setup(domain_id)
tmpclient.callback.synchronize()
tmpclient.unregister_from_core()
return jsonify(domain_id=domain_id_str), 200
def run_client(self):
self.check_domain_id()
self.client = bbc_app.BBcAppClient(port=bbc_config.DEFAULT_CORE_PORT,
multiq=False,
loglevel='all')
self.client.set_user_id(
bbclib.get_new_id('examples.certificates',
include_timestamp=False))
self.client.set_domain_id(self.domain_id)
self.client.set_callback(bbc_app.Callback())
ret = self.client.register_to_core()
assert ret
def domain_setup_utility(core_port_increment, dom_id):
cl = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT + core_port_increment,
multiq=False)
working_dir = ".bbc1-%i/" % (DEFAULT_CORE_PORT + core_port_increment)
if os.path.exists(os.path.join(working_dir, "node_key.pem")):
cl.set_node_key(os.path.join(working_dir, "node_key.pem"))
cl.domain_setup(dom_id)
global common_domain_id
common_domain_id = dom_id
wait_check_result_msg_type(cl.callback,
bbclib.MsgType.RESPONSE_SETUP_DOMAIN)
cl.unregister_from_core()
def setup():
global domain_id
global mint_id
global idPubkeyMap
global keypairs
domain_id = bbclib.get_new_id("test_token_lib", include_timestamp=False)
tmpclient = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT, loglevel="all")
tmpclient.domain_setup(domain_id, "simple_cluster")
tmpclient.callback.synchronize()
tmpclient.unregister_from_core()
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
(mint_id, keypairs) = idPubkeyMap.create_user_id(num_pubkeys=1)
def _run_client(self, args):
self._check_domain_id()
if self.client is None:
if args.ip4address:
addr = args.ip4address
if args.ip6address:
addr = args.ip6address
self.client = bbc_app.BBcAppClient(host=addr, port=args.coreport,
multiq=False, loglevel='all')
self.client.set_user_id(bbclib.get_new_id('.subsystem_tool',
include_timestamp=False))
self.client.set_domain_id(self.domain_id)
self.client.set_callback(bbc_app.Callback())
ret = self.client.register_to_core()
assert ret
def setup():
g.store.setup()
tmpclient = bbc_app.BBcAppClient(port=bbc_config.DEFAULT_CORE_PORT,
multiq=False,
loglevel="all")
tmpclient.domain_setup(domain_id)
tmpclient.callback.synchronize()
tmpclient.unregister_from_core()
g.idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
user_id, keypairs = g.idPubkeyMap.create_user_id(num_pubkeys=1)
g.store.write_user(User(user_id, NAME_REGISTRY, keypair=keypairs[0]))
user_id, keypairs = g.idPubkeyMap.create_user_id(num_pubkeys=1)
g.store.write_user(User(user_id, NAME_USER, keypair=keypairs[0]))
return jsonify({'domain_id': binascii.b2a_hex(domain_id).decode()})
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 create_new_domain():
domain_id = bbclib.get_new_id("certificate domain")
tmpclient = bbc_app.BBcAppClient(port=bbc_config.DEFAULT_CORE_PORT,
multiq=False,
loglevel="all")
tmpclient.domain_setup(domain_id)
tmpclient.callback.synchronize()
tmpclient.unregister_from_core()
print("domain_id:")
print(bbclib.convert_id_to_string(domain_id))
idPubkeyMap = id_lib.BBcIdPublickeyMap(domain_id)
dic = {}
id, keypairs = idPubkeyMap.create_user_id(num_pubkeys=1)
dic[KEY_REGISTRY] = User(id, keypairs[0])
id, keypairs = idPubkeyMap.create_user_id(num_pubkeys=1)
dic[KEY_USER] = User(id, keypairs[0])
write_dic(domain_id, dic)
def test_store():
(mint_id, keypairs) = idPubkeyMap.create_user_id(num_pubkeys=1)
app = bbc_app.BBcAppClient(port=DEFAULT_CORE_PORT, loglevel="all")
app.set_user_id(mint_id)
app.set_domain_id(domain_id)
app.set_callback(bbc_app.Callback())
ret = app.register_to_core()
store = token_lib.Store(domain_id, mint_id, app)
currency_spec = token_lib.CurrencySpec({
'name': "Japanese Yen",
'symbol': "JPY",
})
store.set_condition(0, keypair=keypairs[0], idPublickeyMap=idPubkeyMap)
store.set_currency_spec(currency_spec,
keypair=keypairs[0],
idPublickeyMap=idPubkeyMap)
assert store.get_condition() == 0
assert store.get_currency_spec() == currency_spec
os.makedirs(parsed_args.directory, exist_ok=True)
except:
sys.stderr.write("# Fail to mkdir for domain_keys")
sys.exit(1)
keyname = os.path.join(parsed_args.directory,
parsed_args.domain_id + ".pem")
keypair = bbclib.KeyPair()
keypair.generate()
with open(keyname, "wb") as fout:
fout.write(keypair.get_private_key_in_pem())
sys.exit(0)
if not parsed_args.notify:
sys.stderr.write("# Either -g or -n is required\n")
sys.exit(1)
if parsed_args.ip4address:
addr = parsed_args.ip4address
if parsed_args.ip6address:
addr = parsed_args.ip6address
port = parsed_args.port
bbcclient = bbc_app.BBcAppClient(host=addr,
port=port,
multiq=False,
loglevel="all")
if os.path.exists(parsed_args.node_key):
bbcclient.set_node_key(parsed_args.node_key)
bbcclient.notify_domain_key_update()
sys.exit(0)
