def deactivate_repos(self):
timestamp = int(time()-float(self.get_config().get_cleanup_time()))
try:
database = dbhandler.DbHandler(self.get_config().get_db_file())
old_repos = database.list('repo', '', 'last_used < %s and active > 0' % timestamp)
for repo in old_repos:
logger.info('Deleting repo %s' % repo['path'])
try:
rmtree(repo['path'])
except OSError as exception:
logger.error(exception.strerror)
finally:
# Set repo inactive
database.updateData('repo', "id='%s'" % repo['id'], 'active = 0')
try:
rmtree(repo['deploy_path'])
except OSError as exception:
logger.error(exception.strerror)
makedirs(repo['deploy_path'], 0o755, True)
try:
index_file_path = '/'.join([repo['deploy_path'], 'index.html'])
index_file = open(index_file_path, 'w')
index_file.write(self.__html_content % (int(self.get_config().get_cleanup_time())/60))
except IOError as exception:
logger.error(exception.strerror)
finally:
index_file.close()
except SQLError:
logger.error("Database error, we're in trouble!")
raise
def init_repository(self, url, diff, static_files, draft=True):
try:
database = dbhandler.DbHandler(self.cm().get_db_file())
id = self.utils().generateId(self.cm().get_hash_size())
repo_path = join(self.__base_dir, id)
deploy_path = ''.join([
self.cm().get_deploy_base_path(), id,
self.cm().get_deploy_append_path()
])
if self.utils().repository_exists(id):
return None
database.insertData('repo', id, repo_path, deploy_path, url,
int(time()), 1)
shutil.copytree(OWN_PATH + '/redirector/', deploy_path)
t = threading.Thread(target=self.init_repository_async,
args=(id, deploy_path, repo_path, url, diff,
static_files, draft))
t.daemon = True
t.start()
return id, ''.join(
['http://', id, '.',
self.cm().get_base_url(), '/poller.html'])
except SQLError as exception:
logger.error(exception.__str__())
raise
def update_timestamp(self, id):
try:
database = dbhandler.DbHandler(self.cm().get_db_file())
database.updateData('repo', "id = '%s'" % id, 'last_used=%s' % int(time.time()))
except SQLError as exception:
logger.error(exception.__str__())
raise
def __init__(self, bot):
self.bot = bot
self.levels = {}
with open("./cogs/market/levels.csv", mode="r") as file:
reader = csv.reader(file)
self.levels = {int(row[1]): row[0] for row in reader} # {price: level name, ...}
self.handler = dbhandler.DbHandler()
def get_expiration_date(self, id):
try:
database = dbhandler.DbHandler(self.cm().get_db_file())
last_used = database.list('repo', 'last_used', "id='%s'" % id)[0]
return last_used + (24 * 3600)
except SQLError as exception:
logger.error(exception.__str__())
raise
def delete_repository(self, id):
try:
database = dbhandler.DbHandler(self.cm().get_db_file())
repo = database.list('repo', '', "id='%s'" % id)[0]
rmtree(repo['path'])
database.deleteData('repo', "id='%s'" % repo['id'])
except OSError as exception:
logger.error(exception.strerror)
raise
except SQLError as exception:
logger.error(exception.__str__())
raise
def cleanup_subdomains(self):
logger.info('Cleaning up subdomains.')
try:
database = dbhandler.DbHandler(self.get_config().get_db_file())
old_repos = database.list('repo', '', 'active < 1')
for repo in old_repos:
try:
logger.info('Cleaning up deploy path %s' % repo['deploy_path'])
rmtree(repo['deploy_path'])
except OSError as exception:
logger.error(exception.strerror)
else:
database.deleteData('repo', "id='%s'" % repo['id'])
except SQLError:
logger.error("Database error, we're in trouble!")
raise
def update_repository(self, id, diff, draft=True):
try:
database = dbhandler.DbHandler(self.cm().get_db_file())
repo_path = database.list('repo', 'path', "id='%s'" % id)[0]
deploy_path = database.list('repo', 'deploy_path', "id='%s'" % id)[0]
diff_file = self.fm().create_diff_file(id, diff)
self.apply_diff(id, repo_path, diff_file)
build_successful = self.jm().build(repo_path, deploy_path, draft)
if build_successful:
return (id, ''.join(['https://', id, '.', self.__base_url]))
else:
return (id, self.jm().get_errors())
except OSError as exception:
logger.error(exception.strerror)
raise
except SQLError as exception:
logger.error(exception.__str__())
raise
except git.GitCommandError as exception:
logger.error(exception.__str__())
raise
def file_download(self, id, file_name):
repo_id = id.split('/')[0]
if id.split('/')[1:]:
file_path = id.split('/')[1:][0]
else:
file_path = []
try:
database = dbhandler.DbHandler(self.cm().get_db_file())
repo_path = database.list('repo', 'path', "id='%s'" % repo_id)[0]
abs_path = '/'.join([repo_path, ''.join(file_path), file_name])
if isfile(abs_path):
return True
else:
return False
except OSError as exception:
logger.error(exception.strerror)
raise
except SQLError as exception:
logger.error(exception.__str__())
raise
def __init__(self, bot):
self.bot = bot
self.handler = dbhandler.DbHandler()
def worker(host, port, node):
logger = node.logger
this_client = f"{host}:{port}"
if node.IS_STOPPING:
return
dict_ip = {'ip': host}
node.plugin_manager.execute_filter_hook('peer_ip', dict_ip)
client_instance_worker = client.Client()
if node.peers.is_banned(host) or dict_ip['ip'] == 'banned':
node.logger.app_log.warning(f"IP {host} is banned, won't connect")
return
timeout_operation = 60 # timeout
timer_operation = time.time() # start counting
try:
s = socks.socksocket()
if node.tor:
s.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
# s.setblocking(0)
s.connect((host, port))
node.logger.app_log.info(f"Outbound: Connected to {this_client}")
client_instance_worker.connected = True
# communication starter
send(s, "version")
send(s, node.version)
data = receive(s)
if data == "ok":
node.logger.app_log.info(
f"Outbound: Node protocol version of {this_client} matches our client"
)
else:
raise ValueError(
f"Outbound: Node protocol version of {this_client} mismatch")
send(s, "getversion")
peer_version = receive(s)
if peer_version not in node.version_allow:
raise ValueError(
f"Outbound: Incompatible peer version {peer_version} from {this_client}"
)
send(s, "hello")
# communication starter
except Exception as e:
node.logger.app_log.info(f"Could not connect to {this_client}: {e}")
return # can return here, because no lists are affected yet
node.peers.store_mainnet(host, peer_version)
try:
peer_ip = s.getpeername()[0]
except:
# Should not happen, extra safety
node.logger.app_log.warning(
"Outbound: Transport endpoint was not connected")
return
if this_client not in node.peers.connection_pool:
node.peers.append_client(this_client)
node.logger.app_log.info(f"Connected to {this_client}")
node.logger.app_log.info(
f"Current active pool: {node.peers.connection_pool}")
if not node.peers.is_banned(host) and node.peers.version_allowed(
host, node.version_allow) and not node.IS_STOPPING:
db_handler_instance = dbhandler.DbHandler(node.index_db,
node.ledger_path,
node.hyper_path, node.ram,
node.ledger_ram_file, logger)
while not node.peers.is_banned(host) and node.peers.version_allowed(
host, node.version_allow) and not node.IS_STOPPING:
try:
#ensure_good_peer_version(host)
data = receive(s) # receive data, one and the only root point
# print(data)
if data == "peers":
subdata = receive(s) # dict of "ip":"port"
node.peers.peersync(subdata)
elif data == "sync":
if not time.time() <= timer_operation + timeout_operation:
timer_operation = time.time() # reset timer
try:
while len(node.syncing) >= 3:
if node.IS_STOPPING:
return
time.sleep(int(node.pause))
node.syncing.append(peer_ip)
# sync start
# send block height, receive block height
send(s, "blockheight")
node.logger.app_log.info(
f"Outbound: Sending block height to compare: {node.hdd_block}"
)
# append zeroes to get static length
send(s, node.hdd_block)
received_block_height = receive(
s) # receive node's block height
node.logger.app_log.info(
f"Outbound: Node {peer_ip} is at block height: {received_block_height}"
)
if int(received_block_height) < node.hdd_block:
node.logger.app_log.warning(
f"Outbound: We have a higher block ({node.hdd_block}) than {peer_ip} ({received_block_height}), sending"
)
data = receive(s) # receive client's last block_hash
# send all our followup hashes
node.logger.app_log.info(
f"Outbound: Will seek the following block: {data}")
# consensus pool 2 (active connection)
consensus_blockheight = int(received_block_height)
node.peers.consensus_add(peer_ip,
consensus_blockheight, s,
node.hdd_block)
# consensus pool 2 (active connection)
client_block = db_handler_instance.block_height_from_hash(
data)
if not client_block:
node.logger.app_log.warning(
f"Outbound: Block {data[:8]} of {peer_ip} not found"
)
if node.full_ledger:
send(s, "blocknf")
else:
send(s, "blocknfhb")
send(s, data)
if node.peers.warning(s, peer_ip, "Forked", 1):
raise ValueError(f"{peer_ip} is banned")
else:
node.logger.app_log.warning(
f"Outbound: Node is at block {client_block}"
) # now check if we have any newer
if node.hdd_hash == data or not node.egress:
if not node.egress:
node.logger.app_log.warning(
f"Outbound: Egress disabled for {peer_ip}"
)
time.sleep(int(
node.pause)) # reduce CPU usage
else:
node.logger.app_log.info(
f"Outbound: Node {peer_ip} has the latest block"
)
# TODO: this is unlikely to happen due to conditions above, consider removing
send(s, "nonewblk")
else:
blocks_fetched = db_handler_instance.blocksync(
client_block)
node.logger.app_log.info(
f"Outbound: Selected {blocks_fetched}")
send(s, "blocksfnd")
confirmation = receive(s)
if confirmation == "blockscf":
node.logger.app_log.info(
"Outbound: Client confirmed they want to sync from us"
)
send(s, blocks_fetched)
elif confirmation == "blocksrj":
node.logger.app_log.info(
"Outbound: Client rejected to sync from us because we're dont have the latest block"
)
elif int(received_block_height) >= node.hdd_block:
if int(received_block_height) == node.hdd_block:
node.logger.app_log.info(
f"Outbound: We have the same block as {peer_ip} ({received_block_height}), hash will be verified"
)
else:
node.logger.app_log.warning(
f"Outbound: We have a lower block ({node.hdd_block}) than {peer_ip} ({received_block_height}), hash will be verified"
)
node.logger.app_log.info(
f"Outbound: block_hash to send: {node.hdd_hash}")
send(s, node.hdd_hash)
#ensure_good_peer_version(host)
# consensus pool 2 (active connection)
consensus_blockheight = int(
received_block_height
) # str int to remove leading zeros
node.peers.consensus_add(peer_ip,
consensus_blockheight, s,
node.hdd_block)
# consensus pool 2 (active connection)
except Exception as e:
node.logger.app_log.warning(f"Outbound: Sync failed {e}")
finally:
node.syncing.remove(peer_ip)
elif data == "blocknfhb": # one of the possible outcomes
block_hash_delete = receive(s)
# print peer_ip
# if max(consensus_blockheight_list) == int(received_block_height):
if int(received_block_height) == node.peers.consensus_max:
blocknf(node,
block_hash_delete,
peer_ip,
db_handler_instance,
hyperblocks=True)
if node.peers.warning(s, peer_ip, "Rollback", 2):
raise ValueError(f"{peer_ip} is banned")
sendsync(s, peer_ip, "Block not found", node)
elif data == "blocknf": # one of the possible outcomes
block_hash_delete = receive(s)
# print peer_ip
# if max(consensus_blockheight_list) == int(received_block_height):
if int(received_block_height) == node.peers.consensus_max:
blocknf(node, block_hash_delete, peer_ip,
db_handler_instance)
if node.peers.warning(s, peer_ip, "Rollback", 2):
raise ValueError(f"{peer_ip} is banned")
sendsync(s, peer_ip, "Block not found", node)
elif data == "blocksfnd":
node.logger.app_log.info(
f"Outbound: Node {peer_ip} has the block(s)"
) # node should start sending txs in this step
# node.logger.app_log.info("Inbound: Combined segments: " + segments)
# print peer_ip
if node.db_lock.locked():
node.logger.app_log.warning(
f"Skipping sync from {peer_ip}, syncing already in progress"
)
else:
if int(node.last_block_timestamp) < (time.time() - 600):
block_req = node.peers.consensus_most_common
node.logger.app_log.warning(
"Most common block rule triggered")
else:
block_req = node.peers.consensus_max
node.logger.app_log.warning(
"Longest chain rule triggered")
#ensure_good_peer_version(host)
if int(received_block_height) >= block_req and int(
received_block_height) > node.last_block:
try: # they claim to have the longest chain, things must go smooth or ban
node.logger.app_log.warning(
f"Confirming to sync from {peer_ip}")
send(s, "blockscf")
segments = receive(s)
#ensure_good_peer_version(host)
except:
if node.peers.warning(
s, peer_ip,
"Failed to deliver the longest chain", 2):
raise ValueError(f"{peer_ip} is banned")
else:
digest_block(node, segments, s, peer_ip,
db_handler_instance)
# receive theirs
else:
send(s, "blocksrj")
node.logger.app_log.warning(
f"Inbound: Distant peer {peer_ip} is at {received_block_height}, should be at least {max(block_req,node.last_block+1)}"
)
sendsync(s, peer_ip, "Block found", node)
# block_hash validation end
elif data == "nonewblk":
# send and receive mempool
if mp.MEMPOOL.sendable(peer_ip):
mempool_txs = mp.MEMPOOL.tx_to_send(peer_ip)
# node.logger.app_log.info("Outbound: Extracted from the mempool: " + str(mempool_txs)) # improve: sync based on signatures only
# if len(mempool_txs) > 0: #wont sync mempool until we send something, which is bad
# send own
send(s, "mempool")
send(s, mempool_txs)
# send own
# receive theirs
segments = receive(s)
node.logger.app_log.info(
mp.MEMPOOL.merge(segments, peer_ip,
db_handler_instance.c, True))
# receive theirs
# Tell the mempool we just send our pool to a peer
mp.MEMPOOL.sent(peer_ip)
sendsync(s, peer_ip, "No new block", node)
elif data == "hyperlane":
pass
else:
if data == '*':
raise ValueError("Broken pipe")
raise ValueError(
f"Unexpected error, received: {str(data)[:32]}")
except Exception as e:
"""
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
"""
db_handler_instance.close()
# remove from active pool
node.peers.remove_client(this_client)
node.logger.app_log.warning(
f"Outbound: Disconnected from {this_client}: {e}")
# remove from active pool
# remove from consensus 2
node.peers.consensus_remove(peer_ip)
# remove from consensus 2
node.logger.app_log.info(
f"Connection to {this_client} terminated due to {e}")
node.logger.app_log.info(
f"---thread {threading.currentThread()} ended---")
# properly end the connection
s.close()
# properly end the connection
if node.debug:
raise # major debug client
else:
node.logger.app_log.info(f"Ending thread, because {e}")
return
if not node.peers.version_allowed(host, node.version_allow):
node.logger.app_log.warning(
f"Outbound: Ending thread, because {host} has too old a version: {node.peers.ip_to_mainnet[host]}"
)
def worker(host, port, node):
logger = node.logger
this_client = f"{host}:{port}"
if node.IS_STOPPING:
return
dict_ip = {'ip': host}
node.plugin_manager.execute_filter_hook('peer_ip', dict_ip)
client_instance_worker = classes.Client()
if node.peers.is_banned(host) or dict_ip['ip'] == 'banned':
client_instance_worker.banned = True
node.logger.app_log.warning(f"IP {host} is banned, won't connect")
return
timeout_operation = 60 # timeout
timer_operation = time.time() # start counting
try:
s = socks.socksocket()
if node.tor_conf:
s.setproxy(socks.PROXY_TYPE_SOCKS5, "127.0.0.1", 9050)
# s.setblocking(0)
s.connect((host, port))
node.logger.app_log.info(f"Outbound: Connected to {this_client}")
client_instance_worker.connected = True
# communication starter
send(s, "version")
send(s, node.version)
data = receive(s)
if data == "ok":
node.logger.app_log.info(
f"Outbound: Node protocol version of {this_client} matches our client"
)
else:
raise ValueError(
f"Outbound: Node protocol version of {this_client} mismatch")
# If we are post pow fork, then the peer has getversion command
# if node.last_block >= POW_FORK - FORK_AHEAD:
# Peers that are not up to date will disconnect since they don't know that command.
# That is precisely what we need :D
send(s, "getversion")
peer_version = receive(s)
if peer_version not in node.version_allow:
raise ValueError(
f"Outbound: Incompatible peer version {peer_version} from {this_client}"
)
send(s, "hello")
# communication starter
except Exception as e:
node.logger.app_log.info(f"Could not connect to {this_client}: {e}")
return # can return here, because no lists are affected yet
# if node.last_block >= POW_FORK - FORK_AHEAD:
node.peers.store_mainnet(host, peer_version)
try:
peer_ip = s.getpeername()[0]
except:
# Should not happen, extra safety
node.logger.app_log.warning(
"Outbound: Transport endpoint was not connected")
return
if this_client not in node.peers.connection_pool:
node.peers.append_client(this_client)
node.logger.app_log.info(f"Connected to {this_client}")
node.logger.app_log.info(
f"Current active pool: {node.peers.connection_pool}")
if not client_instance_worker.banned and node.peers.version_allowed(
host, node.version_allow) and not node.IS_STOPPING:
db_handler_instance = dbhandler.DbHandler(
node.index_db, node.ledger_path_conf, node.hyper_path_conf,
node.full_ledger, node.ram_conf, node.ledger_ram_file, logger)
while not client_instance_worker.banned and node.peers.version_allowed(
host, node.version_allow) and not node.IS_STOPPING:
try:
#ensure_good_peer_version(host)
data = receive(s) # receive data, one and the only root point
# print(data)
if data == "peers":
subdata = receive(s)
node.peers.peersync(subdata)
elif data == "sync":
if not time.time() <= timer_operation + timeout_operation:
timer_operation = time.time() # reset timer
try:
while len(node.syncing) >= 3:
if node.IS_STOPPING:
return
time.sleep(int(node.pause_conf))
node.syncing.append(peer_ip)
# sync start
# send block height, receive block height
send(s, "blockheight")
db_handler_instance.execute(
db_handler_instance.c,
'SELECT max(block_height) FROM transactions')
db_block_height = db_handler_instance.c.fetchone()[0]
node.logger.app_log.info(
f"Outbound: Sending block height to compare: {db_block_height}"
)
# append zeroes to get static length
send(s, db_block_height)
received_block_height = receive(
s) # receive node's block height
node.logger.app_log.info(
f"Outbound: Node {peer_ip} is at block height: {received_block_height}"
)
if int(received_block_height) < db_block_height:
node.logger.app_log.warning(
f"Outbound: We have a higher block ({db_block_height}) than {peer_ip} ({received_block_height}), sending"
)
data = receive(s) # receive client's last block_hash
# send all our followup hashes
node.logger.app_log.info(
f"Outbound: Will seek the following block: {data}")
# consensus pool 2 (active connection)
consensus_blockheight = int(received_block_height)
node.peers.consensus_add(peer_ip,
consensus_blockheight, s,
node.last_block)
# consensus pool 2 (active connection)
try:
db_handler_instance.execute_param(
db_handler_instance.h3,
"SELECT block_height FROM transactions WHERE block_hash = ?;",
(data, ))
client_block = db_handler_instance.h3.fetchone()[0]
except Exception:
node.logger.app_log.warning(
f"Outbound: Block {data[:8]} of {peer_ip} not found"
)
send(s, "blocknf")
send(s, data)
else:
node.logger.app_log.info(
f"Outbound: Node is at block {client_block}"
) # now check if we have any newer
db_handler_instance.execute(
db_handler_instance.h3,
'SELECT block_hash FROM transactions ORDER BY block_height DESC LIMIT 1'
)
db_block_hash = db_handler_instance.h3.fetchone()[
0] # get latest block_hash
if db_block_hash == data or not node.egress:
if not node.egress:
node.logger.app_log.warning(
f"Outbound: Egress disabled for {peer_ip}"
)
time.sleep(int(
node.pause_conf)) # reduce CPU usage
else:
node.logger.app_log.info(
f"Outbound: Node {peer_ip} has the latest block"
)
# TODO: this is unlikely to happen due to conditions above, consider removing
send(s, "nonewblk")
else:
blocks_fetched = []
while sys.getsizeof(
str(blocks_fetched)
) < 500000: # limited size based on txs in blocks
# db_handler.execute_param(db_handler.h3, ("SELECT block_height, timestamp,address,recipient,amount,signature,public_key,keep,openfield FROM transactions WHERE block_height > ? AND block_height <= ?;"),(str(int(client_block)),) + (str(int(client_block + 1)),))
db_handler_instance.execute_param(
db_handler_instance.h3,
("SELECT timestamp,address,recipient,amount,signature,public_key,operation,openfield FROM transactions WHERE block_height > ? AND block_height <= ?;"
), (
str(int(client_block)),
str(int(client_block + 1)),
))
result = db_handler_instance.h3.fetchall()
if not result:
break
blocks_fetched.extend([result])
client_block = int(client_block) + 1
# blocks_send = [[l[1:] for l in group] for _, group in groupby(blocks_fetched, key=itemgetter(0))] # remove block number
node.logger.app_log.info(
f"Outbound: Selected {blocks_fetched}")
send(s, "blocksfnd")
confirmation = receive(s)
if confirmation == "blockscf":
node.logger.app_log.info(
"Outbound: Client confirmed they want to sync from us"
)
send(s, blocks_fetched)
elif confirmation == "blocksrj":
node.logger.app_log.info(
"Outbound: Client rejected to sync from us because we're dont have the latest block"
)
elif int(received_block_height) >= db_block_height:
if int(received_block_height) == db_block_height:
node.logger.app_log.info(
f"Outbound: We have the same block as {peer_ip} ({received_block_height}), hash will be verified"
)
else:
node.logger.app_log.warning(
f"Outbound: We have a lower block ({db_block_height}) than {peer_ip} ({received_block_height}), hash will be verified"
)
db_handler_instance.execute(
db_handler_instance.c,
'SELECT block_hash FROM transactions ORDER BY block_height DESC LIMIT 1'
)
db_block_hash = db_handler_instance.c.fetchone()[
0] # get latest block_hash
node.logger.app_log.info(
f"Outbound: block_hash to send: {db_block_hash}")
send(s, db_block_hash)
#ensure_good_peer_version(host)
# consensus pool 2 (active connection)
consensus_blockheight = int(
received_block_height
) # str int to remove leading zeros
node.peers.consensus_add(peer_ip,
consensus_blockheight, s,
node.last_block)
# consensus pool 2 (active connection)
except Exception as e:
node.logger.app_log.info(f"Outbound: Sync failed {e}")
finally:
node.syncing.remove(peer_ip)
elif data == "blocknf": # one of the possible outcomes
block_hash_delete = receive(s)
# print peer_ip
# if max(consensus_blockheight_list) == int(received_block_height):
if int(received_block_height) == node.peers.consensus_max:
blocknf(node, block_hash_delete, peer_ip,
db_handler_instance)
if node.peers.warning(s, peer_ip, "Rollback", 2):
raise ValueError(f"{peer_ip} is banned")
sendsync(s, peer_ip, "Block not found", False, node)
elif data == "blocksfnd":
node.logger.app_log.info(
f"Outbound: Node {peer_ip} has the block(s)"
) # node should start sending txs in this step
# node.logger.app_log.info("Inbound: Combined segments: " + segments)
# print peer_ip
if node.db_lock.locked():
node.logger.app_log.warning(
f"Skipping sync from {peer_ip}, syncing already in progress"
)
else:
db_handler_instance.execute(
db_handler_instance.c,
"SELECT timestamp FROM transactions WHERE reward != 0 ORDER BY block_height DESC LIMIT 1;"
) # or it takes the first
node.last_block_timestamp = quantize_two(
db_handler_instance.c.fetchone()[0])
if int(node.last_block_timestamp) < (time.time() - 600):
block_req = node.peers.consensus_most_common
node.logger.app_log.warning(
"Most common block rule triggered")
else:
block_req = node.peers.consensus_max
node.logger.app_log.warning(
"Longest chain rule triggered")
#ensure_good_peer_version(host)
if int(received_block_height) >= block_req:
try: # they claim to have the longest chain, things must go smooth or ban
node.logger.app_log.warning(
f"Confirming to sync from {peer_ip}")
send(s, "blockscf")
segments = receive(s)
#ensure_good_peer_version(host)
except:
if node.peers.warning(
s, peer_ip,
"Failed to deliver the longest chain", 2):
raise ValueError(f"{peer_ip} is banned")
else:
digest_block(node, segments, s, peer_ip,
db_handler_instance)
# receive theirs
else:
send(s, "blocksrj")
node.logger.app_log.warning(
f"Inbound: Distant peer {peer_ip} is at {received_block_height}, should be at least {block_req}"
)
sendsync(s, peer_ip, "Block found", True, node)
# block_hash validation end
elif data == "nonewblk":
# send and receive mempool
if mp.MEMPOOL.sendable(peer_ip):
mempool_txs = mp.MEMPOOL.tx_to_send(peer_ip)
# node.logger.app_log.info("Outbound: Extracted from the mempool: " + str(mempool_txs)) # improve: sync based on signatures only
# if len(mempool_txs) > 0: #wont sync mempool until we send something, which is bad
# send own
send(s, "mempool")
send(s, mempool_txs)
# send own
# receive theirs
segments = receive(s)
node.logger.app_log.info(
mp.MEMPOOL.merge(segments, peer_ip,
db_handler_instance.c, True))
# receive theirs
# Tell the mempool we just send our pool to a peer
mp.MEMPOOL.sent(peer_ip)
sendsync(s, peer_ip, "No new block", True, node)
elif data == "hyperlane":
pass
else:
if data == '*':
raise ValueError("Broken pipe")
raise ValueError(
f"Unexpected error, received: {str(data)[:32]}")
except Exception as e:
"""
exc_type, exc_obj, exc_tb = sys.exc_info()
fname = os.path.split(exc_tb.tb_frame.f_code.co_filename)[1]
print(exc_type, fname, exc_tb.tb_lineno)
"""
# remove from active pool
node.peers.remove_client(this_client)
node.logger.app_log.warning(
f"Outbound: Disconnected from {this_client}: {e}")
# remove from active pool
# remove from consensus 2
node.peers.consensus_remove(peer_ip)
# remove from consensus 2
node.logger.app_log.info(
f"Connection to {this_client} terminated due to {e}")
node.logger.app_log.info(
f"---thread {threading.currentThread()} ended---")
# properly end the connection
s.close()
# properly end the connection
if node.debug_conf:
raise # major debug client
else:
node.logger.app_log.info(f"Ending thread, because {e}")
return
if not node.peers.version_allowed(host, node.version_allow):
node.logger.app_log.warning(
f"Outbound: Ending thread, because {host} has too old a version: {node.peers.ip_to_mainnet[host]}"
)
def list_repositories(self):
database = dbhandler.DbHandler(self.cm().get_db_file())
dir_list = [[f['path'].split('/')[-1], f['url']] for f in database.list('repo') if isdir(f['path'])]
return dir_list
except Exception as e:
node.logger.app_log.warning("Exception {}".format(e))
node.logger.app_log.warning(
"Processing of {} finished".format(token))
except:
node.logger.app_log.warning("Error parsing")
db_handler_instance.index.commit()
if __name__ == "__main__":
from libs import node, logger
import dbhandler
node = node.Node()
node.debug_level = "WARNING"
node.terminal_output = True
node.logger = logger.Logger()
node.logger.app_log = log.log("local_test.log", node.debug_level,
node.terminal_output)
node.logger.app_log.warning("Configuration settings loaded")
db_handler = dbhandler.DbHandler("static/index_local_test.db",
"static/ledger.db", "static/hyper.db",
False, None, node.logger, False)
tokens_update(node, db_handler)
# tokens_update("tokens.db","reindex")
