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_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 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, 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): 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 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