def run():
client = Peer("127.0.0.1",
1012,
is_root=False,
root_address=ROOT_ADDRESS,
command_line=False)
ClientGUIThread(client).start()
client.run()
class Screen_manager(ScreenManager):
def __init__(self, home, **kwargs):
super().__init__(**kwargs)
self.peer = None
self.is_root = False
self.address = None
self.root_address = None
self.home = home
def print(self, s):
print(s)
def set_is_root(self, input):
self.is_root = input
def set_address(self, ip, port):
self.address = Node.parse_address((ip, port))
print(self.address)
def set_root_address(self, ip, port):
self.root_address = Node.parse_address((ip, port))
print(self.root_address)
def start_peer(self):
self.peer = Peer(self.address[0], self.address[1], self.is_root, self,
self.root_address)
self.peer.setDaemon(True)
self.peer.start()
def set(self):
self.home.timer = '0'
self.home.ip = self.address[0]
self.home.port = self.address[1]
if self.is_root:
self.home.root_client = 'Root'
else:
self.home.root_client = 'Client'
self.home.first_build()
self.home.peer = self.peer
self.home.update_stats()
def display_message(self, message):
self.home.display_message(message)
def display_pkt(self, pkt):
self.home.display_pkt(pkt)
print('header: ')
print(pkt.get_header())
print('body: ')
print(str(pkt.get_body()))
def update_stats(self):
self.home.update_stats()
def client(event=None):
server_port = simpledialog.askinteger("Input",
"Root Port?",
parent=top,
minvalue=0,
maxvalue=65535)
if server_port is None:
return
port = simpledialog.askinteger("Input",
"Server Port?",
parent=top,
minvalue=0,
maxvalue=65535)
if port is None:
return
top.destroy()
interface = GraphicalUserInterface(False)
client = Peer("127.000.000.001",
port,
is_root=False,
root_address=("127.000.000.001", server_port),
gui=True,
interface=interface)
def run_peer():
client.run()
threading.Thread(target=run_peer, daemon=True).start()
interface.run()
def create_server(self):
self.peer = Peer("127.0.0.1", 10000, is_root=True)
self.port = self.peer.server_port
self.address = (self.peer.server_ip, self.peer.server_port)
self.peer.UI.name = self.name
print("SERVER ADDED")
thread = threading.Thread(target=self.peer.run)
thread.start()
def create_client(self):
self.peer = Peer("127.0.0.1", self.port, is_root=False, root_address=("127.0.0.1", 10000))
self.port = self.peer.server_port
self.address = (self.peer.server_ip, self.peer.server_port)
self.peer.UI.name = self.name
print("CLIENT ADDED")
thread = threading.Thread(target=self.peer.run)
thread.start()
def __init__(self):
print('enter ip and port')
ip = input()
port = input()
print("wich one? A f*****g root or an asshole client?")
s = input()
if s == 'root':
self.isRoot = True
self.peer = Peer(ip, int(port), self.isRoot, self)
else:
self.isRoot = False
print('enter server ip and port')
rootIP = input()
rootPort = input()
self.peer = Peer(ip, int(port), self.isRoot, self,
(rootIP, rootPort))
self.peer_buffer = self.peer.ui_buffer
self.peer.start()
self.reader = InputReader(self)
self.reader.start()
class UI:
def __init__(self):
print('enter ip and port')
ip = input()
port = input()
print("wich one? A f*****g root or an asshole client?")
s = input()
if s == 'root':
self.isRoot = True
self.peer = Peer(ip, int(port), self.isRoot, self)
else:
self.isRoot = False
print('enter server ip and port')
rootIP = input()
rootPort = input()
self.peer = Peer(ip, int(port), self.isRoot, self,
(rootIP, rootPort))
self.peer_buffer = self.peer.ui_buffer
self.peer.start()
self.reader = InputReader(self)
self.reader.start()
def display_message(self, message):
print(message)
def display_pkt(self, pkt):
print('header: ')
print(pkt.get_header())
print('body: ')
print(str(pkt.get_body()))
def print_header(self, header):
print('from')
print(header[0])
print(header[1])
def add_to_buffer(self, shit):
self.peer.add_command(shit)
def root(event=None): # event is passed by binders.
port = simpledialog.askinteger("Input",
"Server Port?",
parent=top,
minvalue=0,
maxvalue=65535)
if port is None:
return
top.destroy()
interface = GraphicalUserInterface(True)
server = Peer("127.000.000.001",
port,
is_root=True,
gui=True,
interface=interface)
def run_peer():
server.run()
threading.Thread(target=run_peer, daemon=True).start()
interface.run()
from src.Peer import Peer
if __name__ == "__main__":
server = Peer("insert IP Address", "Insert Port as Int", is_root=True)
server.run()
client = Peer("Insert IP Address",
"Insert Port as Int",
is_root=False,
root_address=("Insert IP Address", "Insert Port as Int"))
port = parts_of_command[3]
if not is_ip_correct(ip) or not is_port_ok(port):
print('WRONG_COMMAND')
else:
if parts_of_command[1] == 'client':
if len(parts_of_command) != 6:
print('WRONG COMMAND')
else:
root_ip = parts_of_command[4]
if root_ip == '_': root_ip = '127.000.000.001'
root_port = parts_of_command[5]
if not is_ip_correct(root_ip) or not is_port_ok(root_port):
print('WRONG_COMMAND')
else:
client = Peer(ip,
int(port),
is_root=False,
root_address=(root_ip, int(root_port)))
threading.Thread(target=client.run).start()
client.start_user_interface()
elif parts_of_command[1] == 'root':
if len(parts_of_command) != 4:
print('WRONG COMMAND')
else:
root = Peer(ip, int(port), is_root=True)
threading.Thread(target=root.run).start()
root.start_user_interface()
else:
print('WRONG COMMAND')
def run():
server = Peer(ROOT_IP, ROOT_PORT, is_root=True)
RootGUIThread().start()
server.run()
from src.Peer import Peer
if __name__ == "__main__":
root_address = ('127.0.0.5', 3536)
server = Peer(root_address[0], root_address[1], is_root=True)
print(root_address)
server.run()
from src.Peer import Peer
import threading
if __name__ == "__main__":
server = Peer("127.000.000.001", 3652, is_root=True)
threading.Thread(target=server.run).start()
client = Peer("127.000.000.001", 35315, is_root=False,
root_address=("127.000.000.001", 3652))
threading.Thread(target=client.run).start()
from src.Peer import Peer
root_address = ('127.0.0.5', 3536)
peer_address = ("127.0.0.4", 8014)
peer = Peer(peer_address[0],
peer_address[1],
is_root=False,
root_address=root_address)
print(peer_address)
peer.run()
from src.Peer import Peer
ROOT_IP = "127.0.0.1"
ROOT_PORT = 5050
ROOT_ADDRESS = (ROOT_IP, ROOT_PORT)
if __name__ == "__main__":
server = Peer(ROOT_IP, ROOT_PORT, is_root=True)
server.run()
from src.Peer import Peer
from src.tools.NetworkGraph import NetworkGraph
if __name__ == "__main__":
server = Peer("127.0.0.1", 64004, is_root=True)
server.run()
#client = Peer("127.0.0.1", 66001,
# is_root=False,root_address=("127.0.0.1", 65000))
def start_peer(self):
self.peer = Peer(self.address[0], self.address[1], self.is_root, self,
self.root_address)
self.peer.setDaemon(True)
self.peer.start()
from RunRoot import ROOT_ADDRESS
from src.Peer import Peer
if __name__ == "__main__":
client = Peer("127.0.0.1", 1012, is_root=False, root_address=ROOT_ADDRESS)
client.run()
from src.Peer import Peer
from src.tools.NetworkGraph import NetworkGraph
if __name__ == "__main__":
# server = Peer("127.0.0.1", 65000, is_root=True)
# server.run()
client = Peer("127.0.0.1", 61004,
is_root=False,root_address=("127.0.0.1", 64004))
client.run()
from src.Peer import Peer
if __name__ == "__main__":
server = Peer("192.168.202.221", 5356, is_root=True)
server.start_user_interface()
server.run()
from src.Peer import Peer
if __name__ == "__main__":
side = input()
if side == '1':
port = int(input("port:"))
server = Peer("127.000.000.001", port, is_root=True)
server.run()
else:
server_port = int(input("server port:"))
port = int(input("port:"))
client = Peer("127.000.000.001",
port,
is_root=False,
root_address=("127.000.000.001", server_port))
client.run()
