def _set_up(self):
self._destroy_db()
CONFIG.set('general', 'database', self.DATABASE_NAME)
CONFIG.set('general', 'network', 'testnet')
CONFIG.set('general', 'wallet_address', '3918807197700602162PR')
CONFIG.set('bootstrap', 'bootstrap_nodes', '[]')
CONFIG.set('developer', 'wallet_password', 'test1')
self.clock = task.Clock()
self.prisma = Prisma()
self.prisma.callLater = self.clock.callLater
self.prisma.start(False)
def __init__(self):
self.logger = logging.getLogger('Network')
self.status = STATUS_INIT
self.callLater = Prisma().callLater
self.reactor = reactor
self.factory = NetworkFactory()
self.listen_port = CONFIG.getint('network', 'listen_port')
self.listener = None
self.node_id = self.get_node_id()
self.get_peers_lc = None
self.get_events_lc = None
self.get_peers_timer = CONFIG.getint('network', 'get_peers_timer')
self.get_events_timer = CONFIG.getint('network', 'get_events_timer')
self.timeout = CONFIG.getint('network', 'timeout')
def is_valid_node_ip(ip):
"""
Validate node ip address.
:param ip: An IPv4 address.
:type ip: string
:rtype: False: Is either a non valid IPv4 address or is an RFC1918-address.
:rtype: string (IP address)
"""
try:
address = ipaddress.IPv4Address(ip)
except ValueError:
return False
if address.is_private:
if CONFIG.get('developer', 'developer_mode') is False:
return False
return ip
def bootstrap(self):
"""
Delete all peers and bootstrap the peers in the config file by connecting and asking
them the peers they know.
"""
self.status = STATUS_BOOTSTRAPPING
# delete first all peers
Prisma().db.delete_peers()
# bootstrap each of the nodes
bootstrap_nodes = json.loads(CONFIG.get('bootstrap',
'bootstrap_nodes'))
for bootstrap in bootstrap_nodes:
host, port = bootstrap.split(":")
self.bootstrap_peer(host, int(port))
# get state from a random node
self.download_state_from_random_peer()
def __init__(self):
self.port = CONFIG.getint('api', 'listen_port')
self.factory = ApiFactory()
self.listener = None
self.push_info_lc = None
def get_events_from_random_peer(self):
"""
Gets a random a peer from the database and connects to it and asks for events.
"""
# check first if ready
if self.status != STATUS_READY:
self.logger.info('Not ready, still bootstrapping.')
return
# check that we have enough peers
peer_count = Prisma().db.count_peers()
if peer_count < 3:
if not CONFIG.getboolean('developer',
'developer_mode') or peer_count < 1:
self.logger.debug(
'Not enough peers found in the network, skipping...')
return
random_peer = Prisma().db.get_random_peer().pop()
host = random_peer['host']
port = random_peer['port']
client = TCP4ClientEndpoint(self.reactor, host, port, self.timeout)
d = client.connect(self.factory)
# in case of connection ok, add the callbacks for get_peers and call send_get_peers
def connection_ok(protocol):
protocol.d = defer.Deferred()
def get_events_ok(_):
self.logger.info('Successfully got events from {0}:{1}'.format(
host, port))
protocol.d.addCallback(get_events_ok)
def get_events_error(reason):
error_message = reason.getErrorMessage()
self.logger.error(
'Error when getting events from {0}:{1}: {2}'.format(
host, port, error_message))
protocol.close_connection()
self.get_events_lc.reset()
self.get_events_from_random_peer()
protocol.d.addErrback(get_events_error)
protocol.send_get_events()
d.addCallback(connection_ok)
# in case of connection error show in debug and try again
def connection_error(reason):
# in case of error remove the peer from the database
addr = random_peer['host'] + ':' + str(random_peer['port'])
self.logger.debug('Error while connecting to {0}: {1}'.format(
addr, reason.getErrorMessage()))
Prisma().db.delete_peer(random_peer['_id'])
# then restart timer and try again get_peers_from_random_peer
self.get_events_lc.reset()
self.get_events_from_random_peer()
d.addErrback(connection_error)
def prompt_unlock(self):
"""
Prompt user for unlocking a certain wallet by its address.
:return: success: keys dictionary, no success: False
"""
try:
# verify if there is not an existing wallet then create a new wallet and continue
if len(self.list_wallets()) == 0:
print(
'You don\'t have any wallets. Let\'s create your first wallet.'
)
keys = self.create_wallet()
print('Wallet created with address: ' + keys['address'])
return keys
# if wallet address is specified in the config file then just ask for a password, otherwise ask for an
# address in the prompt
if CONFIG.has_option('general', 'wallet_address'):
wallet_address = CONFIG.get('general', 'wallet_address')
if CONFIG.get('general',
'wallet_address') not in self.list_wallets():
raise Exception(
'Wallet provided in the config file does not exist.')
self.logger.info(
'Unlocking wallet with address {0}'.format(wallet_address))
# in case of dev mode we can have the password in the config file, otherwise ask for a password
if CONFIG.getboolean('developer', 'developer_mode') and \
CONFIG.has_option('developer', 'wallet_password'):
keys = self.decrypt_keystore(
wallet_address,
CONFIG.get('developer', 'wallet_password'))
if keys:
return keys
else:
while True:
password = getpass(prompt="Password: "******"Password can not be empty.")
else:
while True:
wallet_address = input("Wallet address: ")
if wallet_address and wallet_address in self.list_wallets(
):
password = getpass(prompt="Password: "******"Password can not be empty.")
else:
self.logger.info("Wallet address does not exist.")
break
except Exception as e:
self.logger.error(
'Error when unlocking wallet. Reason: {0}'.format(e))
return False
def main():
"""
Entry point
"""
parser = argparse.ArgumentParser('Run a cryptograph manager.')
parser.add_argument('--create',
action='store_true',
help='create a new wallet address')
parser.add_argument('--list',
action='store_true',
help='list all wallet addresses')
parser.add_argument('--wallet', help='wallet address')
parser.add_argument('--listenport',
help='what port the manager should bind to')
parser.add_argument('--apiport',
help='what port for the API should bind to')
parser.add_argument('--database', help='mongodb database name')
parser.add_argument('--prompt',
'-p',
action='store_true',
help='show prompt')
parser.add_argument('--log', '-l', help='log into a file')
parser.add_argument('--version', action='store_true', help='print version')
parser.add_argument('-v', action='store_true', help='verbose')
parser.add_argument('-vv', action='store_true', help='very verbose')
args = parser.parse_args()
if args.version:
print('Prisma v{0}'.format(__version__))
exit(0)
# check version and ask for updating in case that is not updated.
last_version = retrieve_last_version()
if last_version and version.parse(last_version) > version.parse(
__version__):
print(
'A newer version of Prisma is available ({0}), please update Prisma with pip3.'
.format(last_version))
choice = input(
'Do you wish to continue anyway? (y/N): ').strip().lower()
if choice != 'y':
exit()
wallet = Wallet()
# create a new wallet if --create
if args.create:
try:
keys = wallet.create_wallet()
print('Wallet created with address: ' + keys['address'])
except Exception as e:
print(str(e))
exit()
# list wallet list if --list
if args.list:
print(wallet.list_wallets())
exit()
# set logger options
if args.vv:
logging.basicConfig(
format=
'[%(asctime)s] [%(levelname)-8s] [%(name)-10s] %(message)s [%(filename)s:%(lineno)d]',
level=logging.DEBUG,
filename=args.log)
elif args.v:
logging.basicConfig(format='[%(levelname)s] [%(name)s] %(message)s',
level=logging.INFO,
filename=args.log)
observer = log.PythonLoggingObserver()
observer.start()
if args.listenport:
CONFIG.set('network', 'listen_port', args.listenport)
if args.apiport:
CONFIG.set('api', 'listen_port', args.apiport)
if args.wallet:
CONFIG.set('general', 'wallet_address', args.wallet)
if args.database:
CONFIG.set('general', 'database', args.database)
# preparing manager
def signal_handler(sig, frame):
Prisma().stop()
signal.signal(signal.SIGINT, signal_handler)
signal.signal(signal.SIGQUIT, signal_handler)
# starting manager
Prisma().start(args.prompt)
reactor.run()