def __enter__( self ):
self._cread_lock.acquire()
# Setup temp directory to use as the data directory for this
self._temp_data_dir = TemporaryDirectory()
for child in self._data_dir.iterdir():
if( child.is_dir() ):
copytree( str( child ), str( self._temp_data_dir.name ) + '/' + child.name )
db_version = Path( self._data_dir.name ) / 'db_version'
if( db_version.exists() and not db_version.is_dir() ):
copy2( str( db_version ), str( self._temp_data_dir.name ) + '/db_version' )
config = Path( self._temp_data_dir.name ) / 'config.ini'
config.touch()
config.write_text( self._get_config() )
cread = [ str( self._cread_bin ), '--data-dir=' + str( self._temp_data_dir.name ) ]
cread.extend( self._args )
self._cread_process = Popen( cread, stdout=self.cread_out, stderr=self.cread_err )
self._cread_process.poll()
sleep( 5 )
if( not self._cread_process.returncode ):
self._rpc = CreaNodeRPC( 'ws://127.0.0.1:8095', '', '' )
else:
raise Exception( "cread did not start properly..." )
def test_connect_test_str_list2(self):
str_list = ""
for node in self.nodes:
str_list += node + ","
str_list = str_list[:-1]
rpc = CreaNodeRPC(urls=str_list)
self.assertIn(rpc.url, self.nodes + self.nodes_creait)
rpc.next()
self.assertIn(rpc.url, self.nodes + self.nodes_creait)
def run_cread_tests(debug_node):
from creaapi.creanoderpc import CreaNodeRPC
try:
print('Replaying blocks...', )
sys.stdout.flush()
total_blocks = 0
while (total_blocks % 100000 == 0):
total_blocks += debug_node.debug_push_blocks(
100000, skip_validate_invariants=True)
print('Blocks Replayed: ' + str(total_blocks))
sys.stdout.flush()
print("Triggering payouts")
sys.stdout.flush()
debug_node.debug_generate_blocks_until(1467590400 - 3)
rpc = CreaNodeRPC('ws://127.0.0.1:8095', '', '')
ret = rpc.lookup_accounts('', str(0xFFFFFFFF))
debug_node.debug_generate_blocks(1)
print("Generating blocks to verify nothing broke")
assert (debug_node.debug_generate_blocks(10) == 10)
account_rewards = {}
vote_count = {}
for acc_name in ret:
acc = rpc.get_accounts([acc_name])
#print( acc_name + ',' + acc[0][ 'curation_rewards' ] )
account_rewards[acc_name] = float(
acc[0]['curation_rewards'].split(' ')[0])
vote_count[acc_name] = int(acc[0]['lifetime_vote_count'])
'''
print( "Done!" )
print( "Getting comment dump:" )
sys.stdout.flush()
ret = rpc.get_discussions_by_cashout_time( '', '', str( 0xFFFFFFFF ) );
print( 'author, url, total_payout_value, abs_rshares, num_active_votes' )
for comment in ret:
print( comment[ 'author' ] + ', ' + comment[ 'url' ] + ', ' + comment[ 'total_payout_value' ] + ', ' + comment[ 'cashout_time' ] )
'''
print("Printing account reward dump:")
sorted_rewards = sorted(account_rewards.items(),
key=operator.itemgetter(1))
print("account, curation_crea")
for rew in sorted_rewards:
print(rew[0] + ', ' + str(rew[1]) + ', ' + str(vote_count[rew[0]]))
except ValueError as val_err:
print(str(val_err))
def test_num_retries(self):
with self.assertRaises(NumRetriesReached):
CreaNodeRPC(urls="https://wrong.link.com",
num_retries=2,
timeout=1)
with self.assertRaises(NumRetriesReached):
CreaNodeRPC(urls="https://wrong.link.com",
num_retries=3,
num_retries_call=3,
timeout=1)
nodes = [
"https://httpstat.us/500", "https://httpstat.us/501",
"https://httpstat.us/502", "https://httpstat.us/503",
"https://httpstat.us/505", "https://httpstat.us/511",
"https://httpstat.us/520", "https://httpstat.us/522",
"https://httpstat.us/524"
]
with self.assertRaises(NumRetriesReached):
CreaNodeRPC(urls=nodes,
num_retries=0,
num_retries_call=0,
timeout=1)
def test_error_handling_appbase(self):
rpc = CreaNodeRPC(urls=self.nodes_creait,
num_retries=2,
num_retries_call=3)
with self.assertRaises(exceptions.NoMethodWithName):
rpc.get_wrong_command()
with self.assertRaises(exceptions.NoApiWithName):
rpc.get_block({"block_num": 1}, api="wrong_api")
def test_error_handling(self):
rpc = CreaNodeRPC(urls=self.nodes_creait,
num_retries=2,
num_retries_call=3)
with self.assertRaises(exceptions.NoMethodWithName):
rpc.get_wrong_command()
with self.assertRaises(exceptions.UnhandledRPCError):
rpc.get_accounts("test")
def setUpClass(cls):
nodelist = NodeList()
nodelist.update_nodes(crea_instance=Crea(
node=nodelist.get_nodes(normal=True, appbase=True), num_retries=3))
cls.nodes = nodelist.get_nodes()
if "https://nodes.creary.net" in cls.nodes:
cls.nodes.remove("https://nodes.creary.net")
cls.nodes_creait = ["https://nodes.creary.net"]
cls.appbase = Crea(node=cls.nodes,
nobroadcast=True,
keys={
"active": wif,
"owner": wif,
"memo": wif
},
num_retries=10)
cls.rpc = CreaNodeRPC(urls=cls.nodes_creait)
# from getpass import getpass
# self.bts.wallet.unlock(getpass())
set_shared_crea_instance(cls.nodes_creait)
cls.appbase.set_default_account("test")
class DebugNode( object ):
""" Wraps the cread debug node plugin for easier automated testing of the Crea Network"""
def __init__( self, cread, data_dir, args='', plugins=[], apis=[], cread_out=None, cread_err=None ):
""" Creates a cread debug node.
It can be ran by using 'with debug_node:'
While in the context of 'with' the debug node will continue to run.
Upon exit of 'with' the debug will exit and clean up temporary files.
This class also contains methods to allow basic manipulation of the blockchain.
For all other requests, the python-crea library should be used.
args:
cread -- The string path to the location of the cread binary
data_dir -- The string path to an existing cread data directory which will be used to pull blocks from.
args -- Other string args to pass to cread.
plugins -- Any additional plugins to start with the debug node. Modify plugins DebugNode.plugins
apis -- Any additional APIs to have available. APIs will retain this order for accesibility starting at id 3.
database_api is 0, login_api is 1, and debug_node_api is 2. Modify apis with DebugNode.api
cread_stdout -- A stream for cread's stdout. Default is to pipe to /dev/null
cread_stderr -- A stream for cread's stderr. Default is to pipe to /dev/null
"""
self._data_dir = None
self._debug_key = None
self._FNULL = None
self._rpc = None
self._cread_bin = None
self._cread_lock = None
self._cread_process = None
self._temp_data_dir = None
self._cread_bin = Path( cread )
if( not self._cread_bin.exists() ):
raise ValueError( 'cread does not exist' )
if( not self._cread_bin.is_file() ):
raise ValueError( 'cread is not a file' )
self._data_dir = Path( data_dir )
if( not self._data_dir.exists() ):
raise ValueError( 'data_dir either does not exist or is not a properly constructed crea data directory' )
if( not self._data_dir.is_dir() ):
raise ValueError( 'data_dir is not a directory' )
self.plugins = plugins
self.apis = apis
if( args != '' ):
self._args = args.split( "\\s" )
else:
self._args = list()
self._FNULL = open( devnull, 'w' )
if( cread_out != None ):
self.cread_out = cread_out
else:
self.cread_out = self._FNULL
if( cread_err != None ):
self.cread_err = cread_err
else:
self.cread_err = self._FNULL
self._debug_key = '5JHNbFNDg834SFj8CMArV6YW7td4zrPzXveqTfaShmYVuYNeK69'
self._cread_lock = Lock()
def __enter__( self ):
self._cread_lock.acquire()
# Setup temp directory to use as the data directory for this
self._temp_data_dir = TemporaryDirectory()
for child in self._data_dir.iterdir():
if( child.is_dir() ):
copytree( str( child ), str( self._temp_data_dir.name ) + '/' + child.name )
db_version = Path( self._data_dir.name ) / 'db_version'
if( db_version.exists() and not db_version.is_dir() ):
copy2( str( db_version ), str( self._temp_data_dir.name ) + '/db_version' )
config = Path( self._temp_data_dir.name ) / 'config.ini'
config.touch()
config.write_text( self._get_config() )
cread = [ str( self._cread_bin ), '--data-dir=' + str( self._temp_data_dir.name ) ]
cread.extend( self._args )
self._cread_process = Popen( cread, stdout=self.cread_out, stderr=self.cread_err )
self._cread_process.poll()
sleep( 5 )
if( not self._cread_process.returncode ):
self._rpc = CreaNodeRPC( 'ws://127.0.0.1:8095', '', '' )
else:
raise Exception( "cread did not start properly..." )
def __exit__( self, exc, value, tb ):
self._rpc = None
if( self._cread_process != None ):
self._cread_process.poll()
if( not self._cread_process.returncode ):
self._cread_process.send_signal( SIGINT )
sleep( 7 )
self._cread_process.poll()
if( not self._cread_process.returncode ):
self._cread_process.send_signal( SIGTERM )
sleep( 5 )
self._cread_process.poll()
if( self._cread_process.returncode ):
loggin.error( 'cread did not properly shut down after SIGINT and SIGTERM. User intervention may be required.' )
self._cread_process = None
self._temp_data_dir.cleanup()
self._temp_data_dir = None
self._cread_lock.release()
def _get_config( self ):
return "# no seed-node in config file or command line\n" \
+ "p2p-endpoint = 127.0.0.1:1776 # bind to localhost to prevent remote p2p nodes from connecting to us\n" \
+ "rpc-endpoint = 127.0.0.1:8095 # bind to localhost to secure RPC API access\n" \
+ "enable-plugin = witness debug_node " + " ".join( self.plugins ) + "\n" \
+ "public-api = database_api login_api debug_node_api " + " ".join( self.apis ) + "\n"
def debug_generate_blocks( self, count ):
"""
Generate blocks on the current chain. Pending transactions will be applied, otherwise the
blocks will be empty.
The debug node plugin requires a WIF key to sign blocks with. This class uses the key
5JHNbFNDg834SFj8CMArV6YW7td4zrPzXveqTfaShmYVuYNeK69 which was generated from
`get_dev_key crea debug`. Do not use this key on the live chain for any reason.
args:
count -- The number of new blocks to generate.
returns:
int: The number of blocks actually pushed.
"""
if( count < 0 ):
raise ValueError( "count must be a positive non-zero number" )
return self._rpc.rpcexec( json.loads( '{"jsonrpc": "2.0", "method": "call", "params": [2,"debug_generate_blocks",["' + self._debug_key + '",' + str( count ) + ']], "id": 1}' ) )
def debug_generate_blocks_until( self, timestamp, generate_sparsely=True ):
"""
Generate block up until a head block time rather than a specific number of blocks. As with
`debug_generate_blocks` all blocks will be empty unless there were pending transactions.
The debug node plugin requires a WIF key to sign blocks with. This class uses the key
5JHNbFNDg834SFj8CMArV6YW7td4zrPzXveqTfaShmYVuYNeK69 which was generated from
`get_dev_key crea debug`. Do not use this key on the live chain for any reason.
args:
time -- The desired new head block time. This is a POSIX Timestmap.
generate_sparsely -- True if you wish to skip all intermediate blocks between the current
head block time and the desired head block time. This is useful to trigger events, such
as payouts and bandwidth updates, without generating blocks. However, many automatic chain
updates (such as block inflation) will not continue at their normal rate as they are only
calculated when a block is produced.
returns:
(time, int): A tuple including the new head block time and the number of blocks that were
generated.
"""
if( not isinstance( timestamp, int ) ):
raise ValueError( "Time must be a int" )
generate_sparsely_str = "true"
if( not generate_sparsely ):
generate_sparsely_str = "false"
iso_string = datetime.fromtimestamp( timestamp, timezone.utc ).isoformat().split( '+' )[0].split( '-' )
if( len( iso_string ) == 4 ):
iso_string = iso_string[:-1]
iso_string = '-'.join( iso_string )
print( iso_string )
return self._rpc.rpcexec( json.loads( '{"jsonrpc": "2.0", "method": "call", "params": [2,"debug_generate_blocks_until",["' + self._debug_key + '","' + iso_string + '","' + generate_sparsely_str + '"]], "id": 1}' ) )
def debug_set_hardfork( self, hardfork_id ):
"""
Schedules a hardfork to happen on the next block. call `debug_generate_blocks( 1 )` to trigger
the hardfork. All hardforks with id less than or equal to hardfork_id will be scheduled and
triggered.
args:
hardfork_id: The id of the hardfork to set. Hardfork IDs start at 1 (0 is genesis) and increment
by one for each hardfork. The maximum value is CREA_NUM_HARDFORKS in chain/hardfork.d/0-preamble.hf
"""
if( hardfork_id < 0 ):
raise ValueError( "hardfork_id cannot be negative" )
self._rpc.rpcexec( json.loads( '{"jsonrpc": "2.0", "method": "call", "params": [2,"debug_set_hardfork",[' + str( hardfork_id ) + ']], "id":1}' ) )
def debug_has_hardfork( self, hardfork_id ):
return self._rpc.rpcexec( json.loads( '{"jsonrpc": "2.0", "method": "call", "params": [2,"debug_has_hardfork",[' + str( hardfork_id ) + ']], "id":1}' ) )
def debug_get_witness_schedule( self ):
return self._rpc.rpcexec( json.loads( '{"jsonrpc": "2.0", "method": "call", "params": [2,"debug_get_witness_schedule",[]], "id":1}' ) )
def debug_get_hardfork_property_object( self ):
return self._rpc.rpcexec( json.loads( '{"jsonrpc": "2.0", "method": "call", "params": [2,"debug_get_hardfork_property_object",[]], "id":1}' ) )