def main():
node_root = "/tmp/near/upgradable"
if os.path.exists(node_root):
shutil.rmtree(node_root)
subprocess.check_output('mkdir -p /tmp/near', shell=True)
near_root, (stable_branch,
current_branch) = branches.prepare_ab_test("beta")
# Setup local network.
print([
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root, "testnet", "--v", "4", "--prefix", "test"
])
subprocess.call([
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root, "testnet", "--v", "4", "--prefix", "test"
])
genesis_config_changes = [("epoch_length", 20),
("num_block_producer_seats", 10),
("num_block_producer_seats_per_shard", [10]),
("block_producer_kickout_threshold", 80),
("chunk_producer_kickout_threshold", 80)]
node_dirs = [os.path.join(node_root, 'test%d' % i) for i in range(4)]
for i, node_dir in enumerate(node_dirs):
cluster.apply_genesis_changes(node_dir, genesis_config_changes)
# Start 3 stable nodes and one current node.
config = {
"local": True,
'near_root': near_root,
'binary_name': "near-%s" % stable_branch
}
nodes = [
cluster.spin_up_node(config, near_root, node_dirs[0], 0, None, None)
]
for i in range(1, 3):
nodes.append(
cluster.spin_up_node(config, near_root, node_dirs[i], i,
nodes[0].node_key.pk, nodes[0].addr()))
config["binary_name"] = "near-%s" % current_branch
nodes.append(
cluster.spin_up_node(config, near_root, node_dirs[3], 3,
nodes[0].node_key.pk, nodes[0].addr()))
wait_for_blocks_or_timeout(nodes[0], 20, 120)
# Restart stable nodes into new version.
for i in range(3):
nodes[i].kill()
nodes[i].binary_name = config['binary_name']
nodes[i].start(nodes[0].node_key.pk, nodes[0].addr())
wait_for_blocks_or_timeout(nodes[3], 60, 120)
status0 = nodes[0].get_status()
status3 = nodes[3].get_status()
protocol_version = status0['protocol_version']
latest_protocol_version = status3["latest_protocol_version"]
assert protocol_version == latest_protocol_version,\
"Latest protocol version %d should match active protocol version %d" % (latest_protocol_version, protocol_version)
def main():
near_root, (stable_branch,
current_branch) = branches.prepare_ab_test("1.13.0")
node_root = os.path.join(os.path.expanduser("~"), "./near")
logging.info(f"The near root is {near_root}...")
logging.info(f"The node root is {node_root}...")
init_command = [
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root,
"init",
"--fast",
]
# Init local node
subprocess.call(init_command)
# Run stable node for few blocks.
config = {
"local": True,
'near_root': near_root,
'binary_name': "near-%s" % stable_branch
}
logging.info("Starting the stable node...")
stable_node = cluster.spin_up_node(config, near_root, node_root, 0, None,
None)
logging.info("Running the stable node...")
wait_for_blocks_or_timeout(stable_node, 20, 100)
logging.info("Blocks are being produced, sending some tx...")
deploy_contract(stable_node)
send_some_tx(stable_node)
subprocess.call(["cp", "-r", node_root, "/tmp/near"])
stable_node.cleanup()
logging.info(
"Stable node has produced blocks... Stopping the stable node... ")
# Run new node and verify it runs for a few more blocks.
config["binary_name"] = "near-%s" % current_branch
subprocess.call(["cp", "-r", "/tmp/near", node_root])
logging.info("Starting the current node...")
current_node = cluster.spin_up_node(config, near_root, node_root, 0, None,
None)
logging.info("Running the current node...")
wait_for_blocks_or_timeout(current_node, 20, 100)
logging.info("Blocks are being produced, sending some tx...")
send_some_tx(stable_node)
logging.info(
"Currnet node has produced blocks... Stopping the current node... ")
current_node.cleanup()
def main():
node_root = "/tmp/near/backward"
if os.path.exists(node_root):
shutil.rmtree(node_root)
subprocess.check_output('mkdir -p /tmp/near', shell=True)
near_root, (stable_branch,
current_branch) = branches.prepare_ab_test("beta")
# Setup local network.
subprocess.call([
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root, "testnet", "--v", "2", "--prefix", "test"
])
with open('/tmp/near/backward/test0/genesis.json') as f:
stable_genesis = json.load(f)
stable_protocol_version = stable_genesis['protocol_version']
with open(
os.path.join(os.path.dirname(__file__),
'../../../neard/res/genesis_config.json')) as f:
current_genesis = json.load(f)
current_protocol_version = current_genesis['protocol_version']
if current_protocol_version > stable_protocol_version:
print('Protcol upgrade, does not need backward compatible')
exit(0)
# Run both binaries at the same time.
config = {
"local": True,
'near_root': near_root,
'binary_name': "near-%s" % stable_branch
}
stable_node = cluster.spin_up_node(config, near_root,
os.path.join(node_root, "test0"), 0,
None, None)
config["binary_name"] = "near-%s" % current_branch
current_node = cluster.spin_up_node(config, near_root,
os.path.join(node_root, "test1"), 1,
stable_node.node_key.pk,
stable_node.addr())
# Check it all works.
# TODO: we should run for at least 2 epochs.
# TODO: send some transactions to test that runtime works the same.
BLOCKS = 20
TIMEOUT = 150
max_height = 0
started = time.time()
while max_height < BLOCKS:
assert time.time() - started < TIMEOUT
status = current_node.get_status()
max_height = status['sync_info']['latest_block_height']
def main():
executables = branches.prepare_ab_test()
node_root = utils.get_near_tempdir('db_migration', clean=True)
logging.info(f"The near root is {executables.stable.root}...")
logging.info(f"The node root is {node_root}...")
# Init local node
subprocess.call((
executables.stable.neard,
"--home=%s" % node_root,
"init",
"--fast",
))
# Run stable node for few blocks.
logging.info("Starting the stable node...")
config = executables.stable.node_config()
node = cluster.spin_up_node(config, executables.stable.root,
str(node_root), 0)
logging.info("Running the stable node...")
utils.wait_for_blocks(node, count=20)
logging.info("Blocks are being produced, sending some tx...")
deploy_contract(node)
send_some_tx(node)
node.kill()
logging.info(
"Stable node has produced blocks... Stopping the stable node... ")
# Run new node and verify it runs for a few more blocks.
logging.info("Starting the current node...")
config = executables.current.node_config()
node.binary_name = config['binary_name']
node.start(boot_node=node)
logging.info("Running the current node...")
utils.wait_for_blocks(node, count=20)
logging.info("Blocks are being produced, sending some tx...")
send_some_tx(node)
logging.info(
"Currnet node has produced blocks... Stopping the current node... ")
node.kill()
logging.info("Restarting the current node...")
node.start(boot_node=node)
utils.wait_for_blocks(node, count=20)
def main():
node_root = '/tmp/near/state_migration'
if os.path.exists(node_root):
shutil.rmtree(node_root)
subprocess.check_output('mkdir -p /tmp/near', shell=True)
near_root, (stable_branch, current_branch) = branches.prepare_ab_test("beta")
# Run stable node for few blocks.
subprocess.call(["%snear-%s" % (near_root, stable_branch), "--home=%s/test0" % node_root, "init", "--fast"])
stable_protocol_version = json.load(open('%s/test0/genesis.json' % node_root))['protocol_version']
config = {"local": True, 'near_root': near_root, 'binary_name': "near-%s" % stable_branch }
stable_node = cluster.spin_up_node(config, near_root, os.path.join(node_root, "test0"), 0, None, None)
wait_for_blocks_or_timeout(stable_node, 20, 100)
# TODO: we should make state more interesting to migrate by sending some tx / contracts.
stable_node.cleanup()
os.mkdir('%s/test0' % node_root)
# Dump state.
subprocess.call(["%sstate-viewer-%s" % (near_root, stable_branch), "--home", '%s/test0_finished' % node_root, "dump_state"])
# Migrate.
migrations_home = '../scripts/migrations'
all_migrations = sorted(os.listdir(migrations_home), key=lambda x: int(x.split('-')[0]))
for fname in all_migrations:
m = re.match('([0-9]+)\-.*', fname)
if m:
version = int(m.groups()[0])
if version > stable_protocol_version:
exitcode = subprocess.call(['python', os.path.join(migrations_home, fname), '%s/test0_finished' % node_root, '%s/test0_finished' % node_root])
assert exitcode == 0, "Failed to run migration %d" % version
os.rename(os.path.join(node_root, 'test0_finished/output.json'), os.path.join(node_root, 'test0/genesis.json'))
shutil.copy(os.path.join(node_root, 'test0_finished/config.json'), os.path.join(node_root, 'test0/'))
shutil.copy(os.path.join(node_root, 'test0_finished/validator_key.json'), os.path.join(node_root, 'test0/'))
shutil.copy(os.path.join(node_root, 'test0_finished/node_key.json'), os.path.join(node_root, 'test0/'))
# Run new node and verify it runs for a few more blocks.
config["binary_name"] = "near-%s" % current_branch
current_node = cluster.spin_up_node(config, near_root, os.path.join(node_root, "test0"), 0, None, None)
wait_for_blocks_or_timeout(current_node, 20, 100)
# New genesis can be deserialized by new near is verified above (new near can produce blocks)
# Also test new genesis protocol_version matches neard/res/genesis_config's
new_genesis = json.load(open(os.path.join(node_root, 'test0/genesis.json')))
res_genesis = json.load(open('../neard/res/genesis_config.json'))
assert new_genesis['protocol_version'] == res_genesis['protocol_version']
def main():
node_root = "/tmp/near/backward"
if os.path.exists(node_root):
shutil.rmtree(node_root)
subprocess.check_output('mkdir -p /tmp/near', shell=True)
branch = branches.latest_rc_branch()
print(f"Latest rc release branch is {branch}")
near_root, (stable_branch,
current_branch) = branches.prepare_ab_test(branch)
# Setup local network.
subprocess.call([
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root, "testnet", "--v", "2", "--prefix", "test"
])
# Run both binaries at the same time.
config = {
"local": True,
'near_root': near_root,
'binary_name': "near-%s" % stable_branch
}
stable_node = cluster.spin_up_node(config, near_root,
os.path.join(node_root, "test0"), 0,
None, None)
config["binary_name"] = "near-%s" % current_branch
current_node = cluster.spin_up_node(config, near_root,
os.path.join(node_root, "test1"), 1,
stable_node.node_key.pk,
stable_node.addr())
# Check it all works.
# TODO: we should run for at least 2 epochs.
# TODO: send some transactions to test that runtime works the same.
BLOCKS = 20
TIMEOUT = 150
max_height = -1
started = time.time()
while max_height < BLOCKS:
assert time.time() - started < TIMEOUT
status = current_node.get_status()
cur_height = status['sync_info']['latest_block_height']
if cur_height > max_height:
max_height = cur_height
print("Height:", max_height)
def main():
node_root = utils.get_near_tempdir('backward', clean=True)
executables = branches.prepare_ab_test()
# Setup local network.
subprocess.check_call([
executables.stable.neard,
"--home=%s" % node_root,
# TODO(#4372): testnet subcommand deprecated since 1.24. Replace with
# localnet after a couple of releases in 2022.
"testnet",
"--v",
"2",
"--prefix",
"test"
])
# Run both binaries at the same time.
config = executables.stable.node_config()
stable_node = cluster.spin_up_node(config, executables.stable.root,
str(node_root / 'test0'), 0)
config = executables.current.node_config()
current_node = cluster.spin_up_node(config,
executables.current.root,
str(node_root / 'test1'),
1,
boot_node=stable_node)
# Check it all works.
BLOCKS = 100
max_height = -1
started = time.time()
# Create account, transfer tokens, deploy contract, invoke function call
block_hash = stable_node.get_latest_block().hash_bytes
new_account_id = 'test_account.test0'
new_signer_key = cluster.Key(new_account_id, stable_node.signer_key.pk,
stable_node.signer_key.sk)
create_account_tx = sign_create_account_with_full_access_key_and_balance_tx(
stable_node.signer_key, new_account_id, new_signer_key, 10**24, 1,
block_hash)
res = stable_node.send_tx_and_wait(create_account_tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
transfer_tx = sign_payment_tx(stable_node.signer_key, new_account_id,
10**25, 2, block_hash)
res = stable_node.send_tx_and_wait(transfer_tx, timeout=20)
assert 'error' not in res, res
block_height = stable_node.get_latest_block().height
nonce = block_height * 1_000_000 - 1
tx = sign_deploy_contract_tx(new_signer_key, utils.load_test_contract(),
nonce, block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
tx = sign_deploy_contract_tx(stable_node.signer_key,
utils.load_test_contract(), 3, block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
tx = sign_function_call_tx(new_signer_key, new_account_id,
'write_random_value', [], 10**13, 0, nonce + 1,
block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
data = json.dumps([{
"create": {
"account_id": "test_account.test0",
"method_name": "call_promise",
"arguments": [],
"amount": "0",
"gas": 30000000000000,
},
"id": 0
}, {
"then": {
"promise_index": 0,
"account_id": "test0",
"method_name": "call_promise",
"arguments": [],
"amount": "0",
"gas": 30000000000000,
},
"id": 1
}])
tx = sign_function_call_tx(stable_node.signer_key,
new_account_id, 'call_promise',
bytes(data, 'utf-8'), 90000000000000, 0,
nonce + 2, block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
utils.wait_for_blocks(current_node, target=BLOCKS)
stable_node = cluster.spin_up_node(config, near_root,
os.path.join(node_root, "test0"), 0,
None, None)
config["binary_name"] = "near-%s" % new_branch
current_node = cluster.spin_up_node(config, near_root,
os.path.join(node_root, "test1"), 1,
stable_node.node_key.pk,
stable_node.addr())
# Check it all works.
# TODO: we should run for at least 2 epochs.
# TODO: send some transactions to test that runtime works the same.
BLOCKS = 20
TIMEOUT = 150
max_height = -1
started = time.time()
while max_height < BLOCKS:
assert time.time() - started < TIMEOUT
status = current_node.get_status()
cur_height = status['sync_info']['latest_block_height']
if cur_height > max_height:
max_height = cur_height
print("Height:", max_height)
if __name__ == "__main__":
near_root, (stable_branch, new_branch) = branches.prepare_ab_test("beta")
main(near_root, stable_branch, new_branch)
def main():
node_root = "/tmp/near/upgradable"
if os.path.exists(node_root):
shutil.rmtree(node_root)
subprocess.check_output('mkdir -p /tmp/near', shell=True)
# TODO(#3285): use proper branch
near_root, (stable_branch,
current_branch) = branches.prepare_ab_test("1.13.0")
# Setup local network.
print([
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root, "testnet", "--v", "4", "--prefix", "test"
])
subprocess.call([
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root, "testnet", "--v", "4", "--prefix", "test"
])
genesis_config_changes = [
("epoch_length", 20), ("num_block_producer_seats", 10),
("num_block_producer_seats_per_shard", [10]), ("block_producer_kickout_threshold", 80),
("chunk_producer_kickout_threshold", 80), ("chain_id", "testnet")
]
node_dirs = [os.path.join(node_root, 'test%d' % i) for i in range(4)]
for i, node_dir in enumerate(node_dirs):
cluster.apply_genesis_changes(node_dir, genesis_config_changes)
# Start 3 stable nodes and one current node.
config = {
"local": True,
'near_root': near_root,
'binary_name': "near-%s" % stable_branch
}
nodes = [cluster.spin_up_node(
config, near_root, node_dirs[0], 0, None, None)]
for i in range(1, 3):
nodes.append(cluster.spin_up_node(
config, near_root, node_dirs[i], i, nodes[0].node_key.pk, nodes[0].addr()))
config["binary_name"] = "near-%s" % current_branch
nodes.append(cluster.spin_up_node(
config, near_root, node_dirs[3], 3, nodes[0].node_key.pk, nodes[0].addr()))
time.sleep(2)
# deploy a contract
status = nodes[0].get_status()
hash = status['sync_info']['latest_block_hash']
tx = sign_deploy_contract_tx(
nodes[0].signer_key,
load_binary_file(
'../runtime/near-vm-runner/tests/res/test_contract_rs.wasm'), 1, base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
# write some random value
tx = sign_function_call_tx(nodes[0].signer_key, nodes[0].signer_key.account_id,
'write_random_value', [], 10**13, 0, 2,
base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
# hex_account_id = (b"I'm hex!" * 4).hex()
hex_account_id = '49276d206865782149276d206865782149276d206865782149276d2068657821'
tx = sign_payment_tx(key=nodes[0].signer_key,
to=hex_account_id,
amount=10 ** 25,
nonce=3,
blockHash=base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
# Account doesn't exist
assert 'error' not in res, res
assert 'Failure' in res['result']['status'], res
# No account
res = nodes[0].get_account(hex_account_id)
assert 'error' in res, res
wait_for_blocks_or_timeout(nodes[0], 20, 120)
# Restart stable nodes into new version.
for i in range(3):
nodes[i].kill()
nodes[i].binary_name = config['binary_name']
nodes[i].start(nodes[0].node_key.pk, nodes[0].addr())
wait_for_blocks_or_timeout(nodes[3], 60, 120)
status0 = nodes[0].get_status()
status3 = nodes[3].get_status()
protocol_version = status0['protocol_version']
latest_protocol_version = status3["latest_protocol_version"]
assert protocol_version == latest_protocol_version, \
"Latest protocol version %d should match active protocol version %d" % (latest_protocol_version, protocol_version)
hash = status0['sync_info']['latest_block_hash']
# write some random value again
tx = sign_function_call_tx(nodes[0].signer_key, nodes[0].signer_key.account_id,
'write_random_value', [], 10**13, 0, 4,
base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
tx = sign_payment_tx(key=nodes[0].signer_key,
to=hex_account_id,
amount=10 ** 25,
nonce=5,
blockHash=base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
# Successfully created a new account on transfer to hex
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
hex_account_balance = int(nodes[0].get_account(hex_account_id)['result']['amount'])
assert hex_account_balance == 10 ** 25
def main():
near_root, (stable_branch,
current_branch) = branches.prepare_ab_test("master")
node_root = "/tmp/near/db_migration"
if os.path.exists(node_root):
shutil.rmtree(node_root)
subprocess.check_output('mkdir -p /tmp/near', shell=True)
logging.info(f"The near root is {near_root}...")
logging.info(f"The node root is {node_root}...")
init_command = [
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root,
"init",
"--fast",
]
# Init local node
subprocess.call(init_command)
# Run stable node for few blocks.
config = {
"local": True,
'near_root': near_root,
'binary_name': "near-%s" % stable_branch
}
logging.info("Starting the stable node...")
node = cluster.spin_up_node(config, near_root, node_root, 0, None, None)
logging.info("Running the stable node...")
wait_for_blocks_or_timeout(node, 20, 100)
logging.info("Blocks are being produced, sending some tx...")
deploy_contract(node)
send_some_tx(node)
node.kill()
logging.info(
"Stable node has produced blocks... Stopping the stable node... ")
# Run new node and verify it runs for a few more blocks.
config["binary_name"] = "near-%s" % current_branch
logging.info("Starting the current node...")
node.binary_name = config['binary_name']
node.start(node.node_key.pk, node.addr())
logging.info("Running the current node...")
wait_for_blocks_or_timeout(node, 20, 100)
logging.info("Blocks are being produced, sending some tx...")
send_some_tx(node)
logging.info(
"Currnet node has produced blocks... Stopping the current node... ")
node.kill()
logging.info("Restarting the current node...")
node.start(node.node_key.pk, node.addr())
wait_for_blocks_or_timeout(node, 20, 100)
def main():
node_root = "/tmp/near/backward"
if os.path.exists(node_root):
shutil.rmtree(node_root)
subprocess.check_output('mkdir -p /tmp/near', shell=True)
branch = branches.latest_rc_branch()
near_root, (stable_branch,
current_branch) = branches.prepare_ab_test(branch)
# Setup local network.
subprocess.call([
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root, "testnet", "--v", "2", "--prefix", "test"
])
# Run both binaries at the same time.
config = {
"local": True,
'near_root': near_root,
'binary_name': "near-%s" % stable_branch
}
stable_node = cluster.spin_up_node(config, near_root,
os.path.join(node_root, "test0"), 0,
None, None)
config["binary_name"] = "near-%s" % current_branch
current_node = cluster.spin_up_node(config, near_root,
os.path.join(node_root, "test1"), 1,
stable_node.node_key.pk,
stable_node.addr())
# Check it all works.
BLOCKS = 100
TIMEOUT = 150
max_height = -1
started = time.time()
# Create account, transfer tokens, deploy contract, invoke function call
status = stable_node.get_status()
block_hash = base58.b58decode(
status['sync_info']['latest_block_hash'].encode('utf-8'))
new_account_id = 'test_account'
new_signer_key = cluster.Key(new_account_id, stable_node.signer_key.pk,
stable_node.signer_key.sk)
create_account_tx = sign_create_account_with_full_access_key_and_balance_tx(
stable_node.signer_key, new_account_id, new_signer_key, 10**24, 1,
block_hash)
res = stable_node.send_tx_and_wait(create_account_tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
transfer_tx = sign_payment_tx(stable_node.signer_key, new_account_id,
10**25, 2, block_hash)
res = stable_node.send_tx_and_wait(transfer_tx, timeout=20)
assert 'error' not in res, res
status = stable_node.get_status()
block_height = status['sync_info']['latest_block_height']
nonce = block_height * 1_000_000 - 1
tx = sign_deploy_contract_tx(new_signer_key, load_test_contract(), nonce,
block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
tx = sign_function_call_tx(new_signer_key, new_account_id,
'write_random_value', [], 10**13, 0, nonce + 1,
block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
data = json.dumps([{
"create": {
"account_id": "near_2",
"method_name": "call_promise",
"arguments": [],
"amount": "0",
"gas": 30000000000000,
},
"id": 0
}, {
"then": {
"promise_index": 0,
"account_id": "near_3",
"method_name": "call_promise",
"arguments": [],
"amount": "0",
"gas": 30000000000000,
},
"id": 1
}])
tx = sign_function_call_tx(new_signer_key, new_account_id, 'call_promise',
bytes(data, 'utf-8'), 90000000000000, 0,
nonce + 2, block_hash)
res = stable_node.send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
while max_height < BLOCKS:
assert time.time() - started < TIMEOUT
status = current_node.get_status()
cur_height = status['sync_info']['latest_block_height']
if cur_height > max_height:
max_height = cur_height
time.sleep(1)
def get_executables() -> branches.ABExecutables:
global _EXECUTABLES
if _EXECUTABLES is None:
_EXECUTABLES = branches.prepare_ab_test()
logger.info(f"Latest mainnet release is {_EXECUTABLES.release}")
return _EXECUTABLES
def main():
node_root = "/tmp/near/upgradable"
if os.path.exists(node_root):
shutil.rmtree(node_root)
subprocess.check_output('mkdir -p /tmp/near', shell=True)
branch = branches.latest_rc_branch()
logger.info(f"Latest rc release branch is {branch}")
near_root, (stable_branch,
current_branch) = branches.prepare_ab_test(branch)
# Setup local network.
logger.info([
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root, "testnet", "--v", "4", "--prefix", "test"
])
subprocess.call([
"%snear-%s" % (near_root, stable_branch),
"--home=%s" % node_root, "testnet", "--v", "4", "--prefix", "test"
])
genesis_config_changes = [("epoch_length", 20),
("num_block_producer_seats", 10),
("num_block_producer_seats_per_shard", [10]),
("block_producer_kickout_threshold", 80),
("chunk_producer_kickout_threshold", 80),
("chain_id", "testnet")]
node_dirs = [os.path.join(node_root, 'test%d' % i) for i in range(4)]
for i, node_dir in enumerate(node_dirs):
cluster.apply_genesis_changes(node_dir, genesis_config_changes)
# Start 3 stable nodes and one current node.
config = {
"local": True,
'near_root': near_root,
'binary_name': "near-%s" % stable_branch
}
nodes = [
cluster.spin_up_node(config, near_root, node_dirs[0], 0, None, None)
]
for i in range(1, 3):
nodes.append(
cluster.spin_up_node(config, near_root, node_dirs[i], i,
nodes[0].node_key.pk, nodes[0].addr()))
if os.getenv('NAYDUCK'):
config["binary_name"] = "near"
else:
config["binary_name"] = "near-%s" % current_branch
nodes.append(
cluster.spin_up_node(config, near_root, node_dirs[3], 3,
nodes[0].node_key.pk, nodes[0].addr()))
time.sleep(2)
# deploy a contract
status = nodes[0].get_status()
hash = status['sync_info']['latest_block_hash']
tx = sign_deploy_contract_tx(nodes[0].signer_key, load_test_contract(), 1,
base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
# write some random value
tx = sign_function_call_tx(nodes[0].signer_key,
nodes[0].signer_key.account_id,
'write_random_value', [], 10**13, 0, 2,
base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
wait_for_blocks_or_timeout(nodes[0], 20, 120)
# Restart stable nodes into new version.
for i in range(3):
nodes[i].kill()
nodes[i].binary_name = config['binary_name']
nodes[i].start(nodes[0].node_key.pk, nodes[0].addr())
wait_for_blocks_or_timeout(nodes[3], 60, 120)
status0 = nodes[0].get_status()
status3 = nodes[3].get_status()
protocol_version = status0['protocol_version']
latest_protocol_version = status3["latest_protocol_version"]
assert protocol_version == latest_protocol_version, \
"Latest protocol version %d should match active protocol version %d" % (
latest_protocol_version, protocol_version)
hash = status0['sync_info']['latest_block_hash']
# write some random value again
tx = sign_function_call_tx(nodes[0].signer_key,
nodes[0].signer_key.account_id,
'write_random_value', [], 10**13, 0, 4,
base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
# hex_account_id = (b"I'm hex!" * 4).hex()
hex_account_id = '49276d206865782149276d206865782149276d206865782149276d2068657821'
tx = sign_payment_tx(key=nodes[0].signer_key,
to=hex_account_id,
amount=10**25,
nonce=5,
blockHash=base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
# Successfully created a new account on transfer to hex
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
hex_account_balance = int(
nodes[0].get_account(hex_account_id)['result']['amount'])
assert hex_account_balance == 10**25
hash = status0['sync_info']['latest_block_hash']
new_account_id = f'new.{nodes[0].signer_key.account_id}'
new_signer_key = cluster.Key(new_account_id, nodes[0].signer_key.pk,
nodes[0].signer_key.sk)
create_account_tx = sign_create_account_with_full_access_key_and_balance_tx(
nodes[0].signer_key, new_account_id, new_signer_key, 10**24, 6,
base58.b58decode(hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(create_account_tx, timeout=20)
# Successfully created a new account
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
hash = status0['sync_info']['latest_block_hash']
status = nodes[0].get_status()
block_height = status['sync_info']['latest_block_height']
beneficiary_account_id = '1982374698376abd09265034ef35034756298375462323456294875193563756'
tx = sign_delete_account_tx(key=new_signer_key,
to=new_account_id,
beneficiary=beneficiary_account_id,
nonce=block_height * 1_000_000 - 1,
block_hash=base58.b58decode(
hash.encode('utf8')))
res = nodes[0].send_tx_and_wait(tx, timeout=20)
# Successfully deleted an account
assert 'error' not in res, res
assert 'Failure' not in res['result']['status'], res
None, None)
config["binary_name"] = "near-%s" % new_branch
current_node = cluster.spin_up_node(config, near_root,
os.path.join(node_root, "test1"), 1,
stable_node.node_key.pk,
stable_node.addr())
# Check it all works.
# TODO: we should run for at least 2 epochs.
# TODO: send some transactions to test that runtime works the same.
BLOCKS = 20
TIMEOUT = 150
max_height = -1
started = time.time()
while max_height < BLOCKS:
assert time.time() - started < TIMEOUT
status = current_node.get_status()
cur_height = status['sync_info']['latest_block_height']
if cur_height > max_height:
max_height = cur_height
print("Height:", max_height)
if __name__ == "__main__":
# TODO(#3285): use proper branch
near_root, (stable_branch,
new_branch) = branches.prepare_ab_test('1.13.0')
main(near_root, stable_branch, new_branch)
