def test_adding_node_with_nodelist(self):
try:
validators = self.vnm.launch_network(5)
validator_urls = self.vnm.urls()
endpoint_client = EndpointClient(validator_urls[0])
nodes = []
for epl in endpoint_client.get_endpoint_list():
node = {}
node['Host'] = epl['Host']
node['Port'] = epl['Port']
node['Identifier'] = epl['NodeIdentifier']
node['NodeName'] = epl['Name']
nodes.append(node)
peers = [nodes[0]['NodeName'], nodes[2]['NodeName'],
'validator-x']
self.vnm.validator_config['Nodes'] = nodes
self.vnm.validator_config['Peers'] = peers
v = self.vnm.launch_node()
validator_urls.append(v.url)
self.vnm.wait_for_registration([v], validators[0])
clients = [SawtoothClient(base_url=u) for u in validator_urls]
integer_key_clients = [
IntegerKeyClient(baseurl=u,
keystring=generate_private_key())
for u in validator_urls
]
for int_key_client in integer_key_clients:
int_key_client.set(key=str(1), value=20)
self._verify_equality_of_block_lists(clients)
finally:
self.vnm.shutdown()
self.vnm.create_result_archive('TestNodeList.tar.gz')
def test_initial_connectivity_n_minus_1(self):
try:
self.vnm.validator_config['LedgerURL'] = "**none**"
validator = self.vnm.launch_node(genesis=True)
validators = [validator]
with Progress("Launching validator network") as p:
self.vnm.validator_config['LedgerURL'] = validator.url
node_identifiers = [validator.Address]
for i in range(1, 5):
self.vnm.validator_config['InitialConnectivity'] = i
v = self.vnm.launch_node(genesis=False, daemon=False)
validators.append(v)
node_identifiers.append(v.Address)
p.step()
self.vnm.wait_for_registration(validators, validator)
validator_urls = self.vnm.urls()
clients = [SawtoothClient(base_url=u) for u in validator_urls]
integer_key_clients = [
IntegerKeyClient(baseurl=u, keystring=generate_private_key())
for u in validator_urls
]
for int_key_client in integer_key_clients:
int_key_client.set(key=str(1), value=20)
self._verify_equality_of_block_lists(clients)
self._verify_orderly_transactions(clients, node_identifiers)
finally:
self.vnm.shutdown()
self.vnm.create_result_archive(
'TestOrderlyInitialConnectivity.tar.gz')
def setup(self, urls, numkeys):
self.localState = {}
self.transactions = []
self.clients = []
self.state = IntegerKeyState(urls[0])
with Progress("Creating clients") as p:
for u in urls:
key = generate_private_key()
self.clients.append(IntegerKeyClient(u, keystring=key))
p.step()
print "Checking for pre-existing state"
self.state.fetch()
keys = self.state.State.keys()
for k, v in self.state.State.iteritems():
self.localState[k] = v
with Progress("Populating initial key values") as p:
txncount = 0
starttime = time.clock()
for n in range(1, numkeys + 1):
n = str(n)
if n not in keys:
c = self._get_client()
v = random.randint(5, 1000)
self.localState[n] = v
txnid = c.set(n, v)
if txnid is None:
raise Exception("Failed to set {} to {}".format(n, v))
self.transactions.append(txnid)
txncount += 1
self.txnrate(starttime, txncount)
self._wait_for_transaction_commits()
def test_join_after_delay_start(self):
delayed_validator = None
validator_urls = []
try:
self.vnm.launch_network(5)
validator_urls = self.vnm.urls()
delayed_validator = self.vnm.launch_node(delay=True)
time.sleep(5)
command_url = delayed_validator.url + '/command'
request = urllib2.Request(
url=command_url,
headers={'Content-Type': 'application/json'})
response = urllib2.urlopen(request,
data='{"action": "start"}')
response.close()
self.assertEqual(response.code, 200,
"Successful post to delayed validator")
validator_urls.append(delayed_validator.url)
ledger_web_clients = [
LedgerWebClient(url=u) for u in validator_urls
]
with Progress("Waiting for registration of 1 validator") as p:
url = validator_urls[0]
to = TimeOut(60)
while not delayed_validator.is_registered(url):
if to():
raise ExitError(
"{} delayed validator failed to register "
"within {}S.".format(
1, to.WaitTime))
p.step()
time.sleep(1)
try:
delayed_validator.check_error()
except ValidatorManagerException as vme:
delayed_validator.dump_log()
delayed_validator.dump_stderr()
raise ExitError(str(vme))
integer_key_clients = [
IntegerKeyClient(baseurl=u,
keystring=generate_private_key())
for u in validator_urls
]
for int_key_client in integer_key_clients:
int_key_client.set(key=str(1), value=20)
self._verify_equality_of_block_lists(ledger_web_clients)
finally:
self.vnm.shutdown()
if delayed_validator is not None and \
validator_urls is not [] and \
delayed_validator.url not in validator_urls:
delayed_validator.shutdown()
self.vnm.create_result_archive("TestDelayedStart.tar.gz")
def __init__(self,
txn_validator,
config,
data_dir,
admin_node,
log_config,
static_node=False):
self._txn_validator = txn_validator
self.id = config['id']
self.name = config['NodeName']
self.config = config
self.log_config = log_config
self._admin_node = admin_node
self.static_node = static_node
self._data_dir = data_dir
# Handle validator keys
if self.static_node:
self._key = config['SigningKey']
self._address = config['Identifier']
else:
self._key = generate_private_key()
self._address = get_address_from_private_key_wif(self._key)
self.url = None
self._command = None
self._stdout_file = None
self._output = None
self._stderr_file = None
self._outerr = None
self._config_file = None
self._log_file = None
self._handle = None
def test_initial_connectivity_n_minus_1(self):
try:
self.vnm.validator_config['LedgerURL'] = "**none**"
validator = self.vnm.launch_node(genesis=True)
validators = [validator]
with Progress("Launching validator network") as p:
self.vnm.validator_config['LedgerURL'] = validator.url
node_identifiers = [validator.Address]
for i in range(1, 5):
self.vnm.validator_config['InitialConnectivity'] = i
v = self.vnm.launch_node(genesis=False, daemon=False)
validators.append(v)
node_identifiers.append(v.Address)
p.step()
self.vnm.wait_for_registration(validators, validator)
validator_urls = self.vnm.urls()
clients = [SawtoothClient(base_url=u) for u in validator_urls]
integer_key_clients = [
IntegerKeyClient(baseurl=u,
keystring=generate_private_key())
for u in validator_urls
]
for int_key_client in integer_key_clients:
int_key_client.set(key=str(1), value=20)
self._verify_equality_of_block_lists(clients)
self._verify_orderly_transactions(clients,
node_identifiers)
finally:
self.vnm.shutdown()
self.vnm.create_result_archive(
'TestOrderlyInitialConnectivity.tar.gz')
def setup(self, urls, numkeys):
self.localState = {}
self.transactions = []
self.clients = []
self.state = IntegerKeyState(urls[0])
with Progress("Creating clients") as p:
for u in urls:
key = generate_private_key()
self.clients.append(IntegerKeyClient(u, keystring=key))
p.step()
print "Checking for pre-existing state"
self.state.fetch()
keys = self.state.State.keys()
for k, v in self.state.State.iteritems():
self.localState[k] = v
with Progress("Populating initial key values") as p:
txncount = 0
starttime = time.clock()
for n in range(1, numkeys + 1):
n = str(n)
if n not in keys:
c = self._get_client()
v = random.randint(5, 1000)
self.localState[n] = v
txnid = c.set(n, v)
if txnid is None:
raise Exception("Failed to set {} to {}".format(n, v))
self.transactions.append(txnid)
txncount += 1
self.txnrate(starttime, txncount)
self._wait_for_transaction_commits()
def test_adding_node_with_nodelist(self):
try:
validators = self.vnm.launch_network(5)
validator_urls = self.vnm.urls()
endpoint_client = EndpointRegistryClient(validator_urls[0])
nodes = []
for epl in endpoint_client.get_endpoint_list():
node = {}
node['Host'] = epl['Host']
node['Port'] = epl['Port']
node['Identifier'] = epl['NodeIdentifier']
node['NodeName'] = epl['Name']
nodes.append(node)
peers = [nodes[0]['NodeName'], nodes[2]['NodeName'], 'validator-x']
self.vnm.validator_config['Nodes'] = nodes
self.vnm.validator_config['Peers'] = peers
v = self.vnm.launch_node()
validator_urls.append(v.url)
self.vnm.wait_for_registration([v], validators[0])
ledger_web_clients = [
LedgerWebClient(url=u) for u in validator_urls
]
integer_key_clients = [
IntegerKeyClient(baseurl=u, keystring=generate_private_key())
for u in validator_urls
]
for int_key_client in integer_key_clients:
int_key_client.set(key=str(1), value=20)
self._verify_equality_of_block_lists(ledger_web_clients)
finally:
self.vnm.shutdown()
self.vnm.create_result_archive('TestNodeList.tar.gz')
def __init__(self,
txn_validator,
config,
data_dir,
admin_node,
log_config,
static_node=False):
self._txn_validator = txn_validator
self.id = config['id']
self.name = config['NodeName']
self.config = config
self.log_config = log_config
self._admin_node = admin_node
self.static_node = static_node
self._data_dir = data_dir
# Handle validator keys
if self.static_node:
self._key = config['SigningKey']
self._address = config['Identifier']
else:
self._key = generate_private_key()
self._address = get_address_from_private_key_wif(self._key)
self.url = None
self._command = None
self._stdout_file = None
self._output = None
self._stderr_file = None
self._outerr = None
self._config_file = None
self._log_file = None
self._handle = None
def test_local_validation_errors(self):
client = IntegerKeyClient(self.urls[0],
keystring=generate_private_key(),
disable_client_validation=True)
with self.assertRaises(InvalidTransactionError):
client.inc("bob", 1)
def __init__(self,
cfg,
n_mag,
use_genesis=True,
base_host=None,
base_name='validator',
base_port=9000,
base_http_port=8800,
provider=None):
self.n_mag = n_mag
self.use_genesis = use_genesis
self.provider = None
if provider is not None:
self.provider = provider
# set up nodes
self.nodes = []
for idx in range(n_mag):
node_name = "{0}-{1}".format(base_name, idx)
# get base node configuration
nd = None
if self.provider is None:
nd = OrderedDict()
nd["NodeName"] = node_name
key = generate_private_key()
nd["SigningKey"] = key
nd["Identifier"] = get_address_from_private_key_wif(key)
else:
nd = self.provider.provision_validator(node_name)
# update basic configuration
nd.update(cfg)
nd["id"] = idx
# ...networking information
nd['Host'] = "localhost"
if base_host is not None:
nd['Host'] = "%s-%s" % (base_host, idx)
nd["Port"] = base_port + idx
nd["HttpPort"] = base_http_port + idx
nd['Listen'] = [
'%s:%s/UDP gossip' % (nd['Host'], nd['Port']),
'%s:%s/TCP http' % (nd['Host'], nd['HttpPort']),
]
nd["Nodes"] = []
nd["Peers"] = []
# ...role information
nd["LedgerURL"] = []
nd["GenesisLedger"] = False
if idx == 0 and use_genesis is True:
nd["GenesisLedger"] = True
# aux information
nd["Quorum"] = []
self.nodes.append(nd)
self.node_mat = None
self.peer_mat = None
self.quorum_mat = None
self.blacklist_mat = None
self.con_mat = AdjacencyMatrixAnimation(n_mag)
def test_join_after_delay_start(self):
delayed_validator = None
validator_urls = []
try:
self.vnm.launch_network(5)
validator_urls = self.vnm.urls()
delayed_validator = self.vnm.launch_node(delay=True)
time.sleep(5)
command_url = delayed_validator.url + '/command'
request = urllib2.Request(
url=command_url, headers={'Content-Type': 'application/json'})
response = urllib2.urlopen(request, data='{"action": "start"}')
response.close()
self.assertEqual(response.code, 200,
"Successful post to delayed validator")
validator_urls.append(delayed_validator.url)
ledger_web_clients = [
LedgerWebClient(url=u) for u in validator_urls
]
with Progress("Waiting for registration of 1 validator") as p:
url = validator_urls[0]
to = TimeOut(60)
while not delayed_validator.is_registered(url):
if to():
raise ExitError(
"{} delayed validator failed to register "
"within {}S.".format(1, to.WaitTime))
p.step()
time.sleep(1)
try:
delayed_validator.check_error()
except ValidatorManagerException as vme:
delayed_validator.dump_log()
delayed_validator.dump_stderr()
raise ExitError(str(vme))
integer_key_clients = [
IntegerKeyClient(baseurl=u, keystring=generate_private_key())
for u in validator_urls
]
for int_key_client in integer_key_clients:
int_key_client.set(key=str(1), value=20)
self._verify_equality_of_block_lists(ledger_web_clients)
finally:
self.vnm.shutdown()
if delayed_validator is not None and \
validator_urls is not [] and \
delayed_validator.url not in validator_urls:
delayed_validator.shutdown()
self.vnm.create_result_archive("TestDelayedStart.tar.gz")
def __init__(self, txnvalidater, config, dataDir, adminNode):
self.txnvalidater = txnvalidater
self.Id = config['id']
self.Name = config['NodeName']
self.config = config
self.AdminNode = adminNode
self.dataDir = dataDir
# Generate key for validator
self.Key = generate_private_key()
self.Address = get_address_from_private_key_wif(self.Key)
def __init__(self, txnvalidater, config, dataDir, adminNode):
self.txnvalidater = txnvalidater
self.Id = config['id']
self.Name = config['NodeName']
self.config = config
self.AdminNode = adminNode
self.dataDir = dataDir
# Generate key for validator
self.Key = generate_private_key()
self.Address = get_address_from_private_key_wif(self.Key)
def __init__(self,
n_mag,
overrides=None,
base_name='validator',
base_port=None,
base_http_port=None,
host=None,
endpoint_host=None,
provider=None):
overrides = {} if overrides is None else overrides
base_port = 9000 if base_port is None else base_port
base_http_port = 8800 if base_http_port is None else base_http_port
self.n_mag = n_mag
self.provider = None
if provider is not None:
self.provider = provider
# set up nodes
self.nodes = []
for idx in range(n_mag):
node_name = "{0}-{1}".format(base_name, idx)
# get base node configuration
nd = None
if self.provider is None:
nd = OrderedDict()
nd["NodeName"] = node_name
key = generate_private_key()
nd["SigningKey"] = key
nd["Identifier"] = get_address_from_private_key_wif(key)
else:
nd = self.provider.provision_validator(node_name)
# update basic configuration
nd.update(overrides)
nd["id"] = idx
# ...networking information
net_info = self.resolve_networking_info(host,
base_port + idx,
base_http_port + idx,
endpoint_host)
nd.update(net_info)
nd["Nodes"] = []
nd["Peers"] = []
nd["Blacklist"] = []
# initial athourity
nd["LedgerURL"] = []
# aux information
nd["Quorum"] = []
self.nodes.append(nd)
self.node_mat = None
self.peer_mat = None
self.quorum_mat = None
self.blacklist_mat = None
def __init__(self,
n_mag,
overrides=None,
base_name='validator',
base_port=None,
base_http_port=None,
host=None,
endpoint_host=None,
provider=None):
overrides = {} if overrides is None else overrides
base_port = 9000 if base_port is None else base_port
base_http_port = 8800 if base_http_port is None else base_http_port
self.n_mag = n_mag
self.provider = None
if provider is not None:
self.provider = provider
# set up nodes
self.nodes = []
for idx in range(n_mag):
node_name = "{0}-{1}".format(base_name, idx)
# get base node configuration
nd = None
if self.provider is None:
nd = OrderedDict()
nd["NodeName"] = node_name
key = generate_private_key()
nd["SigningKey"] = key
nd["Identifier"] = get_address_from_private_key_wif(key)
else:
nd = self.provider.provision_validator(node_name)
# update basic configuration
nd.update(overrides)
nd["id"] = idx
# ...networking information
net_info = self.resolve_networking_info(host,
base_port + idx,
base_http_port + idx,
endpoint_host)
nd.update(net_info)
nd["Nodes"] = []
nd["Peers"] = []
nd["Blacklist"] = []
# initial athourity
nd["LedgerURL"] = []
# aux information
self.nodes.append(nd)
self.node_mat = None
self.peer_mat = None
self.blacklist_mat = None
def setup(self, urls, numkeys):
self.localState = {}
self.transactions = []
self.last_key_txn = {}
self.clients = []
self.state = IntegerKeyState(urls[0])
with Progress("Creating clients") as p:
for u in urls:
try:
key = generate_private_key()
self.clients.append(IntegerKeyClient(u, keystring=key))
p.step()
except MessageException:
logger.warn("Unable to connect to Url: %s ", u)
if len(self.clients) == 0:
return
# add check for if a state already exists
with Progress("Checking for pre-existing state") as p:
self.state.fetch()
for k, v in self.state.State.iteritems():
self.localState[k] = v
p.step()
keys = self.state.State.keys()
with Progress("Populating initial key values") as p:
txncount = 0
starttime = time.time()
for n in range(1, numkeys + 1):
n = str(n)
if n not in keys:
c = self._get_client()
v = random.randint(5, 1000)
self.localState[n] = v
txnid = c.set(n, v)
if txnid is None:
raise Exception("Failed to set {} to {}".format(n, v))
self.transactions.append(txnid)
txncount += 1
self.last_key_txn[n] = txnid
p.step()
print
self.txnrate(starttime, txncount, "submitted")
self._wait_for_transaction_commits()
self.txnrate(starttime, txncount, "committed")
def setup(self, urls, numkeys):
self.localState = {}
self.transactions = []
self.last_key_txn = {}
self.clients = []
self.state = IntegerKeyState(urls[0])
with Progress("Creating clients") as p:
for u in urls:
try:
key = generate_private_key()
self.clients.append(IntegerKeyClient(u, keystring=key))
p.step()
except MessageException:
logger.warn("Unable to connect to Url: %s ", u)
if len(self.clients) == 0:
return
# add check for if a state already exists
with Progress("Checking for pre-existing state") as p:
self.state.fetch()
for k, v in self.state.State.iteritems():
self.localState[k] = v
p.step()
keys = self.state.State.keys()
with Progress("Populating initial key values") as p:
txncount = 0
starttime = time.time()
for n in range(1, numkeys + 1):
n = str(n)
if n not in keys:
c = self._get_client()
v = random.randint(5, 1000)
self.localState[n] = v
txnid = c.set(n, v)
if txnid is None:
raise Exception("Failed to set {} to {}".format(n, v))
self.transactions.append(txnid)
txncount += 1
self.last_key_txn[n] = txnid
p.step()
print
self.txnrate(starttime, txncount, "submitted")
self._wait_for_transaction_commits()
self.txnrate(starttime, txncount, "committed")
def setup(self, urls):
self.GlobalStore = {}
self.RunningUrlList = urls
self.GlobalKeys = []
self.transactions = []
self.lastKeyTxn = {}
self.clients = []
self.state = IntegerKeyState(urls[0])
with Progress("Creating clients") as p:
print "Creating clients"
for u in self.RunningUrlList:
try:
key = generate_private_key()
self.clients.append(IntegerKeyClient(u, keystring=key))
p.step()
except MessageException:
print "Unable to connect to Url: {}".format(u)
def setup(self, urls):
self.global_store = {}
self.running_url_list = urls
self.global_keys = []
self.transactions = []
self.lastKeyTxn = {}
self.clients = []
self.state = IntegerKeyState(urls[0])
with Progress("Creating clients") as p:
print "Creating clients"
for u in self.running_url_list:
try:
key = generate_private_key()
self.clients.append(IntegerKeyClient(u, keystring=key))
p.step()
except MessageException:
print "Unable to connect to Url: {}".format(u)
def __init__(
self,
cfg,
n_mag,
use_genesis=True,
base_host=None,
base_name='validator',
base_port=9000,
base_http_port=8800,
):
self.n_mag = n_mag
self.use_genesis = use_genesis
self.keys = [generate_private_key() for _ in range(n_mag)]
self.nodes = []
for (idx, wif) in enumerate(self.keys):
nd = OrderedDict()
nd.update(cfg)
nd["id"] = idx
nd["NodeName"] = "{0}-{1}".format(base_name, idx)
nd["Identifier"] = get_address_from_private_key_wif(wif)
nd['Host'] = "localhost"
if base_host is not None:
nd['Host'] = "%s-%s" % (base_host, idx)
nd["Port"] = base_port + idx
nd["HttpPort"] = base_http_port + idx
nd["Nodes"] = []
nd["Peers"] = []
nd["Quorum"] = []
nd['Listen'] = [
'%s:%s/UDP gossip' % (nd['Host'], nd['Port']),
'%s:%s/TCP http' % (nd['Host'], nd['HttpPort']),
]
nd["LedgerURL"] = []
nd["GenesisLedger"] = False
if idx == 0 and use_genesis is True:
nd["GenesisLedger"] = True
self.nodes.append(nd)
self.node_mat = None
self.peer_mat = None
self.quorum_mat = None
self.blacklist_mat = None
self.con_mat = AdjacencyMatrixAnimation(n_mag)
def test_basic_startup(self):
try:
self.vnm.launch_network(count=self.number_of_daemons,
others_daemon=True)
validator_urls = self.vnm.urls()
# IntegerKeyClient is only needed to send one more transaction
# so n-1=number of EndpointRegistryTransactions
integer_key_clients = [
IntegerKeyClient(baseurl=u, keystring=generate_private_key())
for u in validator_urls
]
clients = [SawtoothClient(base_url=u) for u in validator_urls]
for int_key_client in integer_key_clients:
int_key_client.set(key=str(1), value=20)
self._verify_equality_of_block_lists(clients)
finally:
self.vnm.shutdown()
self.vnm.create_result_archive('TestDaemonStartup.tar.gz')
def __init__(self, cfg, n_mag,
use_genesis=True,
base_host=None,
base_name='validator',
base_port=9000,
base_http_port=8800,
):
self.n_mag = n_mag
self.use_genesis = use_genesis
self.keys = [generate_private_key() for _ in range(n_mag)]
self.nodes = []
for (idx, wif) in enumerate(self.keys):
nd = OrderedDict()
nd.update(cfg)
nd["id"] = idx
nd["NodeName"] = "{0}-{1}".format(base_name, idx)
nd["Identifier"] = get_address_from_private_key_wif(wif)
nd['Host'] = "localhost"
if base_host is not None:
nd['Host'] = "%s-%s" % (base_host, idx)
nd["Port"] = base_port + idx
nd["HttpPort"] = base_http_port + idx
nd["Nodes"] = []
nd["Peers"] = []
nd["Quorum"] = []
nd['Listen'] = [
'%s:%s/UDP gossip' % (nd['Host'], nd['Port']),
'%s:%s/TCP http' % (nd['Host'], nd['HttpPort']),
]
nd["LedgerURL"] = []
nd["GenesisLedger"] = False
if idx == 0 and use_genesis is True:
nd["GenesisLedger"] = True
self.nodes.append(nd)
self.node_mat = None
self.peer_mat = None
self.quorum_mat = None
self.blacklist_mat = None
self.con_mat = AdjacencyMatrixAnimation(n_mag)
def test_basic_startup(self):
try:
self.vnm.launch_network(count=self.number_of_daemons,
others_daemon=True)
validator_urls = self.vnm.urls()
# IntegerKeyClient is only needed to send one more transaction
# so n-1=number of EndpointRegistryTransactions
integer_key_clients = [
IntegerKeyClient(baseurl=u,
keystring=generate_private_key())
for u in validator_urls
]
clients = [SawtoothClient(base_url=u) for u in validator_urls]
for int_key_client in integer_key_clients:
int_key_client.set(key=str(1), value=20)
self._verify_equality_of_block_lists(clients)
finally:
self.vnm.shutdown()
self.vnm.create_result_archive('TestDaemonStartup.tar.gz')
def setup(self, urls, numKeys):
self.localState = {}
self.transactions = []
self.clients = []
self.state = IntegerKeyState(urls[0])
with Progress("Creating clients") as p:
for u in urls:
key = generate_private_key()
self.clients.append(IntegerKeyClient(u, keystring=key))
p.step()
with Progress("Creating initial key values") as p:
for n in range(1, numKeys + 1):
n = str(n)
c = self._get_client()
v = random.randint(5, 1000)
self.localState[n] = v
txnid = c.set(n, v)
if txnid is None:
raise Exception("Failed to set {} to {}".format(n, v))
self.transactions.append(txnid)
self._wait_for_transaction_commits()
def setup(self, urls, numKeys):
self.localState = {}
self.transactions = []
self.clients = []
self.state = IntegerKeyState(urls[0])
with Progress("Creating clients") as p:
for u in urls:
key = generate_private_key()
self.clients.append(IntegerKeyClient(u, keystring=key))
p.step()
with Progress("Creating initial key values") as p:
for n in range(1, numKeys + 1):
n = str(n)
c = self._get_client()
v = random.randint(5, 1000)
self.localState[n] = v
txnid = c.set(n, v)
if txnid is None:
raise Exception("Failed to set {} to {}".format(n, v))
self.transactions.append(txnid)
self._wait_for_transaction_commits()
def _generate_invalid_transactions(self, url):
client = IntegerKeyClient(url,
keystring=generate_private_key(),
disable_client_validation=True)
with self.assertRaises(InvalidTransactionError):
client.inc("bob", 1)
def __init__(self, name, ledger_url, key=None, state=None):
# record of all transactions this actor has committed
self.transactions = []
self.accounts = None
self.assetType = None
self.assets = {}
self.holdings = {} # map, fully qualified names
self.holdingsByAsset = {} # map, fqn asset to fqn holding id.
self.Name = name
self.state = state
if self.state is None:
self.state = mktplace_state.MarketPlaceState(ledger_url)
# create keys
# Generate key for validator
self.Key = key
if not self.Key:
self.Key = generate_private_key()
self.creator = self.state.n2i('//{0}'.format(name))
if self.creator:
addr = get_address_from_private_key_wif(self.Key)
partxn = self.state.State[self.creator]
if addr != partxn["address"]:
raise Exception("Participant key mismatch")
self.client = mktplace_client.MarketPlaceClient(ledger_url,
creator=self.creator,
name=name,
keystring=self.Key,
state=self.state)
if not self.creator:
self.creator = self.client.register_participant(name)
self.client.CreatorID = self.creator
self.transactions.append(self.creator)
if not self.creator:
raise
self.state.CreatorID = self.creator
self._register_account()
self._register_asset_type()
# LOAD objects from state
for no in self.state.list(creator=self.creator, fields="*"):
n = no['name']
if n.startswith(self.get_qualified_name("/assets/")):
o = self.get_state_object(n)
if self.creator != o["creator"]:
raise Exception("Transaction namespace violation.")
self.assets[n] = no
elif n.startswith(self.get_qualified_name("/assets")):
o = self.get_state_object(n)
if self.creator != o["creator"]:
raise Exception("Transaction namespace violation.")
self.assetType = no
elif n.startswith(self.get_qualified_name("/account/")):
o = self.get_state_object(n)
if self.creator != o["creator"]:
raise Exception("Transaction namespace violation.")
self.holdings[n] = self.state.NameMap[n]
asset_name = self.state.i2n(o["asset"])
self.holdingsByAsset[asset_name] = no
def _generate_invalid_transactions(self, url):
client = IntegerKeyClient(url,
keystring=generate_private_key(),
disable_client_validation=True)
with self.assertRaises(InvalidTransactionError):
client.inc("bob", 1)
def __init__(self, name, ledger_url, key=None, state=None):
# record of all transactions this actor has committed
self.transactions = []
self.accounts = None
self.assetType = None
self.assets = {}
self.holdings = {} # map, fully qualified names
self.holdingsByAsset = {} # map, fqn asset to fqn holding id.
self.Name = name
self.state = state
if self.state is None:
self.state = mktplace_state.MarketPlaceState(ledger_url)
# create keys
# Generate key for validator
self.Key = key
if not self.Key:
self.Key = generate_private_key()
self.creator = self.state.n2i('//{0}'.format(name))
if self.creator:
addr = get_address_from_private_key_wif(self.Key)
partxn = self.state.State[self.creator]
if addr != partxn["address"]:
raise Exception("Participant key mismatch")
self.client = mktplace_client.MarketPlaceClient(ledger_url,
creator=self.creator,
name=name,
keystring=self.Key,
state=self.state)
if not self.creator:
self.creator = self.client.register_participant(name)
self.client.CreatorID = self.creator
self.transactions.append(self.creator)
if not self.creator:
raise
self.state.CreatorID = self.creator
self._register_account()
self._register_asset_type()
# LOAD objects from state
for no in self.state.list(creator=self.creator, fields="*"):
n = no['name']
if n.startswith(self.get_qualified_name("/assets/")):
o = self.get_state_object(n)
if self.creator != o["creator"]:
raise Exception("Transaction namespace violation.")
self.assets[n] = no
elif n.startswith(self.get_qualified_name("/assets")):
o = self.get_state_object(n)
if self.creator != o["creator"]:
raise Exception("Transaction namespace violation.")
self.assetType = no
elif n.startswith(self.get_qualified_name("/account/")):
o = self.get_state_object(n)
if self.creator != o["creator"]:
raise Exception("Transaction namespace violation.")
self.holdings[n] = self.state.NameMap[n]
asset_name = self.state.i2n(o["asset"])
self.holdingsByAsset[asset_name] = no
