def on_application_start(self):
init_profile_db()
self.updater = Updater(self)
self.node = Node(self)
self.aboutToQuit.connect(self.cleanup)
from app.models.db import profile_session_scope
with profile_session_scope() as session:
is_first_start = app.is_first_start(session)
if is_first_start:
wizard = SetupWizard()
if wizard.exec() == SetupWizard.Rejected:
QtWidgets.qApp.quit()
return
else:
init_data_db()
# Initialize main window
self.ui = self.main_widget()
# Init TrayIcon
self.tray_icon = QtWidgets.QSystemTrayIcon(self)
self.tray_icon.setIcon(QIcon(':images/resources/app_icon.png'))
self.tray_icon.activated.connect(self.on_tray_activated)
show_action = QtWidgets.QAction("Show", self)
quit_action = QtWidgets.QAction("Exit", self)
hide_action = QtWidgets.QAction("Hide", self)
show_action.triggered.connect(self.ui.show)
hide_action.triggered.connect(self.ui.hide)
quit_action.triggered.connect(QtWidgets.qApp.quit)
tray_menu = QtWidgets.QMenu()
tray_menu.addAction(show_action)
tray_menu.addAction(hide_action)
tray_menu.addAction(quit_action)
self.tray_icon.setContextMenu(tray_menu)
self.tray_icon.show()
# Shortcuts
if hasattr(self.ui, 'node'):
self.ui.debug_shortcut = QtWidgets.QShortcut(
'Ctrl+K', self.ui, self.node.kill)
self.ui.debug_shortcut = QtWidgets.QShortcut(
'Ctrl+S', self.ui, self.node.stop)
self.ui.debug_shortcut = QtWidgets.QShortcut(
'Ctrl+R', self.ui, self.node.start)
def set_network(ip_list, isPrivate=True):
if isPrivate:
node.remove_all_node()
# 프라이빗 블록체인에서는 등록된 ip만 브로드캐스팅 할 수 있게함
for ip in ip_list:
node.add_node(Node(ip))
#print(ip)
else:
start_public()
def set_my_node():
print("Set my node")
my_node = Node(util.get_ip_address('en0'))
pri_key, pub_key = key.get_key()
if (pri_key == ''):
print("Invalid Key Info...")
return
node.add_node(my_node)
class testNode(unittest.TestCase):
def setUp(self):
self.node = Node(1, 1)
def test_timestep(self):
self.node.step({1}, 1)
result = self.node.uptime
self.assertEqual(1, result)
def test_charge(self):
result = self.node.charge(4)
self.assertEqual(15, result)
def test_calc_power_usage(self):
result = self.node.calculate_power_sensors({1})
self.assertEqual(0.6, result)
def test_calculate_power_send_data(self):
result = self.node.calculate_power_send_data()
self.assertEqual(0.0001855, result)
def turn_head(self, direction: Direction):
if direction == self.head.direction:
return
current_direction = self.head.direction.value
if (direction.value == 'LEFT' and current_direction == 'RIGHT'
or direction.value == 'RIGHT' and current_direction == 'LEFT'
or direction.value == 'UP' and current_direction == 'DOWN'
or direction.value == 'DOWN' and current_direction == 'UP'):
return
self.head.direction = direction
turn = Node(self.head.x, self.head.y, direction)
for node in self.nodes[1:]:
node.add_turn(turn)
def __init__(self,
nodes: Collection[Node] = None,
chromosome: List[float] = None):
self._nodes = list(nodes) if nodes else [
Node(100, i, Direction.up) for i in range(100, 130, NODE_SIZE)
]
self.points = 0
# 24 input neurons
# 8 angles (0, 45, 90, 135, 180, 225, 270, 315)
# 3 distance meassurements for current angle (to_food, to_wall, to_its_body) normalized to values [0, 1]
# order is in following way [angle 0 to_food, angle 0 to_wall, ang 0 to_its_body, ang 45 to_food, ....]
# angle 0 means straight (from head perspective)
self.chromosome = list(chromosome) if chromosome else [
round(random.uniform(0, 1), 2) for _ in range(24)
]
self.fitness = 0
def initialize_app(flask_app, port, name, peers, honest):
configure_app(flask_app, port)
blueprint = Blueprint('api', __name__, url_prefix='/api')
api.init_app(blueprint)
api.add_namespace(ns_operations)
flask_app.register_blueprint(blueprint)
# Logging
if not os.path.exists('logs'):
os.mkdir('logs')
logging.basicConfig(filename='logs/log_node_{}.log'.format(port),
level=logging.DEBUG,
filemode='w',
format='%(asctime)s %(levelname)-8s %(message)s')
## Initialize client
Node()
Node.instance.port = port
#print(Node.instance.port)
Node.instance.name = name
Node.instance.honest = honest
for peer in peers.split(','):
Node.instance.registerPeer(int(peer))
logging.info("Created client {} {} {}".format(port, name, honest))
#notify peers of own existence
#print (Node.instance.peers)
for peer in Node.instance.peers:
if peer != port:
url = "http://localhost:{}/api/registerPeer/?peer={}".format(
peer, port)
logging.info("registering myself to peer: {}".format(url))
requests.post(url)
api.title = "{} - {}".format(name, api.title)
def set_my_node():
my_node = Node(util.get_ip_address('en0'))
key.generate_key()
log.write("Set my node")
node.add_node(my_node)
if self.currentId() == self.P3_CONNECT:
return self.P7_SYNC
if self.currentId() == self.P4_CHOOSE_ACCOUNT:
if self.button_account_create.isChecked():
return self.P6_CREATE_ACCOUNT
if self.button_account_import.isChecked():
return self.P5_IMPORT_ACCOUNT
if self.currentId() == self.P5_IMPORT_ACCOUNT:
return self.P7_SYNC
return super().nextId()
if __name__ == '__main__':
import sys
import traceback
from PyQt5 import QtWidgets, Qt
from app.updater import Updater
from app.node import Node
from app.helpers import init_logging
sys.excepthook = traceback.print_exception
init_logging()
wrapper = QtWidgets.QApplication(sys.argv)
wrapper.setStyle('fusion')
wrapper.node = Node()
wrapper.updater = Updater()
wizard = SetupWizard()
wizard.show()
sys.exit(wrapper.exec())
class Application(QtWidgets.QApplication):
def __init__(self, args, main_widget=None):
log.debug('init app')
super().__init__(args)
if not app.is_frozen():
sys.excepthook = traceback.print_exception
self.setQuitOnLastWindowClosed(False)
# Initialize application metadata
locale.setlocale(locale.LC_ALL, '')
self.setOrganizationName(app.ORG_NAME)
self.setOrganizationDomain(app.ORG_DOMAIN)
self.setApplicationDisplayName(app.APP_NAME)
self.setApplicationName(app.APP_NAME)
self.setApplicationVersion(app.APP_VERSION)
# Gui Styles and Fonts
self.setStyle('fusion')
font_db = QtGui.QFontDatabase()
font_db.addApplicationFont(':/fonts/resources/Roboto-Light.ttf')
font_db.addApplicationFont(
':/fonts/resources/RobotoCondensed-Regular.ttf')
font_db.addApplicationFont(':/fonts/resources/Oswald-Regular.ttf')
font_db.addApplicationFont(':/fonts/resources/Oswald-SemiBold.ttf')
app_font = QtGui.QFont("Roboto Light")
app_font.setStyleStrategy(QtGui.QFont.PreferAntialias
| QtGui.QFont.PreferQuality)
app_font.setHintingPreference(QtGui.QFont.PreferNoHinting)
self.setFont(app_font)
# Instantiate workers
self.updater = None
self.node = None
self.main_widget = main_widget if main_widget else MainWindow
self.ui = None
self.tray_icon = None
signals.application_start.connect(self.on_application_start)
def on_application_start(self):
self.updater = Updater(self)
self.node = Node(self)
self.aboutToQuit.connect(self.cleanup)
if app.is_first_start():
wizard = SetupWizard()
if wizard.exec() == SetupWizard.Rejected:
QtWidgets.qApp.quit()
return
# Initialize main window
self.ui = self.main_widget()
# Init TrayIcon
self.tray_icon = QtWidgets.QSystemTrayIcon(self)
self.tray_icon.setIcon(QIcon(':images/resources/app_icon.png'))
self.tray_icon.activated.connect(self.on_tray_activated)
show_action = QtWidgets.QAction("Show", self)
quit_action = QtWidgets.QAction("Exit", self)
hide_action = QtWidgets.QAction("Hide", self)
show_action.triggered.connect(self.ui.show)
hide_action.triggered.connect(self.ui.hide)
quit_action.triggered.connect(QtWidgets.qApp.quit)
tray_menu = QtWidgets.QMenu()
tray_menu.addAction(show_action)
tray_menu.addAction(hide_action)
tray_menu.addAction(quit_action)
self.tray_icon.setContextMenu(tray_menu)
self.tray_icon.show()
# Shortcuts
if hasattr(self.ui, 'node'):
self.ui.debug_shortcut = QtWidgets.QShortcut(
'Ctrl+K', self.ui, self.node.kill)
self.ui.debug_shortcut = QtWidgets.QShortcut(
'Ctrl+S', self.ui, self.node.stop)
self.ui.debug_shortcut = QtWidgets.QShortcut(
'Ctrl+R', self.ui, self.node.start)
@pyqtSlot()
def cleanup(self):
"""Final application teardown/cleanup"""
log.debug('init app teardown cleanup')
if self.node is not None:
try:
log.debug('attempt gracefull node shuttdown via rpc')
rpc_result = self.node.stop()
log.debug('rpc stop returned: %s' % rpc_result)
except Exception as e:
log.exception('failed rpc shutdown - try to kill node process')
self.node.kill()
if self.ui is not None:
self.ui.data_db.close()
self.ui.profile_db.close()
if self.tray_icon is not None:
self.tray_icon.deleteLater()
log.debug('finished app teardown cleanup - quitting.')
def on_tray_activated(self, reason):
if reason == QtWidgets.QSystemTrayIcon.DoubleClick:
self.ui.show()
self.ui.activateWindow()
from flask_bootstrap import Bootstrap
from flask_sqlalchemy import SQLAlchemy
from flask_migrate import Migrate
from flask_login import LoginManager
from config import Config, initialize, generate_peers
from app.node import Node
from threading import Thread
from flask import g
apps = []
chord_node = None
nodes = dict()
app = Flask(__name__)
for port in initialize():
chord_node = Node(port, None, None)
nodes[ str(port) ] = chord_node
# print(f"Here is app before import: {app}")
# Config.update_port(port)
app.config.from_object(Config)
db = SQLAlchemy(app)
migrate = Migrate(app, db)
login = LoginManager(app)
login.login_view = "login"
login.login_message = "Please log in to access this page."
bootstrap = Bootstrap(str(port), app)
app.chord_node = chord_node
from app import routes, models
# Thread(target=app.run, kwargs={"port":port}).start()
apps.append([app, chord_node])
def setUp(self):
self.node = Node(1, 1)
def build_clients():
my_node_1 = Node()
my_node_1.run()
my_node_2 = Node()
my_node_2.run()
my_node_3 = Node()
my_node_3.run()
my_node_4 = Node()
my_node_4.run()
return my_node
#!/usr/bin/env python
#encoding: utf-8
from app.node import Node
import socket
import sys
if len(sys.argv) > 1:
command = sys.argv[1]
if command == 'who':
""" Get node id corresponding to ip/port """
my_node = Node()
target_ip = sys.argv[2]
target_port = int(sys.argv[3])
my_node.send_presentation_request((target_ip, target_port))
elif command == 'ping':
""" Send ping request """
my_node = Node()
target_ip = sys.argv[2]
target_port = int(sys.argv[3])
if my_node.ping(('', target_ip, target_port)) == 0:
print("Online")
else:
print("Offline")
elif command == 'get':
""" Get topic """
my_node = Node()
my_node.get_topic(sys.argv[2])
""" Run node and wait for response """
my_node.run()
elif command == 'add':
