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 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 __init__(self, baseurl, name='IntegerKeyClient', keystring=None, keyfile=None, state=None): super(IntegerKeyClient, self).__init__(baseurl) self.LastTransaction = None self.CurrentState = state or IntegerKeyState(self.BaseURL) self.CurrentState.fetch() # set up the signing key if keystring: logger.debug("set signing key from string\n%s", keystring) signingkey = signed_object.generate_signing_key(wifstr=keystring) elif keyfile: logger.debug("set signing key from file %s", keyfile) signingkey = signed_object.generate_signing_key( wifstr=open(keyfile, "r").read()) else: raise TypeError('expecting valid signing key, none provided') identifier = signed_object.generate_identifier(signingkey) self.LocalNode = node.Node(identifier=identifier, signingkey=signingkey, name=name)
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.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 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.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, 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()
class IntKeyLoadTest(object): def __init__(self, timeout=None): print("start inkeyloadtest") self.localState = {} self.transactions = [] self.clients = [] self.state = None self.Timeout = 240 if timeout is None else timeout self.fake_txn_id = '123456789ABCDEFGHJKLMNPQRSTUV' \ 'WXYZabcdefghijkmnopqrstuvwxyz' self.committedBlckIds = [] self.pendingTxnCount = 0 self.pendingTxns = [] def _get_client(self): return self.clients[random.randint(0, len(self.clients) - 1)] def _update_uncommitted_transactions(self): remaining = [] # For each client, we want to verify that its corresponding validator # has the transaction. For a transaction to be considered committed, # all validators must have it in its blockchain as a committed # transaction. for c in self.clients: for t in self.transactions: status = c.get_transaction_status(t) # If the transaction has not been committed and we don't # already have it in our list of uncommitted transactions # then add it. if (status != http.OK) and (t not in remaining): remaining.append(t) self.transactions = remaining return len(self.transactions) def _wait_for_transaction_commits(self): to = TimeOut(self.Timeout) txnCnt = len(self.transactions) with Progress("Waiting for %s transactions to commit" % (txnCnt)) \ as p: while not to() and txnCnt > 0: p.step() time.sleep(1) txnCnt = self._update_uncommitted_transactions() if txnCnt != 0: if len(self.transactions) != 0: print("Uncommitted transactions: ", self.transactions) raise Exception("{} transactions failed to commit in {}s".format( txnCnt, to.WaitTime)) def _wait_for_no_transaction_commits(self): # for the case where no transactions are expected to commit to = TimeOut(240) starting_txn_count = len(self.transactions) remaining_txn_cnt = len(self.transactions) with Progress("Waiting for transactions to NOT commit") as p: while not to() and remaining_txn_cnt > 0: p.step() time.sleep(1) remaining_txn_cnt = self._update_uncommitted_transactions() if remaining_txn_cnt != starting_txn_count: committedtxncount = starting_txn_count - remaining_txn_cnt raise Exception("{} transactions with missing dependencies " "were committed in {}s" .format(committedtxncount, to.WaitTime)) else: print("No transactions with missing dependencies " "were committed in {0}s".format(to.WaitTime)) def _wait_for_limit_pending_transactions(self): result = self.is_registered('http://localhost:8800/statistics/journal') json_data = json.loads(result) self.committedBlckCount = json_data['journal']['CommittedBlockCount'] print(("committedBlckCount: ", self.committedBlckCount)) self.pendingTxnCount = json_data['journal']['PendingTxnCount'] print(("PendingTxnCount: ", self.pendingTxnCount)) if (self.committedBlckCount > 3 & self.pendingTxnCount != 0): raise Exception("{} blocks were committed " "with {} invalid transactions." .format(self.committedBlckCount, self.pendingTxnCount)) else: print("All pending transactions after " "3 blocks have been dropped") 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 run(self, numkeys, rounds=1, txintv=0): if len(self.clients) == 0: return self.state.fetch() keys = self.state.State.keys() print("Running {0} rounds for {1} keys " "with {2} second inter-transaction time" .format(rounds, numkeys, txintv)) for r in range(0, rounds): cnt = 0 starttime = time.time() with Progress("Round {}".format(r)) as p: for k in keys: k = str(k) c = self._get_client() self.localState[k] += 2 txn_dep = self.last_key_txn.get(k, None) txn_id = c.inc(k, 2, txn_dep) if txn_id is None: raise Exception( "Failed to inc key:{} value:{} by 2".format( k, self.localState[k])) self.transactions.append(txn_id) self.last_key_txn[k] = txn_id cnt += 1 if cnt % 10 == 0: p.step() time.sleep(txintv) for k in keys: k = str(k) c = self._get_client() self.localState[k] -= 1 txn_dep = self.last_key_txn[k] txn_id = c.dec(k, 1, txn_dep) if txn_id is None: raise Exception( "failed to dec key:{} value:{} by 1".format( k, self.localState[k])) self.transactions.append(txn_id) self.last_key_txn[k] = txn_id cnt += 1 if cnt % 10 == 0: p.step() time.sleep(txintv) txn_count = len(self.transactions) self.txnrate(starttime, txn_count, "submitted") self._wait_for_transaction_commits() self.txnrate(starttime, txn_count, "committed") def validate(self): if len(self.clients) == 0: logger.warn("Unable to connect to Validators, No Clients created") return self.state.fetch() print("Validating IntegerKey State") for k, v in self.state.State.iteritems(): if self.localState[k] != v: print("key {} is {} expected to be {}".format( k, v, self.localState[k])) assert self.localState[k] == v def journalstate(self): self.state.fetch() print("state: ") for k, v in self.state.State.iteritems(): print(k, v) print() def txnrate(self, starttime, numtxns, purpose): if numtxns > 0: endtime = time.time() totaltime = endtime - starttime avgrate = (numtxns / totaltime) print("{0} transaction in {1} seconds averaging {2} t/s " "{3}" .format(numtxns, totaltime, avgrate, purpose)) def generate_txn_id(self): string_id = '' for i in range(0, 16): string_id = string_id + random.choice(self.fake_txn_id) return string_id def is_registered(self, url=None): response = urllib2.urlopen(url).read() return response def run_with_limit_txn_dependencies(self, numkeys, rounds=1, txintv=0): if len(self.clients) == 0: return self.state.fetch() keys = self.state.State.keys() print("Running {0} rounds for {1} keys " "with {2} second inter-transaction time" "with limit on missing dep transactions" .format(rounds, numkeys, txintv)) for r in range(1, rounds + 1): with Progress("Updating clients state") as p: print("Round {}".format(r)) for k in range(1, numkeys + 1): k = str(k) c = self._get_client() print ("Sending invalid txnx: ") cnt = 0 starttime = time.time() for inf in range(0, 3): missingid = self.generate_txn_id() dependingtid = c.inc(k, 1, txndep=missingid) self.pendingTxns.append(dependingtid) cnt += 1 print(("pendingTxns: ", self.pendingTxns)) self.txnrate(starttime, cnt, " invalid transactions NOT submitted") result = self.is_registered( 'http://localhost:8800/statistics/journal') json_data = json.loads(result) self.pendingTxnCount = \ json_data['journal']['PendingTxnCount'] print(("PendingTxnCount: ", self.pendingTxnCount)) for loop_ind in range(0, 4): print ("Sending valid txn:") cnt = 0 starttime = time.time() for ind in range(0, 5): self.localState[k] += 2 txn_dep = self.last_key_txn.get(k, None) txn_id = c.inc(k, 2, txn_dep) if txn_id is None: raise Exception( "Failed to inc key:{} value:{}" " by 2".format( k, self.localState[k])) self.transactions.append(txn_id) self.last_key_txn[k] = txn_id cnt += 1 if cnt % 10 == 0: p.step() time.sleep(txintv) txn_count = len(self.transactions) self.txnrate(starttime, txn_count, " valid transactions submitted") self._wait_for_transaction_commits() self._wait_for_limit_pending_transactions() print("checking pending txn limit") self._wait_for_limit_pending_transactions() def run_with_missing_dep(self, numkeys, rounds=1): self.state.fetch() print("Running {0} rounds for {1} keys " "with missing transactions" .format(rounds, numkeys)) starttime = time.time() for r in range(1, rounds + 1): print("Round {}".format(r)) for k in range(1, numkeys + 1): k = str(k) c = c = self._get_client() for ind in range(0, 5): missingid = self.generate_txn_id() dependingtid = c.inc(k, 1, txndep=missingid) self.transactions.append(dependingtid) txn_count = len(self.transactions) self.txnrate(starttime, txn_count, " dep txn submitted") self._wait_for_no_transaction_commits()
class IntKeyLoadTest(object): def __init__(self): pass def _get_client(self): return self.clients[random.randint(0, len(self.clients) - 1)] def _has_uncommitted_transactions(self): remaining = [] for t in self.transactions: status = self.clients[0].get_transaction_status(t) if status != http.OK: remaining.append(t) self.transactions = remaining return len(self.transactions) def _wait_for_transaction_commits(self): to = TimeOut(900) txn_cnt = len(self.transactions) with Progress("Waiting for %s transactions to commit" % (txn_cnt)) \ as p: while not to() and txn_cnt > 0: p.step() time.sleep(1) self._has_uncommitted_transactions() txn_cnt = len(self.transactions) if txn_cnt != 0: if len(self.transactions) != 0: print "Uncommitted transactions: ", self.transactions raise Exception("{} transactions failed to commit in {}s".format( txn_cnt, to.WaitTime)) 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 run(self, count=1, interval=0.0): if self.clients == []: return prev = "" self.state.fetch() self.global_keys = self.state.State.keys() for k, v in self.state.State.iteritems(): self.global_store[k] = v while count > 0: count -= 1 c = self._get_client() c.fetch_state() k = str(random.randint(0, len(self.global_keys) + 1)) # Stops the inc of a key that was just set while k == prev: k = str(random.randint(0, len(self.global_keys) + 1)) if k in self.global_keys: self.global_store[k] += 1 if k in self.lastKeyTxn: txn_dep = self.lastKeyTxn[k] else: txn_dep = None txnid = c.inc(k, 1, txn_dep) if txnid is None: raise Exception( "Failed to inc key:{} value:{} by 1".format( k, self.global_store[k])) self.transactions.append(txnid) self.lastKeyTxn[k] = txnid time.sleep(interval) else: self.global_keys += [k] v = random.randint(5, 1000) self.global_store[k] = v txnid = c.set(k, v, txndep=None) prev = k if txnid is None: raise Exception("Failed to set {} to {}".format(k, v)) self.transactions.append(txnid) self.lastKeyTxn[k] = txnid time.sleep(interval) self._wait_for_transaction_commits() self._wait_for_transaction_commits() def validate(self): if self.clients == []: print "Unable to connect to Validators, No Clients created" return self.state.fetch() print "Validating IntegerKey State" for k, v in self.state.State.iteritems(): if self.global_store[k] != v: print "key {} is {} expected to be {}".format( k, v, self.localState[k]) assert self.global_store[k] == v
class IntKeyLoadTest(object): def __init__(self, timeout=None): print "start inkeyloadtest" self.localState = {} self.transactions = [] self.clients = [] self.state = None self.Timeout = 240 if timeout is None else timeout def _get_client(self): return self.clients[random.randint(0, len(self.clients) - 1)] def _update_uncommitted_transactions(self): remaining = [] # For each client, we want to verify that its corresponding validator # has the transaction. For a transaction to be considered committed, # all validators must have it in its blockchain as a committed # transaction. for c in self.clients: for t in self.transactions: status = c.get_transaction_status(t) # If the transaction has not been committed and we don't # already have it in our list of uncommitted transactions # then add it. if (status != http.OK) and (t not in remaining): remaining.append(t) self.transactions = remaining return len(self.transactions) def _wait_for_transaction_commits(self): to = TimeOut(self.Timeout) txnCnt = len(self.transactions) with Progress("Waiting for %s transactions to commit" % (txnCnt)) \ as p: while not to() and txnCnt > 0: p.step() time.sleep(1) txnCnt = self._update_uncommitted_transactions() if txnCnt != 0: if len(self.transactions) != 0: print "Uncommitted transactions: ", self.transactions raise Exception("{} transactions failed to commit in {}s".format( txnCnt, to.WaitTime)) def _wait_for_no_transaction_commits(self): # for the case where no transactions are expected to commit to = TimeOut(120) starting_txn_count = len(self.transactions) remaining_txn_cnt = len(self.transactions) with Progress("Waiting for transactions to NOT commit") as p: while not to() and remaining_txn_cnt > 0: p.step() time.sleep(1) remaining_txn_cnt = self._update_uncommitted_transactions() if remaining_txn_cnt != starting_txn_count: committedtxncount = starting_txn_count - remaining_txn_cnt raise Exception("{} transactions with missing dependencies " "were committed in {}s" .format(committedtxncount, to.WaitTime)) else: print "No transactions with missing dependencies " \ "were committed in {0}s".format(to.WaitTime) 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 run(self, numkeys, rounds=1, txintv=0): if len(self.clients) == 0: return self.state.fetch() keys = self.state.State.keys() print "Running {0} rounds for {1} keys " \ "with {2} second inter-transaction time" \ .format(rounds, numkeys, txintv) for r in range(0, rounds): with Progress("Updating clients state") as p: for c in self.clients: c.fetch_state() p.step() cnt = 0 starttime = time.time() with Progress("Round {}".format(r)) as p: for k in keys: k = str(k) c = self._get_client() self.localState[k] += 2 txn_dep = self.last_key_txn.get(k, None) txn_id = c.inc(k, 2, txn_dep) if txn_id is None: raise Exception( "Failed to inc key:{} value:{} by 2".format( k, self.localState[k])) self.transactions.append(txn_id) self.last_key_txn[k] = txn_id cnt += 1 if cnt % 10 == 0: p.step() time.sleep(txintv) for k in keys: k = str(k) c = self._get_client() self.localState[k] -= 1 txn_dep = self.last_key_txn[k] txn_id = c.dec(k, 1, txn_dep) if txn_id is None: raise Exception( "failed to dec key:{} value:{} by 1".format( k, self.localState[k])) self.transactions.append(txn_id) self.last_key_txn[k] = txn_id cnt += 1 if cnt % 10 == 0: p.step() time.sleep(txintv) txn_count = len(self.transactions) self.txnrate(starttime, txn_count, "submitted") self._wait_for_transaction_commits() self.txnrate(starttime, txn_count, "committed") def validate(self): if len(self.clients) == 0: logger.warn("Unable to connect to Validators, No Clients created") return self.state.fetch() print "Validating IntegerKey State" for k, v in self.state.State.iteritems(): if self.localState[k] != v: print "key {} is {} expected to be {}".format( k, v, self.localState[k]) assert self.localState[k] == v def ledgerstate(self): self.state.fetch() print "state: " for k, v in self.state.State.iteritems(): print k, v print def txnrate(self, starttime, numtxns, purpose): if numtxns > 0: endtime = time.time() totaltime = endtime - starttime avgrate = (numtxns / totaltime) print "{0} transaction in {1} seconds averaging {2} t/s " \ "{3}" .format(numtxns, totaltime, avgrate, purpose) def run_with_missing_dep(self, numkeys, rounds=1): self.state.fetch() print "Running {0} rounds for {1} keys " \ "with missing transactions" \ .format(rounds, numkeys) for r in range(1, rounds + 1): for c in self.clients: c.CurrentState.fetch() print "Round {}".format(r) for k in range(1, numkeys + 1): k = str(k) c = c = self._get_client() missingid = c.inc(k, 1, txndep=None, postmsg=False) dependingtid = c.inc(k, 1, txndep=missingid) self.transactions.append(dependingtid) self._wait_for_no_transaction_commits()
class IntKeyLoadTest(object): def __init__(self): pass def _get_client(self): return self.clients[random.randint(0, len(self.clients) - 1)] def _has_uncommitted_transactions(self): remaining = [] for t in self.transactions: status = self.clients[0].headrequest('/transaction/{0}'.format(t)) if status != http.OK: remaining.append(t) self.transactions = remaining return len(self.transactions) def _wait_for_transaction_commits(self): to = TimeOut(120) txnCnt = len(self.transactions) with Progress("Waiting for transactions to commit") as p: while not to() and txnCnt > 0: p.step() time.sleep(1) self._has_uncommitted_transactions() txnCnt = len(self.transactions) if txnCnt != 0: if len(self.transactions) != 0: print "Uncommitted transactions: ", self.transactions raise Exception("{} transactions failed to commit in {}s".format( txnCnt, to.WaitTime)) 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 run(self, rounds=1): self.state.fetch() keys = self.state.State.keys() for r in range(0, rounds): for c in self.clients: c.CurrentState.fetch() print "Round {}".format(r) for k in keys: c = self._get_client() self.localState[k] += 2 txnid = c.inc(k, 2) if txnid is None: raise Exception( "Failed to inc key:{} value:{} by 2".format( k, self.localState[k])) self.transactions.append(txnid) for k in keys: c = self._get_client() self.localState[k] -= 1 txnid = c.dec(k, 1) if txnid is None: raise Exception( "Failed to dec key:{} value:{} by 1".format( k, self.localState[k])) self.transactions.append(txnid) self._wait_for_transaction_commits() def validate(self): self.state.fetch() print "Validating IntegerKey State" for k, v in self.state.State.iteritems(): if self.localState[k] != v: print "key {} is {} expected to be {}".format( k, v, self.localState[k]) assert self.localState[k] == v
class IntKeyLoadTest(object): def __init__(self, timeout=None): print "start inkeyloadtest" self.localState = {} self.transactions = [] self.clients = [] self.state = None self.Timeout = 240 if timeout is None else timeout self.fake_txn_id = '123456789ABCDEFGHJKLMNPQRSTUV' \ 'WXYZabcdefghijkmnopqrstuvwxyz' self.committedBlckIds = [] self.pendingTxnCount = 0 self.pendingTxns = [] def _get_client(self): return self.clients[random.randint(0, len(self.clients) - 1)] def _update_uncommitted_transactions(self): remaining = [] # For each client, we want to verify that its corresponding validator # has the transaction. For a transaction to be considered committed, # all validators must have it in its blockchain as a committed # transaction. for c in self.clients: for t in self.transactions: status = c.get_transaction_status(t) # If the transaction has not been committed and we don't # already have it in our list of uncommitted transactions # then add it. if (status != http.OK) and (t not in remaining): remaining.append(t) self.transactions = remaining return len(self.transactions) def _wait_for_transaction_commits(self): to = TimeOut(self.Timeout) txnCnt = len(self.transactions) with Progress("Waiting for %s transactions to commit" % (txnCnt)) \ as p: while not to() and txnCnt > 0: p.step() time.sleep(1) txnCnt = self._update_uncommitted_transactions() if txnCnt != 0: if len(self.transactions) != 0: print "Uncommitted transactions: ", self.transactions raise Exception("{} transactions failed to commit in {}s".format( txnCnt, to.WaitTime)) def _wait_for_no_transaction_commits(self): # for the case where no transactions are expected to commit to = TimeOut(120) starting_txn_count = len(self.transactions) remaining_txn_cnt = len(self.transactions) with Progress("Waiting for transactions to NOT commit") as p: while not to() and remaining_txn_cnt > 0: p.step() time.sleep(1) remaining_txn_cnt = self._update_uncommitted_transactions() if remaining_txn_cnt != starting_txn_count: committedtxncount = starting_txn_count - remaining_txn_cnt raise Exception("{} transactions with missing dependencies " "were committed in {}s".format( committedtxncount, to.WaitTime)) else: print "No transactions with missing dependencies " \ "were committed in {0}s".format(to.WaitTime) def _wait_for_limit_pending_transactions(self): result = self.is_registered('http://localhost:9000/statistics/ledger') json_data = json.loads(result) self.committedBlckCount = json_data['ledger']['CommittedBlockCount'] print("committedBlckCount: ", self.committedBlckCount) self.pendingTxnCount = json_data['ledger']['PendingTxnCount'] print("PendingTxnCount: ", self.pendingTxnCount) if (self.committedBlckCount > 3 & self.pendingTxnCount != 0): raise Exception("{} blocks were committed " "with {} invalid transactions.".format( self.committedBlckCount, self.pendingTxnCount)) else: print "All pending transactions after " \ "3 blocks have been dropped" 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 run(self, numkeys, rounds=1, txintv=0): if len(self.clients) == 0: return self.state.fetch() keys = self.state.State.keys() print "Running {0} rounds for {1} keys " \ "with {2} second inter-transaction time" \ .format(rounds, numkeys, txintv) for r in range(0, rounds): with Progress("Updating clients state") as p: for c in self.clients: c.fetch_state() p.step() cnt = 0 starttime = time.time() with Progress("Round {}".format(r)) as p: for k in keys: k = str(k) c = self._get_client() self.localState[k] += 2 txn_dep = self.last_key_txn.get(k, None) txn_id = c.inc(k, 2, txn_dep) if txn_id is None: raise Exception( "Failed to inc key:{} value:{} by 2".format( k, self.localState[k])) self.transactions.append(txn_id) self.last_key_txn[k] = txn_id cnt += 1 if cnt % 10 == 0: p.step() time.sleep(txintv) for k in keys: k = str(k) c = self._get_client() self.localState[k] -= 1 txn_dep = self.last_key_txn[k] txn_id = c.dec(k, 1, txn_dep) if txn_id is None: raise Exception( "failed to dec key:{} value:{} by 1".format( k, self.localState[k])) self.transactions.append(txn_id) self.last_key_txn[k] = txn_id cnt += 1 if cnt % 10 == 0: p.step() time.sleep(txintv) txn_count = len(self.transactions) self.txnrate(starttime, txn_count, "submitted") self._wait_for_transaction_commits() self.txnrate(starttime, txn_count, "committed") def validate(self): if len(self.clients) == 0: logger.warn("Unable to connect to Validators, No Clients created") return self.state.fetch() print "Validating IntegerKey State" for k, v in self.state.State.iteritems(): if self.localState[k] != v: print "key {} is {} expected to be {}".format( k, v, self.localState[k]) assert self.localState[k] == v def ledgerstate(self): self.state.fetch() print "state: " for k, v in self.state.State.iteritems(): print k, v print def txnrate(self, starttime, numtxns, purpose): if numtxns > 0: endtime = time.time() totaltime = endtime - starttime avgrate = (numtxns / totaltime) print "{0} transaction in {1} seconds averaging {2} t/s " \ "{3}" .format(numtxns, totaltime, avgrate, purpose) def generate_txn_id(self): string_id = '' for i in range(0, 16): string_id = string_id + random.choice(self.fake_txn_id) return string_id def is_registered(self, url=None): response = urllib2.urlopen(url).read() return response def run_with_limit_txn_dependencies(self, numkeys, rounds=1, txintv=0): if len(self.clients) == 0: return self.state.fetch() keys = self.state.State.keys() print "Running {0} rounds for {1} keys " \ "with {2} second inter-transaction time" \ "with limit on missing dep transactions" \ .format(rounds, numkeys, txintv) for r in range(1, rounds + 1): with Progress("Updating clients state") as p: for c in self.clients: c.fetch_state() p.step() print "Round {}".format(r) for k in range(1, numkeys + 1): k = str(k) c = self._get_client() print("Sending invalid txnx: ") cnt = 0 starttime = time.time() for inf in range(0, 3): missingid = self.generate_txn_id() dependingtid = c.inc(k, 1, txndep=missingid) self.pendingTxns.append(dependingtid) cnt += 1 print("pendingTxns: ", self.pendingTxns) self.txnrate(starttime, cnt, " invalid transactions NOT submitted") result = self.is_registered( 'http://localhost:9000/statistics/ledger') json_data = json.loads(result) self.pendingTxnCount = \ json_data['ledger']['PendingTxnCount'] print("PendingTxnCount: ", self.pendingTxnCount) for loop_ind in range(0, 4): print("Sending valid txn:") cnt = 0 starttime = time.time() for ind in range(0, 5): self.localState[k] += 2 txn_dep = self.last_key_txn.get(k, None) txn_id = c.inc(k, 2, txn_dep) if txn_id is None: raise Exception("Failed to inc key:{} value:{}" " by 2".format( k, self.localState[k])) self.transactions.append(txn_id) self.last_key_txn[k] = txn_id cnt += 1 if cnt % 10 == 0: p.step() time.sleep(txintv) txn_count = len(self.transactions) self.txnrate(starttime, txn_count, " valid transactions submitted") self._wait_for_transaction_commits() self._wait_for_limit_pending_transactions() print "checking pending txn limit" self._wait_for_limit_pending_transactions() def run_with_missing_dep(self, numkeys, rounds=1): self.state.fetch() print "Running {0} rounds for {1} keys " \ "with missing transactions" \ .format(rounds, numkeys) starttime = time.time() for r in range(1, rounds + 1): for c in self.clients: c.fetch_state() print "Round {}".format(r) for k in range(1, numkeys + 1): k = str(k) c = c = self._get_client() for ind in range(0, 5): missingid = self.generate_txn_id() dependingtid = c.inc(k, 1, txndep=missingid) self.transactions.append(dependingtid) txn_count = len(self.transactions) self.txnrate(starttime, txn_count, " dep txn submitted") self._wait_for_no_transaction_commits()
class IntKeyLoadTest: def __init__(self): pass def _get_client(self): return self.clients[random.randint(0, len(self.clients) - 1)] def _has_uncommitted_transactions(self): remaining = [] for t in self.transactions: status = self.clients[0].headrequest('/transaction/{0}'.format(t)) if status != http.OK: remaining.append(t) self.transactions = remaining return len(self.transactions) def _wait_for_transaction_commits(self): to = TimeOut(120) txnCnt = len(self.transactions) with Progress("Waiting for transactions to commit") as p: while not to() and txnCnt > 0: p.step() time.sleep(1) self._has_uncommitted_transactions() txnCnt = len(self.transactions) if txnCnt != 0: if len(self.transactions) != 0: print "Uncommitted transactions: ", self.transactions raise Exception("{} transactions failed to commit in {}s".format( txnCnt, to.WaitTime)) 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 run(self, rounds=1): self.state.fetch() inc = True keys = self.state.State.keys() for r in range(0, rounds): for c in self.clients: c.CurrentState.fetch() print "Round {}".format(r) for k in keys: c = self._get_client() self.localState[k] += 2 txnid = c.inc(k, 2) if txnid is None: raise Exception( "Failed to inc key:{} value:{} by 2".format( k, self.localState[k])) self.transactions.append(txnid) for k in keys: c = self._get_client() self.localState[k] -= 1 txnid = c.dec(k, 1) if txnid is None: raise Exception( "Failed to dec key:{} value:{} by 1".format( k, self.localState[k])) self.transactions.append(txnid) self._wait_for_transaction_commits() def validate(self): self.state.fetch() print "Validating IntegerKey State" for k, v in self.state.State.iteritems(): if self.localState[k] != v: print "key {} is {} expected to be {}".format( k, v, self.localState[k]) assert self.localState[k] == v
class IntKeyLoadTest(object): def __init__(self, timeout=None): self.Timeout = 240 if timeout is None else timeout def _get_client(self): return self.clients[random.randint(0, len(self.clients) - 1)] def _update_uncommitted_transactions(self): remaining = [] # For each client, we want to verify that its corresponding validator # has the transaction. For a transaction to be considered committed, # all validators must have it in its blockchain as a committed # transaction. for c in self.clients: for t in self.transactions: status = c.headrequest('/transaction/{0}'.format(t)) # If the transaction has not been committed and we don't # already have it in our list of uncommitted transactions # then add it. if (status != http.OK) and (t not in remaining): remaining.append(t) self.transactions = remaining return len(self.transactions) def _wait_for_transaction_commits(self): to = TimeOut(self.Timeout) txn_cnt = len(self.transactions) with Progress("Waiting for %s transactions to commit" % (txn_cnt)) \ as p: while not to() and txn_cnt > 0: p.step() time.sleep(1) txn_cnt = self._update_uncommitted_transactions() if txn_cnt != 0: if len(self.transactions) != 0: print "Uncommitted transactions: ", self.transactions raise Exception("{} transactions failed to commit in {}s".format( txn_cnt, to.WaitTime)) def setup(self, urls, num_keys): 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() keys = self.state.State.keys() for k, v in self.state.State.iteritems(): self.localState[k] = v with Progress("Creating initial key values") as p: for n in range(1, num_keys + 1): n = str(n) if n not in keys: c = self._get_client() v = random.randint(5, 1000) self.localState[n] = v txn_id = c.set(n, v, txndep=None) if txn_id is None: raise Exception("Failed to set {} to {}".format(n, v)) self.transactions.append(txn_id) self.last_key_txn[n] = txn_id self._wait_for_transaction_commits() def run(self, rounds=1): if len(self.clients) == 0: return self.state.fetch() keys = self.state.State.keys() for r in range(1, rounds + 1): with Progress("Updating clients state") as p: for c in self.clients: c.CurrentState.fetch() p.step() cnt = 0 with Progress("Round {}".format(r)) as p: for k in keys: c = self._get_client() self.localState[k] += 2 if k in self.last_key_txn: txn_dep = self.last_key_txn[k] else: txn_dep = None txn_id = c.inc(k, 2, txn_dep) if txn_id is None: raise Exception( "Failed to inc key:{} value:{} by 2".format( k, self.localState[k])) self.transactions.append(txn_id) self.last_key_txn[k] = txn_id cnt += 1 if cnt % 10 == 0: p.step() for k in keys: c = self._get_client() self.localState[k] -= 1 txn_dep = self.last_key_txn[k] txn_id = c.dec(k, 1, txn_dep) if txn_id is None: raise Exception( "Failed to dec key:{} value:{} by 1".format( k, self.localState[k])) self.transactions.append(txn_id) self.last_key_txn[k] = txn_id cnt += 1 if cnt % 10 == 0: p.step() self._wait_for_transaction_commits() def validate(self): if len(self.clients) == 0: logger.warn("Unable to connect to Validators, No Clients created") return self.state.fetch() print "Validating IntegerKey State" for k, v in self.state.State.iteritems(): if self.localState[k] != v: print "key {} is {} expected to be {}".format( k, v, self.localState[k]) assert self.localState[k] == v
class IntKeyLoadTest(object): def __init__(self): pass def _get_client(self): return self.clients[random.randint(0, len(self.clients) - 1)] def _has_uncommitted_transactions(self): remaining = [] for t in self.transactions: status = self.clients[0].headrequest('/transaction/{0}'.format(t)) if status != http.OK: remaining.append(t) self.transactions = remaining return len(self.transactions) def _wait_for_transaction_commits(self): to = TimeOut(240) txnCnt = len(self.transactions) with Progress("Waiting for %s transactions to commit" % (txnCnt)) as p: while not to() and txnCnt > 0: p.step() time.sleep(1) self._has_uncommitted_transactions() txnCnt = len(self.transactions) if txnCnt != 0: if len(self.transactions) != 0: print "Uncommitted transactions: ", self.transactions raise Exception("{} transactions failed to commit in {}s".format( txnCnt, to.WaitTime)) def _wait_for_no_transaction_commits(self): # for the case where no transactions are expected to commit to = TimeOut(120) startingTxnCnt = len(self.transactions) remainingTxnCnt = len(self.transactions) with Progress("Waiting for no transactions to commit") as p: while not to() and remainingTxnCnt > 0: p.step() time.sleep(1) self._has_uncommitted_transactions() remainingTxnCnt = len(self.transactions) if startingTxnCnt != remainingTxnCnt: raise Exception("{} unexpected transaction commits after {}s" .format(startingTxnCnt - remainingTxnCnt, to.WaitTime)) # def _wait_for_no_transaction_commits(self): # to = TimeOut(120) # txnCnt = len(self.transactions) # with Progress("Waiting for transactions to commit") as p: # while not to() and txnCnt > 0: # p.step() # time.sleep(1) # self._has_uncommitted_transactions() # txnCnt = len(self.transactions) # # if txnCnt != 0: # if len(self.transactions) != 0: # print "Uncommitted transactions: ", self.transactions # "{} transactions with unmet dependencies did not " \ # "to commit in {}s".format( # txnCnt, to.WaitTime) # else: # raise Exception("{} transactions with unmet dependencies " # "committed in {}s".format( # txnCnt, to.WaitTime)) 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 run(self, rounds=1): self.state.fetch() keys = self.state.State.keys() for r in range(0, rounds): for c in self.clients: c.CurrentState.fetch() print "Round {}".format(r) for k in keys: c = self._get_client() self.localState[k] += 2 txnid = c.inc(k, 2) if txnid is None: raise Exception( "Failed to inc key:{} value:{} by 2".format( k, self.localState[k])) self.transactions.append(txnid) # for k in keys: # c = self._get_client() # self.localState[k] -= 1 # txnid = c.dec(k, 1) # if txnid is None: # raise Exception( # "Failed to dec key:{} value:{} by 1".format( # k, self.localState[k])) # self.transactions.append(txnid) self._wait_for_transaction_commits() def run_missing_dep_test(self, rounds=0): self.state.fetch() keys = self.state.State.keys() for r in range(0, rounds): for c in self.clients: c.CurrentState.fetch() print "Round {}".format(r) for k in keys: c = self._get_client() missingid = c.inc(k, 1, txndep=None, postmsg=False) dependingtid = c.inc(k, 1, txndep=missingid) self.transactions.append(dependingtid) self._wait_for_no_transaction_commits() def validate(self): self.state.fetch() print "Validating IntegerKey State" for k, v in self.state.State.iteritems(): if self.localState[k] != v: print "key {} is {} expected to be {}".format( k, v, self.localState[k]) assert self.localState[k] == v
class IntKeyLoadTest(object): def __init__(self): pass def _get_client(self): return self.clients[random.randint(0, len(self.clients) - 1)] def _has_uncommitted_transactions(self): remaining = [] for t in self.transactions: status = self.clients[0].headrequest('/transaction/{0}'.format(t)) if status != http.OK: remaining.append(t) self.transactions = remaining return len(self.transactions) def _wait_for_transaction_commits(self): to = TimeOut(900) txnCnt = len(self.transactions) with Progress("Waiting for %s transactions to commit" % (txnCnt)) as p: while not to() and txnCnt > 0: p.step() time.sleep(1) self._has_uncommitted_transactions() txnCnt = len(self.transactions) if txnCnt != 0: if len(self.transactions) != 0: print "Uncommitted transactions: ", self.transactions raise Exception("{} transactions failed to commit in {}s".format( txnCnt, to.WaitTime)) 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 run(self, count=1, interval=0.0): if self.clients == []: return prev = "" self.state.fetch() self.GlobalKeys = self.state.State.keys() for k, v in self.state.State.iteritems(): self.GlobalStore[k] = v while count > 0: count -= 1 c = self._get_client() c.CurrentState.fetch() k = str(random.randint(0, len(self.GlobalKeys) + 1)) # Stops the inc of a key that was just set while k == prev: k = str(random.randint(0, len(self.GlobalKeys) + 1)) if k in self.GlobalKeys: self.GlobalStore[k] += 1 if k in self.lastKeyTxn: txndep = self.lastKeyTxn[k] else: txndep = None txnid = c.inc(k, 1, txndep) if txnid is None: raise Exception( "Failed to inc key:{} value:{} by 1".format( k, self.GlobalStore[k])) self.transactions.append(txnid) self.lastKeyTxn[k] = txnid time.sleep(interval) else: self.GlobalKeys += [k] v = random.randint(5, 1000) self.GlobalStore[k] = v txnid = c.set(k, v, txndep=None) prev = k if txnid is None: raise Exception("Failed to set {} to {}".format(k, v)) self.transactions.append(txnid) self.lastKeyTxn[k] = txnid time.sleep(interval) self._wait_for_transaction_commits() self._wait_for_transaction_commits() def validate(self): if self.clients == []: print "Unable to connect to Validators, No Clients created" return self.state.fetch() print "Validating IntegerKey State" for k, v in self.state.State.iteritems(): if self.GlobalStore[k] != v: print "key {} is {} expected to be {}".format( k, v, self.localState[k]) assert self.GlobalStore[k] == v
class IntKeyLoadTest(object): def __init__(self, timeout=None): self.Timeout = 240 if timeout is None else timeout def _get_client(self): return self.clients[random.randint(0, len(self.clients) - 1)] def _update_uncommitted_transactions(self): remaining = [] # For each client, we want to verify that its corresponding validator # has the transaction. For a transaction to be considered committed, # all validators must have it in its blockchain as a committed # transaction. for c in self.clients: for t in self.transactions: status = c.get_transaction_status(t) # If the transaction has not been committed and we don't # already have it in our list of uncommitted transactions # then add it. if (status != http.OK) and (t not in remaining): remaining.append(t) self.transactions = remaining return len(self.transactions) def _wait_for_transaction_commits(self): to = TimeOut(self.Timeout) txn_cnt = len(self.transactions) with Progress("Waiting for %s transactions to commit" % (txn_cnt)) \ as p: while not to() and txn_cnt > 0: p.step() time.sleep(1) txn_cnt = self._update_uncommitted_transactions() if txn_cnt != 0: if len(self.transactions) != 0: print "Uncommitted transactions: ", self.transactions raise Exception("{} transactions failed to commit in {}s".format( txn_cnt, to.WaitTime)) def setup(self, urls, num_keys): 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() with Progress("Creating initial key values") as p: for n in range(1, num_keys + 1): n = str(n) c = self._get_client() v = random.randint(5, 1000) self.localState[n] = v txn_id = c.set(n, v, txndep=None) if txn_id is None: raise Exception("Failed to set {} to {}".format(n, v)) self.transactions.append(txn_id) self.last_key_txn[n] = txn_id p.step() self._wait_for_transaction_commits() def run(self, rounds=1): if len(self.clients) == 0: return self.state.fetch() keys = self.state.State.keys() for r in range(1, rounds + 1): with Progress("Updating clients state") as p: for c in self.clients: c.fetch_state() p.step() cnt = 0 with Progress("Round {}".format(r)) as p: for k in keys: c = self._get_client() self.localState[k] += 2 if k in self.last_key_txn: txn_dep = self.last_key_txn[k] else: txn_dep = None txn_id = c.inc(k, 2, txn_dep) if txn_id is None: raise Exception( "Failed to inc key:{} value:{} by 2".format( k, self.localState[k])) self.transactions.append(txn_id) self.last_key_txn[k] = txn_id cnt += 1 if cnt % 10 == 0: p.step() for k in keys: c = self._get_client() self.localState[k] -= 1 txn_dep = self.last_key_txn[k] txn_id = c.dec(k, 1, txn_dep) if txn_id is None: raise Exception( "Failed to dec key:{} value:{} by 1".format( k, self.localState[k])) self.transactions.append(txn_id) self.last_key_txn[k] = txn_id cnt += 1 if cnt % 10 == 0: p.step() self._wait_for_transaction_commits() def validate(self): if len(self.clients) == 0: logger.warn("Unable to connect to Validators, No Clients created") return self.state.fetch() print "Validating IntegerKey State" for k, v in self.state.State.iteritems(): if self.localState[k] != v: print "key {} is {} expected to be {}".format( k, v, self.localState[k]) assert self.localState[k] == v
class IntKeyLoadTest(object): def __init__(self): pass def _get_client(self): return self.clients[random.randint(0, len(self.clients) - 1)] def _has_uncommitted_transactions(self): remaining = [] for t in self.transactions: status = self.clients[0].headrequest('/transaction/{0}'.format(t)) if status != http.OK: remaining.append(t) self.transactions = remaining return len(self.transactions) def _wait_for_transaction_commits(self): to = TimeOut(240) txnCnt = len(self.transactions) with Progress("Waiting for %s transactions to commit" % (txnCnt)) as p: while not to() and txnCnt > 0: p.step() time.sleep(1) self._has_uncommitted_transactions() txnCnt = len(self.transactions) if txnCnt != 0: if len(self.transactions) != 0: print "Uncommitted transactions: ", self.transactions raise Exception("{} transactions failed to commit in {}s".format( txnCnt, to.WaitTime)) def _wait_for_no_transaction_commits(self): # for the case where no transactions are expected to commit to = TimeOut(120) startingTxnCnt = len(self.transactions) remainingTxnCnt = len(self.transactions) with Progress("Waiting for no transactions to commit") as p: while not to() and remainingTxnCnt > 0: p.step() time.sleep(1) self._has_uncommitted_transactions() remainingTxnCnt = len(self.transactions) if startingTxnCnt != remainingTxnCnt: raise Exception( "{} unexpected transaction commits after {}s".format( startingTxnCnt - remainingTxnCnt, to.WaitTime)) # def _wait_for_no_transaction_commits(self): # to = TimeOut(120) # txnCnt = len(self.transactions) # with Progress("Waiting for transactions to commit") as p: # while not to() and txnCnt > 0: # p.step() # time.sleep(1) # self._has_uncommitted_transactions() # txnCnt = len(self.transactions) # # if txnCnt != 0: # if len(self.transactions) != 0: # print "Uncommitted transactions: ", self.transactions # "{} transactions with unmet dependencies did not " \ # "to commit in {}s".format( # txnCnt, to.WaitTime) # else: # raise Exception("{} transactions with unmet dependencies " # "committed in {}s".format( # txnCnt, to.WaitTime)) 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 run(self, rounds=1): self.state.fetch() keys = self.state.State.keys() for r in range(0, rounds): for c in self.clients: c.CurrentState.fetch() print "Round {}".format(r) for k in keys: c = self._get_client() self.localState[k] += 2 txnid = c.inc(k, 2) if txnid is None: raise Exception( "Failed to inc key:{} value:{} by 2".format( k, self.localState[k])) self.transactions.append(txnid) # for k in keys: # c = self._get_client() # self.localState[k] -= 1 # txnid = c.dec(k, 1) # if txnid is None: # raise Exception( # "Failed to dec key:{} value:{} by 1".format( # k, self.localState[k])) # self.transactions.append(txnid) self._wait_for_transaction_commits() def run_missing_dep_test(self, rounds=0): self.state.fetch() keys = self.state.State.keys() for r in range(0, rounds): for c in self.clients: c.CurrentState.fetch() print "Round {}".format(r) for k in keys: c = self._get_client() missingid = c.inc(k, 1, txndep=None, postmsg=False) dependingtid = c.inc(k, 1, txndep=missingid) self.transactions.append(dependingtid) self._wait_for_no_transaction_commits() def validate(self): self.state.fetch() print "Validating IntegerKey State" for k, v in self.state.State.iteritems(): if self.localState[k] != v: print "key {} is {} expected to be {}".format( k, v, self.localState[k]) assert self.localState[k] == v
class IntKeyLoadTest(object): def __init__(self): print "start inkeyloadtest" self.localState = {} self.transactions = [] self.clients = [] self.state = None def _get_client(self): return self.clients[random.randint(0, len(self.clients) - 1)] def _update_uncommitted_transactions(self): remaining = [] # For each client, we want to verify that its corresponding validator # has the transaction. For a transaction to be considered committed, # all validators must have it in its blockchain as a committed # transaction. for c in self.clients: for t in self.transactions: status = c.get_transaction_status(t) # If the transaction has not been committed and we don't # already have it in our list of uncommitted transactions # then add it. if (status != http.OK) and (t not in remaining): remaining.append(t) self.transactions = remaining return len(self.transactions) def _wait_for_transaction_commits(self): to = TimeOut(240) txnCnt = len(self.transactions) with Progress("Waiting for transactions to commit") as p: while not to() and txnCnt > 0: p.step() time.sleep(1) txnCnt = self._update_uncommitted_transactions() if txnCnt != 0: if len(self.transactions) != 0: print "Uncommitted transactions: ", self.transactions raise Exception("{} transactions failed to commit in {}s".format( txnCnt, to.WaitTime)) def _wait_for_no_transaction_commits(self): # for the case where no transactions are expected to commit to = TimeOut(120) starting_txn_count = len(self.transactions) remaining_txn_cnt = len(self.transactions) with Progress("Waiting for transactions to NOT commit") as p: while not to() and remaining_txn_cnt > 0: p.step() time.sleep(1) remaining_txn_cnt = self._update_uncommitted_transactions() if remaining_txn_cnt != starting_txn_count: committedtxncount = starting_txn_count - remaining_txn_cnt raise Exception("{} transactions with missing dependencies " "were committed in {}s".format( committedtxncount, to.WaitTime)) else: print "No transactions with missing dependencies " \ "were committed in {0}s".format(to.WaitTime) 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 run(self, numkeys, rounds=1, txintv=0): self.state.fetch() print "Running {0} rounds for {1} keys " \ "with {2} second inter-transaction time" \ .format(rounds, numkeys, txintv) for r in range(0, rounds): for c in self.clients: c.fetch_state() print "Round {}".format(r) # for k in keys: starttime = time.clock() for k in range(1, numkeys + 1): k = str(k) c = self._get_client() self.localState[k] += 2 txnid = c.inc(k, 2) if txnid is None: raise Exception( "Failed to inc key:{} value:{} by 2".format( k, self.localState[k])) self.transactions.append(txnid) time.sleep(txintv) # for k in keys: for k in range(1, numkeys + 1): k = str(k) c = self._get_client() self.localState[k] -= 1 txnid = c.dec(k, 1) if txnid is None: raise Exception( "Failed to dec key:{} value:{} by 1".format( k, self.localState[k])) self.transactions.append(txnid) time.sleep(txintv) self.txnrate(starttime, 2 * numkeys) self._wait_for_transaction_commits() def validate(self): self.state.fetch() print "Validating IntegerKey State" for k, v in self.state.State.iteritems(): if self.localState[k] != v: print "key {} is {} expected to be {}".format( k, v, self.localState[k]) assert self.localState[k] == v def ledgerstate(self): self.state.fetch() print "state: " for k, v in self.state.State.iteritems(): print k, v print def txnrate(self, starttime, numtxns): if numtxns > 0: endtime = time.clock() totaltime = endtime - starttime avgrate = (numtxns / totaltime) print "Sent {0} transaction in {1} seconds averaging {2} t/s" \ .format(numtxns, totaltime, avgrate) def run_with_missing_dep(self, numkeys, rounds=1): self.state.fetch() print "Running {0} rounds for {1} keys " \ "with missing transactions" \ .format(rounds, numkeys) for r in range(1, rounds + 1): for c in self.clients: c.CurrentState.fetch() print "Round {}".format(r) for k in range(1, numkeys + 1): k = str(k) c = c = self._get_client() missingid = c.inc(k, 1, txndep=None, postmsg=False) dependingtid = c.inc(k, 1, txndep=missingid) self.transactions.append(dependingtid) self._wait_for_no_transaction_commits()