mirror of
https://github.com/darkrenaissance/darkfi.git
synced 2026-04-28 03:00:18 -04:00
258 lines
8.0 KiB
Python
Executable File
258 lines
8.0 KiB
Python
Executable File
#!/usr/bin/python3
|
|
|
|
# This file is part of DarkFi (https://dark.fi)
|
|
#
|
|
# Copyright (C) 2020-2024 Dyne.org foundation
|
|
#
|
|
# This program is free software: you can redistribute it and/or modify
|
|
# it under the terms of the GNU Affero General Public License as
|
|
# published by the Free Software Foundation, either version 3 of the
|
|
# License, or (at your option) any later version.
|
|
#
|
|
# This program is distributed in the hope that it will be useful,
|
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
# GNU Affero General Public License for more details.
|
|
#
|
|
# You should have received a copy of the GNU Affero General Public License
|
|
# along with this program. If not, see <https://www.gnu.org/licenses/>.
|
|
|
|
import asyncio, random, re, sys, base58, json
|
|
import base58
|
|
import urwid as u
|
|
import networkx as nx
|
|
# import matplotlib.pyplot as plt
|
|
import src.util
|
|
|
|
from os.path import join
|
|
|
|
# # Create a directed graph
|
|
# dag = nx.DiGraph()
|
|
|
|
# # Add edges to the graph (this also adds nodes)
|
|
# dag.add_edges_from([
|
|
# ("root", "a"),
|
|
# ("a", "b"),
|
|
# ("a", "e"),
|
|
# ("b", "c"),
|
|
# ("b", "d"),
|
|
# ("d", "e")
|
|
# ])
|
|
|
|
class JsonRpc:
|
|
|
|
async def start(self, server, port):
|
|
reader, writer = await asyncio.open_connection(server, port, limit=1024 * 128)
|
|
self.reader = reader
|
|
self.writer = writer
|
|
|
|
async def stop(self):
|
|
self.writer.close()
|
|
await self.writer.wait_closed()
|
|
|
|
async def _make_request(self, method, params):
|
|
ident = random.randint(0, 2**16)
|
|
#print(ident)
|
|
request = {
|
|
"jsonrpc": "2.0",
|
|
"method": method,
|
|
"params": params,
|
|
"id": ident,
|
|
}
|
|
|
|
message = json.dumps(request) + "\n"
|
|
self.writer.write(message.encode())
|
|
await self.writer.drain()
|
|
|
|
data = await self.reader.readline()
|
|
message = data.decode().strip()
|
|
response = json.loads(message)
|
|
#print(response)
|
|
return response
|
|
|
|
async def _subscribe(self, method, params):
|
|
ident = random.randint(0, 2**16)
|
|
request = {
|
|
"jsonrpc": "2.0",
|
|
"method": method,
|
|
"params": params,
|
|
"id": ident,
|
|
}
|
|
|
|
message = json.dumps(request) + "\n"
|
|
self.writer.write(message.encode())
|
|
await self.writer.drain()
|
|
#print("Subscribed")
|
|
|
|
async def ping(self):
|
|
return await self._make_request("ping", [])
|
|
|
|
async def dnet_switch(self, state):
|
|
return await self._make_request("dnet.switch", [state])
|
|
|
|
async def dnet_subscribe_events(self):
|
|
return await self._subscribe("dnet.subscribe_events", [])
|
|
|
|
async def deg_switch(self, state):
|
|
return await self._make_request("deg.switch", [state])
|
|
|
|
|
|
class ListItem(u.WidgetWrap):
|
|
|
|
def __init__ (self, event):
|
|
self.content = event
|
|
layer_num = int(event["layer"])
|
|
layer = "layer " + str(layer_num) if layer_num != 0 else "genesis"
|
|
t = u.AttrWrap(u.Text(layer), "event", "event_selected")
|
|
u.WidgetWrap.__init__(self, t)
|
|
|
|
def selectable (self):
|
|
return True
|
|
|
|
def keypress(self, size, key):
|
|
return key
|
|
|
|
class ListView(u.WidgetWrap):
|
|
|
|
def __init__(self):
|
|
u.register_signal(self.__class__, ['show_details'])
|
|
self.walker = u.SimpleFocusListWalker([])
|
|
lb = u.ListBox(self.walker)
|
|
u.WidgetWrap.__init__(self, lb)
|
|
|
|
def modified(self):
|
|
focus_w, _ = self.walker.get_focus()
|
|
u.emit_signal(self, 'show_details', focus_w.content)
|
|
|
|
def set_data(self, events):
|
|
events_widgets = [ListItem(e) for e in events]
|
|
u.disconnect_signal(self.walker, 'modified', self.modified)
|
|
|
|
while len(self.walker) > 0:
|
|
self.walker.pop()
|
|
|
|
self.walker.extend(events_widgets)
|
|
u.connect_signal(self.walker, "modified", self.modified)
|
|
self.walker.set_focus(0)
|
|
|
|
class DetailView(u.WidgetWrap):
|
|
|
|
def __init__ (self):
|
|
t = u.Text("")
|
|
u.WidgetWrap.__init__(self, t)
|
|
|
|
def set_event(self, c):
|
|
s = f'Hash: {c["hash"]}\nChildren: {c["children"]}\nContent: {c["content"]}\nLayer: {c["layer"]}'
|
|
self._w.set_text(s)
|
|
|
|
class App(object):
|
|
|
|
def unhandled_input(self, key):
|
|
if key in ('q',):
|
|
raise u.ExitMainLoop()
|
|
|
|
def show_details(self, event):
|
|
self.detail_view.set_event(event)
|
|
|
|
def __init__(self):
|
|
self.palette = {
|
|
("bg", "white", "black"),
|
|
("event", "white", "black"),
|
|
("event_selected", "white", "yellow"),
|
|
("footer", "white, bold", "dark red")
|
|
}
|
|
|
|
self.list_view = ListView()
|
|
self.detail_view = DetailView()
|
|
u.connect_signal(self.list_view, 'show_details', self.show_details)
|
|
footer = u.AttrWrap(u.Text(" Q to exit"), "footer")
|
|
col_rows = u.raw_display.Screen().get_cols_rows()
|
|
h = col_rows[0] - 2
|
|
f1 = u.Filler(self.list_view, valign='top', height=h)
|
|
f2 = u.Filler(self.detail_view, valign='top')
|
|
c_list = u.LineBox(f1, title="Layers")
|
|
c_details = u.LineBox(f2, title="Details")
|
|
columns = u.Columns([('weight', 15, c_list), ('weight', 85, c_details)])
|
|
frame = u.AttrMap(u.Frame(body=columns, footer=footer), 'bg')
|
|
self.loop = u.MainLoop(frame, self.palette, unhandled_input=self.unhandled_input)
|
|
|
|
async def update_data(self, config):
|
|
host = config['host']
|
|
port = config['port']
|
|
rpc = JsonRpc()
|
|
while True:
|
|
try:
|
|
await rpc.start(host, port)
|
|
break
|
|
except OSError:
|
|
print("Error: Couldn't connent to rpc")
|
|
exit(-1)
|
|
|
|
await rpc.deg_switch(True)
|
|
await rpc.deg_switch(False)
|
|
|
|
json_result = await rpc._make_request("eventgraph.get_info", [])
|
|
|
|
if json_result['result']['eventgraph_info']:
|
|
dag_dict = json_result['result']['eventgraph_info']['dag']
|
|
dag_list = list(dag_dict.items())
|
|
# sorted_dag = sorted(dag_list, key=lambda x:x[1]['layer'])
|
|
|
|
# genesis_hash = sorted_dag[0][0]
|
|
|
|
parent_child_pairs = []
|
|
for item in dag_list:
|
|
parents = item[1]['parents']
|
|
child = item[0]
|
|
for parent in parents:
|
|
if parent == '0' * 64:
|
|
continue
|
|
parent_child_pairs.append((parent, child))
|
|
|
|
# Create a directed graph
|
|
dag = nx.DiGraph()
|
|
|
|
# Add edges to the graph (this also adds nodes)
|
|
dag.add_edges_from(parent_child_pairs)
|
|
l = []
|
|
topological_order = list(nx.topological_sort(dag))
|
|
for node in topological_order:
|
|
event_details = dag_dict.get(node) # details
|
|
layer = int(event_details['layer'])
|
|
content = event_details['content'] # event content
|
|
# print(content)
|
|
pattern = r'\\x[0-9A-Fa-f]{2}'
|
|
decoded_str = str(base58.b58decode(content))
|
|
matches = re.split(pattern, decoded_str)
|
|
children = dag.successors(node)
|
|
l.append({"layer":f"{layer}", "hash":f"{node}", "children":f"{list(children)}", "content":f"{matches[1:]}"})
|
|
|
|
self.list_view.set_data(l)
|
|
|
|
async def start(self, config):
|
|
await self.update_data(config)
|
|
self.loop.run()
|
|
|
|
async def main(argv):
|
|
|
|
os = src.util.get_os()
|
|
config_path = src.util.user_config_dir('darkfi', os)
|
|
|
|
suffix = '.toml'
|
|
filename = 'deg_config'
|
|
path = join(config_path, filename + suffix)
|
|
config = src.util.spawn_config(path)
|
|
config = config['nodes'][0]
|
|
|
|
if len(argv) > 1:
|
|
if argv[1] in ['darkirc', 'irc']:
|
|
config['port'] = 26660
|
|
elif argv[1] in ['taud', 'tau']:
|
|
config['port'] = 23330
|
|
|
|
app = App()
|
|
await app.start(config)
|
|
|
|
|
|
asyncio.run(main(sys.argv))
|