def deploy_client(request, populus_config):
client_type = populus_config.get_value(request, 'deploy_client_type')
if client_type == 'ethtester':
from populus.ethtester_client import EthTesterClient
client = EthTesterClient()
elif client_type == 'rpc':
from eth_rpc_client import Client
rpc_host = populus_config.get_value(request, 'deploy_client_rpc_host')
rpc_port = populus_config.get_value(request, 'deploy_client_rpc_port')
client = Client(rpc_host, rpc_port)
elif client_type == 'ipc':
from eth_ipc_client import Client
ipc_path = populus_config.get_value(request, 'ipc_path')
if ipc_path is None:
from populus.geth import get_geth_data_dir
geth_project_dir = populus_config.get_value(request, 'geth_project_dir')
geth_chain_name = populus_config.get_value(request, 'geth_chain_name')
geth_data_dir = get_geth_data_dir(geth_project_dir, geth_chain_name)
ipc_path = os.path.join(geth_data_dir, 'geth.ipc')
client = Client(ipc_path)
else:
raise ValueError(
"Unsupported client type '{0}'. Supported values are 'tester', "
"'rpc', and 'ipc'"
)
return client
def test_new_filter(rpc_server, eth_coinbase):
"""
"""
client = Client(CLIENT_HOST, CLIENT_PORT)
filt_id = client.new_filter(from_block="latest", to_block="pending")
assert is_valid_filter_id(filt_id)
def test_running_node_without_mining(project_test04, open_port):
data_dir = get_geth_data_dir(project_test04, 'default')
command, proc = run_geth_node(data_dir, rpc_port=open_port, mine=False)
wait_for_popen(proc)
rpc_client = Client('127.0.0.1', port=open_port)
coinbase = rpc_client.get_coinbase()
proc.send_signal(signal.SIGINT)
wait_for_popen(proc)
assert coinbase == get_geth_accounts(data_dir)[0]
def test_running_node_without_mining(project_test04, open_port):
data_dir = get_geth_data_dir(project_test04, 'default')
command, proc = run_geth_node(data_dir, rpc_port=open_port, mine=False)
wait_for_popen(proc)
rpc_client = Client('127.0.0.1', port=open_port)
coinbase = rpc_client.get_coinbase()
proc.send_signal(signal.SIGINT)
wait_for_popen(proc)
assert coinbase == get_geth_accounts(data_dir)[0]
def test_get_filter_changes(rpc_server, eth_coinbase):
"""
"""
client = Client(CLIENT_HOST, CLIENT_PORT)
filt_id = client.new_filter()
assert is_valid_filter_id(filt_id)
resp = client.get_filter_logs(filt_id)
assert resp == []
def test_uninstall_filter(rpc_server, eth_coinbase):
"""
"""
client = Client(CLIENT_HOST, CLIENT_PORT)
filt_id = client.new_filter()
assert is_valid_filter_id(filt_id)
resp = client.uninstall_filter(filt_id)
assert resp == True
def test_get_transaction_by_hash(rpc_server, eth_coinbase):
client = Client("127.0.0.1", "8545")
to_addr = tester.encode_hex(tester.accounts[1])
txn_hash = client.send_transaction(_from=eth_coinbase, to=to_addr, value=12345)
txn = client.get_transaction_by_hash(txn_hash)
assert txn["from"].endswith(eth_coinbase)
assert txn["to"].endswith(to_addr)
assert int(txn["value"], 16) == 12345
def test_send_a_transaction_uses_coinbase_as_from(rpc_server, eth_coinbase):
client = Client('127.0.0.1', '8545')
to_addr = tester.encode_hex(tester.accounts[1])
txn_hash = client.send_transaction(
to=to_addr,
value=12345,
)
after_balance = client.get_balance(eth_coinbase)
assert after_balance == 1000004999999999999987655L
def test_running_node_and_mining(project_test04, open_port):
data_dir = get_geth_data_dir(project_test04, 'default')
command, proc = run_geth_node(data_dir, rpc_port=open_port, mine=True)
wait_for_popen(proc)
rpc_client = Client('127.0.0.1', port=open_port)
block_num = rpc_client.get_block_number()
start = time.time()
rpc_client.wait_for_block(block_num + 1, 60)
assert block_num < rpc_client.get_block_number()
proc.send_signal(signal.SIGINT)
wait_for_popen(proc)
def test_running_node_and_mining(project_test04, open_port):
data_dir = get_geth_data_dir(project_test04, 'default')
command, proc = run_geth_node(data_dir, rpc_port=open_port, mine=True)
wait_for_popen(proc)
rpc_client = Client('127.0.0.1', port=open_port)
block_num = rpc_client.get_block_number()
start = time.time()
while rpc_client.get_block_number() <= block_num:
time.sleep(0.2)
if time.time() > start + 20:
raise Exception('Could not mine block within 20 seconds')
assert block_num < rpc_client.get_block_number()
proc.send_signal(signal.SIGINT)
wait_for_popen(proc)
def test_contract_creation(rpc_server, eth_coinbase):
client = Client('127.0.0.1', '8545')
data = "0x60606040525b5b600a8060136000396000f30060606040526008565b00"
txn_hash = client.send_transaction(
_from=eth_coinbase,
value=12345,
data=data,
)
txn_receipt = client.get_transaction_receipt(txn_hash)
contract_addr = txn_receipt['contractAddress']
contract_balance = client.get_balance(contract_addr)
assert contract_balance == 12345
def test_contract_creation(rpc_server, eth_coinbase):
client = Client('127.0.0.1', '8545')
data = "0x60606040525b5b600a8060136000396000f30060606040526008565b00"
txn_hash = client.send_transaction(
_from=eth_coinbase,
value=12345,
data=data,
)
txn_receipt = client.get_transaction_receipt(txn_hash)
contract_addr = txn_receipt['contractAddress']
contract_balance = client.get_balance(contract_addr)
assert contract_balance == 12345
def test_running_node_and_mining(project_test04, open_port):
data_dir = get_geth_data_dir(project_test04, 'default')
command, proc = run_geth_node(data_dir, rpc_port=open_port, mine=True)
time.sleep(2)
rpc_client = Client('127.0.0.1', port=open_port)
block_num = rpc_client.get_block_number()
start = time.time()
while time.time() < start + 10:
time.sleep(0.2)
if rpc_client.get_block_number() > block_num:
break
assert block_num < rpc_client.get_block_number()
proc.send_signal(signal.SIGINT)
wait_for_popen(proc)
def test_running_node_and_mining(project_test04, open_port):
data_dir = get_geth_data_dir(project_test04, 'default')
command, proc = run_geth_node(data_dir, rpc_port=open_port, mine=True)
wait_for_popen(proc)
rpc_client = Client('127.0.0.1', port=open_port)
block_num = rpc_client.get_block_number()
start = time.time()
while rpc_client.get_block_number() <= block_num:
time.sleep(0.2)
if time.time() > start + 20:
raise Exception('Could not mine block within 20 seconds')
assert block_num < rpc_client.get_block_number()
proc.send_signal(signal.SIGINT)
wait_for_popen(proc)
def test_running_node_and_mining(project_test04, open_port):
data_dir = get_geth_data_dir(project_test04, 'default')
command, proc = run_geth_node(data_dir, rpc_port=open_port, mine=True)
time.sleep(2)
rpc_client = Client('127.0.0.1', port=open_port)
block_num = rpc_client.get_block_number()
start = time.time()
while time.time() < start + 10:
time.sleep(0.2)
if rpc_client.get_block_number() > block_num:
break
assert block_num < rpc_client.get_block_number()
proc.send_signal(signal.SIGINT)
wait_for_popen(proc)
def test_get_transaction_by_hash(rpc_server, eth_coinbase):
client = Client('127.0.0.1', '8545')
to_addr = tester.encode_hex(tester.accounts[1])
txn_hash = client.send_transaction(
_from=eth_coinbase,
to=to_addr,
value=12345,
)
txn = client.get_transaction_by_hash(txn_hash)
assert txn['from'].endswith(eth_coinbase)
assert txn['to'].endswith(to_addr)
assert int(txn['value'], 16) == 12345
def get_client(name):
if len(clients) == 0:
clients.update({
name: Client(host=node['host'], port=node['port'])
for name, node in get_nodes().iteritems()
})
return clients[name]
def test_get_code(rpc_server, eth_coinbase):
client = Client('127.0.0.1', '8545')
data = "0x606060405260f8806100126000396000f30060606040526000357c01000000000000000000000000000000000000000000000000000000009004806316216f3914604b578063a5f3c23b14606a578063dcf537b1146095576049565b005b605460045060e6565b6040518082815260200191505060405180910390f35b607f60048035906020018035906020015060ba565b6040518082815260200191505060405180910390f35b60a460048035906020015060d0565b6040518082815260200191505060405180910390f35b60008183019050805080905060ca565b92915050565b6000600782029050805080905060e1565b919050565b6000600d9050805080905060f5565b9056"
txn_hash = client.send_transaction(
_from=eth_coinbase,
data=data,
)
txn_receipt = client.get_transaction_receipt(txn_hash)
contract_addr = txn_receipt['contractAddress']
code = client.get_code(contract_addr)
# TODO: figure out what's going on here and why the two are almost the same
# but not exactly the same.
assert len(code) > 100
assert data.endswith(code[2:])
class Eth(object):
def __init__(self, rpc_port):
self.rpc_ip = '127.0.0.1'
self.rpc_port = rpc_port
self.rpc_eth = Client(self.rpc_ip, self.rpc_port)
def getnewaddress(self):
return self.rpc_eth.get_coinbase()
def ipc_client(request, populus_config):
from eth_ipc_client import Client
ipc_path = populus_config.get_value(request, 'ipc_path')
if ipc_path is None:
from populus.geth import get_geth_data_dir
geth_project_dir = populus_config.get_value(request, 'geth_project_dir')
geth_chain_name = populus_config.get_value(request, 'geth_chain_name')
geth_data_dir = get_geth_data_dir(geth_project_dir, geth_chain_name)
ipc_path = os.path.join(geth_data_dir, 'geth.ipc')
client = Client(ipc_path)
return client
def get_transaction_by_hash(self, hash):
try:
if self.rpc_client is None:
self.rpc_client = RpcClient(host=self.host, port=self.rpc_port)
self.rpc_client.session.headers.update(
{"Content-type": "application/json"})
result = self.rpc_client.get_transaction_by_hash(hash)
return result
except Exception as e:
self.logger.error("Cannot get balance due to exception. %s", e)
return None
def get_balance(self):
try:
if self.rpc_client is None:
self.rpc_client = RpcClient(host=self.host, port=self.rpc_port)
self.rpc_client.session.headers.update(
{"Content-type": "application/json"})
balance = self.rpc_client.get_balance("0x{}".format(
self.coin_base))
return balance
except Exception as e:
self.logger.error("Cannot get balance due to exception. %s", e)
return None
def get_chain_height(self):
try:
if self.rpc_client is None:
self.rpc_client = RpcClient(host=self.host, port=self.rpc_port)
self.rpc_client.session.headers.update(
{"Content-type": "application/json"})
height = self.rpc_client.get_block_number()
self.logger.debug("get height: %d, %s.", height, self.host)
return height
except Exception as e:
self.logger.debug("cannot get chain height yet, please retry. %s",
e)
return None
def deploy():
"""
Deploy contracts.
"""
contracts = utils.load_contracts(os.getcwd())
client = Client('127.0.0.1', '8545')
deployed_contracts = utils.deploy_contracts(client, contracts)
name_padding = max(len(n) + 1 for n in deployed_contracts.keys())
for name, info in deployed_contracts.items():
click.echo("{name} @ {addr} via txn:{txn_hash}".format(
name=name.ljust(name_padding),
addr=(info.get('addr') or '<pending>').ljust(42),
txn_hash=info['txn'].ljust(66),
))
def deploy_client(request, populus_config):
client_type = populus_config.get_value(request, 'deploy_client_type')
if client_type == 'ethtester':
from populus.ethtester_client import EthTesterClient
client = EthTesterClient()
elif client_type == 'rpc':
from eth_rpc_client import Client
rpc_host = populus_config.get_value(request, 'deploy_client_rpc_host')
rpc_port = populus_config.get_value(request, 'deploy_client_rpc_port')
client = Client(rpc_host, rpc_port)
else:
raise ValueError(
"Unsupported client type '{0}'. Supported values are 'tester' and "
"'rpc'")
return client
def get_block_hash_by_height(self, height):
try:
if self.rpc_client is None:
self.rpc_client = RpcClient(host=self.host, port=self.rpc_port)
self.rpc_client.session.headers.update(
{"Content-type": "application/json"})
block = self.rpc_client.get_block_by_number(height)
if block is None:
self.logger.error(
"Cannot find block with height: %d at host: %s", height,
self.host)
return None
return block["hash"]
except IOError as e:
self.logger.error("Cannot access RPC API from remote. %s", e)
return None
except Exception as e:
self.logger.error("Exception happens: %s", e)
return None
def test_running_node_and_mining(project_test04, open_port):
data_dir = get_geth_data_dir(project_test04, 'default')
command, proc = run_geth_node(data_dir, rpc_port=open_port, mine=True)
wait_for_popen(proc)
rpc_client = Client('127.0.0.1', port=open_port)
block_num = rpc_client.get_block_number()
start = time.time()
rpc_client.wait_for_block(block_num + 1, 60)
assert block_num < rpc_client.get_block_number()
proc.send_signal(signal.SIGINT)
wait_for_popen(proc)
def send_transaction(self,
to=None,
gas=None,
gas_price=None,
value=0,
data=None):
try:
if self.rpc_client is None:
self.rpc_client = RpcClient(host=self.host, port=self.rpc_port)
self.rpc_client.session.headers.update(
{"Content-type": "application/json"})
# send transaction
tx_hash = self.rpc_client.send_transaction(_from="0x{}".format(
self.coin_base),
to=to,
gas=gas,
gas_price=gas_price,
value=value,
data=data)
return tx_hash
except Exception as e:
self.logger.warn("send tx failed due to exception: %s", e)
return None
class Client(object):
def __init__(self,
host=None,
p2p_port=None,
rpc_port=None,
ws_port=None,
net_interface=None,
coin_base=None,
ssh_user=None,
ssh_pass=None,
ssh_key=None,
sudo_pass=None,
autonity_path=None,
bootnode_path=None,
role=None,
index=None,
e_node=None):
self.autonity_path = autonity_path
self.bootnode_path = bootnode_path
self.host = host
self.p2p_port = p2p_port
self.rpc_port = rpc_port
self.ws_port = ws_port
self.net_interface = net_interface
self.ssh_user = ssh_user
self.ssh_pass = ssh_pass
self.ssh_key = ssh_key
self.sudo_pass = sudo_pass
self.coin_base = coin_base
self.role = role
self.index = index
self.e_node = e_node
self.rpc_client = None
self.logger = log.get_logger()
self.disconnected_peers = []
self.client_stopped = False
self.up_link_delayed = False
self.down_link_delayed = False
self.is_local_address = False
def create_work_dir(self, data_dir):
work_dir = "{}/{}".format(data_dir, self.host)
utility.create_dir(work_dir)
def generate_new_account(self):
folder = self.host
utility.execute("echo 123 > ./network-data/{}/pass.txt".format(folder))
output = utility.execute(
'{} --datadir "./network-data/{}/data" --password "./network-data/{}/pass.txt" account new'
.format(self.autonity_path, folder, folder))
self.logger.debug(output)
m = re.findall(r'0x(.{40})', output[0], re.MULTILINE)
if len(m) == 0:
self.logger.error("Aborting - account creation failed")
return None
else:
self.coin_base = m[0]
return self.coin_base
def generate_enode(self):
folder = self.host
keystores_dir = "./network-data/{}/data/keystore".format(folder)
keystore_file_path = keystores_dir + "/" + os.listdir(keystores_dir)[0]
with open(keystore_file_path) as keyfile:
encrypted_key = keyfile.read()
account_private_key = w3.eth.account.decrypt(encrypted_key,
"123").hex()[2:]
with open("./network-data/{}/boot.key".format(folder), "w") as bootkey:
bootkey.write(account_private_key)
pub_key = \
utility.execute("{} -writeaddress -nodekey ./network-data/{}/boot.key".
format(self.bootnode_path, folder))[0].rstrip()
self.e_node = "enode://{}@{}:{}".format(pub_key, self.host,
self.p2p_port)
return self.e_node
def generate_system_service_file(self):
template_remote = "[Unit]\n" \
"Description=Clearmatics Autonity Client server\n" \
"After=syslog.target network.target\n" \
"[Service]\n" \
"Type=simple\n" \
"ExecStart={} --genesis {} --datadir {} --nodekey {} --syncmode 'full' --port {} " \
"--http.port {} --http --http.addr '0.0.0.0' --ws --wsport {} --rpccorsdomain '*' "\
"--rpcapi 'personal,debug,db,eth,net,web3,txpool,miner,tendermint,clique' --networkid 1991 " \
"--gasprice '0' --allow-insecure-unlock --graphql " \
"--unlock 0x{} --password {} " \
"--debug --mine --minerthreads '1' --etherbase 0x{} --verbosity 4 --miner.gaslimit 10000000000 --miner.gastarget 100000000000 --metrics --pprof \n" \
"KillMode=process\n" \
"KillSignal=SIGINT\n" \
"TimeoutStopSec=1\n" \
"Restart=on-failure\n" \
"RestartSec=1s\n" \
"[Install]\n" \
"Alias=autonity.service\n"\
"WantedBy=multi-user.target"
folder = self.host
print("prepare autonity systemd service file for node: %s", self.host)
bin_path = AUTONITY_PATH.format(self.ssh_user)
genesis_path = GENESIS_PATH.format(self.ssh_user)
data_dir = CHAIN_DATA_DIR.format(self.ssh_user, folder)
boot_key_file = BOOT_KEY_FILE.format(self.ssh_user, folder)
p2p_port = self.p2p_port
rpc_port = self.rpc_port
ws_port = self.ws_port
coin_base = self.coin_base
password_file = KEY_PASSPHRASE_FILE.format(self.ssh_user, folder)
content = template_remote.format(bin_path, genesis_path, data_dir,
boot_key_file, p2p_port, rpc_port,
ws_port, coin_base, password_file,
coin_base)
with open("./network-data/{}/autonity.service".format(folder),
'w') as out:
out.write(content)
def generate_package(self):
folder = self.host
utility.execute('cp {} ./network-data/'.format(self.autonity_path))
utility.execute(
'tar -zcvf ./network-data/{}.tgz ./network-data/{}/ ./network-data/genesis.json ./network-data/autonity'
.format(folder, folder))
def deliver_package(self):
try:
with Connection(
self.host,
user=self.ssh_user,
connect_kwargs={
#"key_filename": self.ssh_key,
"password": self.ssh_pass
}) as c:
sudopass = Responder(pattern=r'\[sudo\] password for ' +
self.ssh_user + ':',
response=self.sudo_pass + '\n')
c.put(PACKAGE_NAME.format(self.host),
REMOTE_NAME.format(self.ssh_user, self.host))
self.logger.info('Chain package was uploaded to %s.',
self.host)
result = c.run('sudo tar -C /home/{} -zxvf {}'.format(
self.ssh_user, REMOTE_NAME.format(self.ssh_user,
self.host)),
pty=True,
watchers=[sudopass],
warn=True,
hide=True)
if result and result.exited == 0 and result.ok:
self.logger.info('Chain package was unpacked to %s.',
self.host)
return True
else:
self.logger.error('chain package fail to unpacked to %s.',
self.host)
except Exception as e:
self.logger.error("cannot deliver package to host. %s, %s",
self.host, e)
return False
def load_systemd_file(self):
try:
with Connection(
self.host,
user=self.ssh_user,
connect_kwargs={
#"key_filename": self.ssh_key,
"password": self.ssh_pass
}) as c:
sudopass = Responder(pattern=r'\[sudo\] password for ' +
self.ssh_user + ':',
response=self.sudo_pass + '\n')
src = '/home/{}/network-data/{}/autonity.service'.format(
self.ssh_user, self.host)
result = c.run('sudo cp {} {}'.format(src, SYSTEM_SERVICE_DIR),
pty=True,
watchers=[sudopass],
warn=True,
hide=True)
if result and result.exited == 0 and result.ok:
self.logger.info('system service loaded. %s', self.host)
else:
self.logger.error('systemd file loading failed. %s',
self.host)
except Exception as e:
self.logger.error("cannot load systemd file. %s, %s", self.host, e)
def start_client(self):
try:
with Connection(
self.host,
user=self.ssh_user,
connect_kwargs={
#"key_filename": self.ssh_key,
"password": self.ssh_pass
}) as c:
sudopass = Responder(pattern=r'\[sudo\] password for ' +
self.ssh_user + ':',
response=self.sudo_pass + '\n')
#cmd = self.generate_start_cmd()
cmd = SYSTEMD_START_CLIENT
result = c.run(cmd,
pty=True,
watchers=[sudopass],
warn=True,
hide=True)
if result and result.exited == 0 and result.ok:
self.logger.info('system service started. %s', self.host)
self.client_stopped = False
return True
else:
self.logger.error('systemd service starting failed. %s',
self.host)
except Exception as e:
self.logger.error("cannot start service. %s, %s.", self.host, e)
return False
def deploy_client(self):
self.deliver_package()
self.load_systemd_file()
def stop_client(self):
try:
with Connection(
self.host,
user=self.ssh_user,
connect_kwargs={
#"key_filename": self.ssh_key,
"password": self.ssh_pass
}) as c:
sudopass = Responder(pattern=r'\[sudo\] password for ' +
self.ssh_user + ':',
response=self.sudo_pass + '\n')
#cmd = self.generate_stop_cmd()
cmd = SYSTEMD_STOP_CLIENT
result = c.run(cmd,
pty=True,
watchers=[sudopass],
warn=True,
hide=True)
if result and result.exited == 0 and result.ok:
self.logger.info('system service stopped. %s', self.host)
self.client_stopped = True
return True
else:
self.logger.error('system service stopping failed. %s',
self.host)
except Exception as e:
self.logger.error("cannot stop client, %s, %s", self.host, e)
return False
def clean_chain_data(self):
try:
with Connection(
self.host,
user=self.ssh_user,
connect_kwargs={
#"key_filename": self.ssh_key,
"password": self.ssh_pass
}) as c:
sudopass = Responder(pattern=r'\[sudo\] password for ' +
self.ssh_user + ':',
response=self.sudo_pass + '\n')
result = c.run('sudo rm -rf {}'.format(
DEPLOYMENT_DIR.format(self.ssh_user)),
pty=True,
watchers=[sudopass],
warn=True,
hide=True)
if result and result.exited == 0 and result.ok:
self.logger.info('chain data cleaned. %s', self.host)
else:
self.logger.error('chain data cleaning failed. %s',
self.host)
except Exception as e:
self.logger.error("cannot clean chain data. %s, %s.", self.host, e)
return False
return True
def redirect_system_log(self, log_folder):
try:
zip_file = "{}/{}.tgz".format(log_folder, self.host)
log_file = "{}/{}.log".format(log_folder, self.host)
# untar file,
utility.execute("tar -zxvf {} --directory {}".format(
zip_file, log_folder))
# read file and print into log file.
self.logger.info(
"\t\t\t **** node_%s logs started from here. **** \n\n\n",
self.host)
with open(log_file, "r", encoding="utf-8") as fp:
for _, line in enumerate(fp):
self.logger.info("NODE_%s_%s: %s", self.index, self.host,
line.encode("utf-8"))
# remove file.
utility.execute("rm -f {}".format(log_file))
except Exception as e:
self.logger.error('Exception happens. %s', e)
def collect_system_log(self, log_folder):
try:
with Connection(
self.host,
user=self.ssh_user,
connect_kwargs={
#"key_filename": self.ssh_key,
"password": self.ssh_pass,
}) as c:
sudopass = Responder(pattern=r'\[sudo\] password for ' +
self.ssh_user + ':',
response=self.sudo_pass + '\n')
# dump log at remote node.
file_name = "./{}.log".format(self.host)
cmd = 'sudo journalctl -u autonity.service -b > {}'.format(
file_name)
result = c.run(cmd,
pty=True,
watchers=[sudopass],
warn=True,
hide=True)
if result and result.exited == 0 and result.ok:
self.logger.info('log was dump on host: %s', self.host)
# tar logs for remote node.
tar_file = "./{}.log.tgz".format(self.host)
cmd = "sudo tar -zcvf {} {}".format(tar_file, file_name)
result = c.run(cmd,
pty=True,
watchers=[sudopass],
warn=True,
hide=True)
if result and result.exited == 0 and result.ok:
self.logger.info('log was zip on host: %s', self.host)
# download logs.
local_dir = log_folder
local_file = "{}/{}.tgz".format(local_dir, self.host)
c.get(tar_file, local=local_file)
self.logger.info('log files was saved to %s.',
local_dir)
else:
self.logger.error('cannot zip log file at host: %s',
self.host)
else:
self.logger.error(
'Cannot dump logs from autonity.service. %s',
self.host)
except (KeyError, TypeError) as e:
self.logger.error('wrong configuration file. %s', e)
except Exception as e:
self.logger.error('Exception happens. %s', e)
def send_transaction(self,
to=None,
gas=None,
gas_price=None,
value=0,
data=None):
try:
if self.rpc_client is None:
self.rpc_client = RpcClient(host=self.host, port=self.rpc_port)
self.rpc_client.session.headers.update(
{"Content-type": "application/json"})
# send transaction
tx_hash = self.rpc_client.send_transaction(_from="0x{}".format(
self.coin_base),
to=to,
gas=gas,
gas_price=gas_price,
value=value,
data=data)
return tx_hash
except Exception as e:
self.logger.warn("send tx failed due to exception: %s", e)
return None
def get_balance(self):
try:
if self.rpc_client is None:
self.rpc_client = RpcClient(host=self.host, port=self.rpc_port)
self.rpc_client.session.headers.update(
{"Content-type": "application/json"})
balance = self.rpc_client.get_balance("0x{}".format(
self.coin_base))
return balance
except Exception as e:
self.logger.error("Cannot get balance due to exception. %s", e)
return None
def get_block_hash_by_height(self, height):
try:
if self.rpc_client is None:
self.rpc_client = RpcClient(host=self.host, port=self.rpc_port)
self.rpc_client.session.headers.update(
{"Content-type": "application/json"})
block = self.rpc_client.get_block_by_number(height)
if block is None:
self.logger.error(
"Cannot find block with height: %d at host: %s", height,
self.host)
return None
return block["hash"]
except IOError as e:
self.logger.error("Cannot access RPC API from remote. %s", e)
return None
except Exception as e:
self.logger.error("Exception happens: %s", e)
return None
def get_transaction_by_hash(self, hash):
try:
if self.rpc_client is None:
self.rpc_client = RpcClient(host=self.host, port=self.rpc_port)
self.rpc_client.session.headers.update(
{"Content-type": "application/json"})
result = self.rpc_client.get_transaction_by_hash(hash)
return result
except Exception as e:
self.logger.error("Cannot get balance due to exception. %s", e)
return None
def get_chain_height(self):
try:
if self.rpc_client is None:
self.rpc_client = RpcClient(host=self.host, port=self.rpc_port)
self.rpc_client.session.headers.update(
{"Content-type": "application/json"})
height = self.rpc_client.get_block_number()
self.logger.debug("get height: %d, %s.", height, self.host)
return height
except Exception as e:
self.logger.debug("cannot get chain height yet, please retry. %s",
e)
return None
def execute_ssh_cmd(self, cmd):
self.logger.debug("ssh cmd: %s ", cmd)
try:
with Connection(
self.host,
user=self.ssh_user,
connect_kwargs={
#"key_filename": self.ssh_key,
"password": self.ssh_pass,
}) as c:
sudopass = Responder(pattern=r'\[sudo\] password for ' +
self.ssh_user + ':',
response=self.sudo_pass + '\n')
result = c.run(cmd,
pty=True,
watchers=[sudopass],
warn=True,
hide=True)
if result and result.exited == 0 and result.ok:
self.logger.debug('SSH executed fine. %s for node: %s',
cmd, self.host)
return True
else:
self.logger.debug('%s', result)
return result.stdout.strip()
except IOError as e:
self.logger.error("Cannot connect to node: %s via network. %s",
self.host, e)
return None
except ValueError as e:
self.logger.error("Wrong parameter for fabric lib. %s", e)
return None
except Exception as e:
self.logger.error('Command get exception: %s', e)
return None
def is_peer_disconnected(self, host, port):
cmd = IS_PEER_ALREADY_DISCONNECTED.format(host)
is_disconnected = self.execute_ssh_cmd(cmd)
if is_disconnected is True:
return True
return False
def connect_peer(self, host, port):
if self.is_peer_disconnected(host, port) is False:
return True
# connect_peer
cmd = CONNECT_PEER.format(host)
if self.execute_ssh_cmd(cmd) is not True:
return False
peer = "{}:{}".format(host, port)
if peer in self.disconnected_peers:
self.logger.info("peer connected: %s to %s", self.host, host)
self.disconnected_peers.remove(peer)
return True
def dis_connect_peer(self, host, port):
if self.is_peer_disconnected(host, port):
return True
cmd = DISCONNECT_PEER.format(host)
if self.execute_ssh_cmd(cmd) is not True:
return False
peer = "{}:{}".format(host, port)
if peer not in self.disconnected_peers:
self.logger.info("peer disconnected: %s to %s", self.host, host)
self.disconnected_peers.append(peer)
return True
def set_up_link_delay(self, up_link_delay_meta):
try:
delay = \
DEFAULT_DELAY if up_link_delay_meta['delay'] is None else up_link_delay_meta['delay']
loss_rate = \
DEFAULT_PACKAGE_LOSS_RATE if up_link_delay_meta['lossRate'] is None else up_link_delay_meta['lossRate']
duplicate_rate = \
DEFAULT_PACKAGE_DUPLICATE_RATE \
if up_link_delay_meta['duplicateRate'] is None else up_link_delay_meta['duplicateRate']
reorder_rate = \
DEFAULT_PACKAGE_REORDER_RATE \
if up_link_delay_meta['reorderRate'] is None else up_link_delay_meta['reorderRate']
corrupt_rate = \
DEFAULT_PACKAGE_CORRUPT_RATE \
if up_link_delay_meta['corruptRate'] is None else up_link_delay_meta['corruptRate']
# to do checking parameters before formatting command.
delay = delay if isinstance(delay, (
int, float)) and not isinstance(delay, bool) else DEFAULT_DELAY
loss_rate = loss_rate \
if isinstance(loss_rate, (int, float)) and not isinstance(loss_rate, bool) \
else DEFAULT_PACKAGE_LOSS_RATE
duplicate_rate = duplicate_rate if isinstance(duplicate_rate, (int, float)) \
and not isinstance(duplicate_rate, bool) else DEFAULT_PACKAGE_DUPLICATE_RATE
reorder_rate = reorder_rate \
if isinstance(reorder_rate, (int, float)) and not isinstance(reorder_rate, bool)\
else DEFAULT_PACKAGE_REORDER_RATE
corrupt_rate = corrupt_rate \
if isinstance(corrupt_rate, (int, float)) and not isinstance(corrupt_rate, bool)\
else DEFAULT_PACKAGE_CORRUPT_RATE
ether_id = self.net_interface
if ether_id is None:
self.logger.error('Cannot find host ethernet interface id.')
return None
# to do formatting shell command.
command = SSH_DELAY_TX_COMMAND.format(ether_id, delay, loss_rate,
duplicate_rate, reorder_rate,
corrupt_rate)
result = self.execute_ssh_cmd(command)
if result is True:
self.up_link_delayed = True
self.logger.info(
"network traffic control rule applied to host: %s",
self.host)
else:
self.logger.error('SSH ERR: %s', result)
return None
except (KeyError, TypeError) as e:
self.logger.error('Wrong configuration. %s', e)
return None
except Exception as e:
self.logger.error('Exception happens: %s', e)
return None
return True
def cancel_up_link_delay(self):
try:
ether_id = self.net_interface
if ether_id is None:
self.logger.error('Cannot find host ethernet interface id.')
return None
command = SSH_UN_DELAY_TX_COMMAND.format(ether_id)
result = self.execute_ssh_cmd(command)
if result is True:
self.logger.info(
"network traffic control rule canceled to host: %s",
self.host)
self.up_link_delayed = False
else:
self.logger.error(
'undelay up-link failed for host: %s, error: %s',
self.host, result)
return None
except (KeyError, TypeError) as e:
self.logger.error('wrong configuration. %s', e)
return None
except Exception as e:
self.logger.error('Exception happens: %s', e)
return None
self.logger.info('SSH command execute fine. %s', command)
return True
def set_down_link_delay(self, down_link_delay_meta):
# since docker is a LXC base container solution, it does not involved the kernel module
# which our TC (traffic control) depends on to simulate the traffic delays, so
# we remove this from docker based testbed, while in VM based testing, TC is
# still valid.
return True
try:
delay = \
DEFAULT_DELAY if down_link_delay_meta['delay'] is None else down_link_delay_meta['delay']
loss_rate = \
DEFAULT_PACKAGE_LOSS_RATE if down_link_delay_meta['lossRate'] \
is None else down_link_delay_meta['lossRate']
duplicate_rate = \
DEFAULT_PACKAGE_DUPLICATE_RATE \
if down_link_delay_meta['duplicateRate'] is None else down_link_delay_meta['duplicateRate']
reorder_rate = \
DEFAULT_PACKAGE_REORDER_RATE \
if down_link_delay_meta['reorderRate'] is None else down_link_delay_meta['reorderRate']
corrupt_rate = \
DEFAULT_PACKAGE_CORRUPT_RATE \
if down_link_delay_meta['corruptRate'] is None else down_link_delay_meta['corruptRate']
# to do checking parameters before formatting command.
delay = delay if isinstance(delay, (
int, float)) and not isinstance(delay, bool) else DEFAULT_DELAY
loss_rate = loss_rate \
if isinstance(loss_rate, (int, float)) and not isinstance(loss_rate, bool) \
else DEFAULT_PACKAGE_LOSS_RATE
duplicate_rate = duplicate_rate if isinstance(duplicate_rate, (int, float)) \
and not isinstance(duplicate_rate, bool) else DEFAULT_PACKAGE_DUPLICATE_RATE
reorder_rate = reorder_rate \
if isinstance(reorder_rate, (int, float)) and not isinstance(reorder_rate, bool)\
else DEFAULT_PACKAGE_REORDER_RATE
corrupt_rate = corrupt_rate \
if isinstance(corrupt_rate, (int, float)) and not isinstance(corrupt_rate, bool)\
else DEFAULT_PACKAGE_CORRUPT_RATE
# get ip from host name.
ether_id = self.net_interface
if ether_id is None:
self.logger.error('cannot get ethernet interface id')
return None
# step 1, create virtual network interface.
result = \
self.execute_ssh_cmd(SSH_CREATE_IFB_MODULE)
if result is not True:
self.logger.error(
'create virtual network interface failed. %s', result)
return None
# step 2, start up virtual network interface.
result = self.execute_ssh_cmd(SSH_UP_IFB_DEVICE_INTERFACE)
if result is not True:
self.logger.error(
'start up virtual network interface failed. %s', result)
return None
# step 3, add in-coming queue to network interface.
command = SSH_ADD_INCOMING_QUEUE_4_PUB_INTERFACE.format(ether_id)
result = self.execute_ssh_cmd(command)
if result is not True:
self.logger.error('create redirect stream failed. %s', result)
return None
# step 4, redirect in-coming stream into virtual network interface.
command = SSH_REDIRECT_STREAM_TO_IFB.format(ether_id)
result = self.execute_ssh_cmd(command)
if result is not True:
self.logger.error(
'redirect in-coming stream into virtual network interface failed. %s',
result)
return None
# step 5, apply delay in in-coming stream.
command = SSH_DELAY_RX_COMMAND.format(delay, loss_rate,
duplicate_rate, reorder_rate,
corrupt_rate)
result = self.execute_ssh_cmd(command)
if result is True:
self.down_link_delayed = True
else:
self.logger.error('SSH ERR: %s', result)
return None
except (KeyError, TypeError) as e:
self.logger.error('Wrong configuration. %s', e)
return None
except Exception as e:
self.logger.error('Exception happens: %s', e)
return None
return True
def cancel_down_link_delay(self):
# since docker is a LXC base container solution, it does not involved the kernel module
# which our TC (traffic control) depends on to simulate the traffic delays, so
# we remove this from docker based testbed, while in VM based testing, TC is
# still valid.
return True
try:
ether_id = self.net_interface
if ether_id is None:
self.logger.error('Cannot find host ethernet interface id.')
return None
# step 1, un-apply delay on in-coming data stream.
result = self.execute_ssh_cmd(SSH_UN_DELAY_RX_COMMAND)
if result is not True:
self.logger.error(
'un-apply delay on in-coming data stream failed. %s',
result)
# step 2, recycle the redirection stream.
command = SSH_DELETE_INCOMING_QUEUE_4_PUB_INTERFACE.format(
ether_id)
result = self.execute_ssh_cmd(command)
if result is True:
self.down_link_delayed = False
else:
self.logger.error(
'undelay up-link failed for host: %s, error: %s',
self.host, result)
return None
except (KeyError, TypeError) as e:
self.logger.error('wrong configuration. %s', e)
return None
except Exception as e:
self.logger.error('Exception happens: %s', e)
return None
self.logger.info('SSH command executed fine. %s', command)
return True
def heal_from_disaster(self):
failed = False
if self.client_stopped:
if self.start_client() is not True:
failed = True
disconnected_peers = copy.deepcopy(self.disconnected_peers)
if len(disconnected_peers) > 0:
for peer in disconnected_peers:
endpoint = peer.split(":")
if self.connect_peer(endpoint[0], endpoint[1]) is not True:
failed = True
if self.up_link_delayed:
if self.cancel_up_link_delay() is not True:
failed = True
if self.down_link_delayed:
if self.cancel_down_link_delay() is not True:
failed = True
return True if not failed else False
def rpc_client(request, populus_config):
from eth_rpc_client import Client
rpc_port = populus_config.get_value(request, 'rpc_client_port')
rpc_hostname = populus_config.get_value(request, 'rpc_client_host')
client = Client(rpc_hostname, rpc_port)
return client
def __init__(self, rpc_port):
self.rpc_ip = '127.0.0.1'
self.rpc_port = rpc_port
self.rpc_eth = Client(self.rpc_ip, self.rpc_port)
def test_get_coinbase(rpc_server):
client = Client('127.0.0.1', '8545')
cb = client.get_coinbase()
assert cb == '0x82a978b3f5962a5b0957d9ee9eef472ee55b42f1'
def test_get_balance(rpc_server, eth_coinbase):
client = Client('127.0.0.1', '8545')
balance = client.get_balance(eth_coinbase)
assert balance == 1000000000000000000000000L
def test_get_code(rpc_server):
client = Client('127.0.0.1', '8545')
max_gas = client.get_max_gas()
assert max_gas > 0
def rpc_client():
from eth_rpc_client import Client
client = Client('127.0.0.1', '8545')
return client
sys.path += ['.', '..', 'tools', '../populus']
from overlog import ovlg, ovlocal
import overlog
import contract as mycon
from populus import contracts as pocon
from eth_rpc_client import Client
overlog.SELECTED_GROUPS = ['overlog']
class Dummy(object):
pass
eth = Client(*mycon.RpcHost)
ci = mycon.MainStore.last_ci_named(mycon.ConName)
co_cls = pocon.Contract(eth, ci.name, {
'info': {
'abiDefinition': ci.abi,
'source': ''
},
'code': ci.code
})
# contract obj
cobj = co_cls(ci.addr)
eth.accounts = eth.get_accounts()
eth.defaults['from'] = eth.accounts[0]
from eth_alarm_client import (
BlockSage,
PoolManager,
Scheduler,
)
alarm_addresses = (
('0.1.0', '0xb0059e72ae1802fa1e1add5e7d0cb0eec1cc0cc1'),
('0.2.0', '0xc1cfa6ac1d7cf99bd1e145dcd04ec462b3b0c4da'),
('0.3.0', '0xdb15058402c241b04a03846f6fb104b1fbeea10b'),
('0.4.0 (latest)', '0x07307d0b136a79bac718f43388aed706389c4588'),
)
DEFAULT_ADDRESS = '0x07307d0b136a79bac718f43388aed706389c4588'
rpc_client = Client('127.0.0.1', '8545')
def get_contract(contract_name):
with open(os.path.join(os.path.dirname(__file__),
'alarm.json')) as contract_json:
contracts = json.loads(contract_json.read())
return Contract(contracts[contract_name], contract_name)
@click.group()
def main():
pass
@main.command()
def repeat_all_messages(message): # Название функции не играет никакой роли, важно не повторяться
client = Client(host="ubuntu.athex.ru", port="8545")
bot.send_message(message.chat.id, client.get_balance(client.get_coinbase()))
Scheduler,
)
DEFAULT_ADDRESS = '0x321a1e5e0ef137f37eeb5563c987d60ab9dcd8de'
alarm_addresses = (
('0.1.0', '0xb0059e72ae1802fa1e1add5e7d0cb0eec1cc0cc1'),
('0.2.0', '0xc1cfa6ac1d7cf99bd1e145dcd04ec462b3b0c4da'),
('0.3.0', '0xdb15058402c241b04a03846f6fb104b1fbeea10b'),
('0.4.0', '0x07307d0b136a79bac718f43388aed706389c4588'),
('0.5.0 (latest)', DEFAULT_ADDRESS),
)
rpc_client = Client('127.0.0.1', '8545')
def get_contract(contract_name):
with open(os.path.join(os.path.dirname(__file__), 'alarm.json')) as contract_json:
contracts = json.loads(contract_json.read())
return Contract(contracts[contract_name], contract_name)
@click.group()
def main():
pass
@main.command()
def addresses():
sys.path += ['.', '..', 'tools', '../populus']
from overlog import ovlg, ovlocal
import overlog
import contract as mycon
from populus import contracts as pocon
from eth_rpc_client import Client
overlog.SELECTED_GROUPS = ['overlog']
class Dummy(object):
pass
eth = Client(*mycon.RpcHost)
ci = mycon.MainStore.last_ci_named(mycon.ConName)
co_cls = pocon.Contract(eth, ci.name, {
'info': {
'abiDefinition': ci.abi,
'source': ''
},
'code': ci.code
})
# contract obj
cobj = co_cls(ci.addr)
eth.accounts = eth.get_accounts()
eth.defaults['from'] = eth.accounts[0]
def attach(active):
"""
Enter a python shell with contracts and blockchain client
available.
"""
project_dir = os.path.abspath(os.getcwd())
contracts_meta = utils.load_contracts(project_dir)
client = Client('127.0.0.1', '8545')
context = {
'contracts': package_contracts(contracts_meta),
'client': client,
}
data_dir = None
if active:
data_dir = get_active_data_dir(project_dir)
if os.path.islink(data_dir):
setup_known_instances(context, data_dir)
else:
click.echo(
click.style("No Valid Active Chain Data Directory Found!",
fg="red"))
def redeploy(contracts=[], record=True):
return (deploy_set(context,
client,
project_dir,
data_dir=data_dir,
record=record,
contracts_by_name=contracts))
context["redeploy"] = redeploy
contract_names = ', '.join(sorted(contracts_meta.keys()))
banner = textwrap.dedent("""
Python: {python_version}
Populus: v{populus_version}
Project Path: {project_dir}
contracts -> Contract classes
client -> Blockchain client ({client_type})
redeploy -> Method to re-deploy project contracts
Example:
deployed_cts = redeploy()
deployed_cts = redeploy(record = False)
deployed_cts = redeploy(contracts = ["Example"])
Contracts: {contracts}
Check contracts.<type>.known for deployed contracts.
""").format(
python_version=sys.version.partition('\n')[0],
populus_version=populus.__version__,
project_dir=project_dir,
client_type="json-rpc",
contracts=click.wrap_text(
contract_names,
initial_indent='',
subsequent_indent=' ' * 4,
),
).strip()
if is_ipython:
shell = InteractiveConsole(user_ns=context)
else:
shell = InteractiveConsole(context)
# Start the active directory link observer
event_handler = ActiveDataDirChangedEventHandler(
project_dir=project_dir,
context=context,
)
observer = get_active_dir_observer(project_dir, event_handler)
observer.start()
shell.interact(banner)
observer.stop()
observer.join()
