def __init__(self, server_address, set_root=False, set_register=False):
"""
The Node object constructor.
This object is our low-level abstraction for other peers in the network.
Every node has a ClientSocket that should bind to the Node TCPServer address.
Warnings:
1. Insert an exception handler when initializing the ClientSocket; when a socket closed here we will face to
an exception and we should detach this Node and clear its output buffer.
:param server_address:
:param set_root:
:param set_register:
"""
self.is_root = set_root
self.is_registered = set_register
self.server_ip = Node.parse_ip(server_address[0])
self.server_port = Node.parse_port(server_address[1])
print("New Node Created\n\tServer Address: ", server_address)
print(self.server_ip, self.server_port)
try:
self.client = ClientSocket(mode=server_address[0],
port=int(server_address[1]),
single_use=False)
except:
raise ConnectionRefusedError
self.out_buff = []
self.in_buff = []
def __init__(self, server_address, set_register=False):
"""
The Node object constructor.
This object is our low-level abstraction for other peers in the network.
Every node has a ClientSocket that should bind to the Node TCPServer address.
Warnings:
1. Insert an exception handler when initializing the ClientSocket; when a socket closed here we will face to
an exception and we should detach this Node and clear its output buffer.
:param server_address:
:param set_root:
:param set_register:
"""
self.server_ip = Node.parse_ip(server_address[0])
self.server_port = Node.parse_port(server_address[1])
self.register = set_register
self.out_buff = []
try:
# self.client = ClientSocket(self.server_ip, self.server_port, single_use=False)
self.client = ClientSocket(server_address[0],
server_address[1],
single_use=False)
print("from client connecting to the server: " + server_address)
#print("client address",server_address)
except:
"heree"
self.out_buff.clear()
def __init__(self, server_address, set_root=False, set_register=False):
"""
The Node object constructor.
This object is our low level abstraction for other peers in the network.
Every node has a ClientSocket that should bind to the Node TCPServer address.
Warnings:
1. Insert an exception handler when initialising the ClientSocket; when a socket closed here we will face to
an exception and we should detach this Node and clear it's output buffer.
:param server_address:
:param set_root:
:param set_register:
"""
self.server_ip = Node.parse_ip(server_address[0])
self.server_port = Node.parse_port(server_address[1])
print("Server Address: ", server_address)
self.out_buff = []
self.is_root = set_root
self.is_register_connection = set_register
try:
self.client = ClientSocket(self.server_ip,
int(self.server_port, 10),
single_use=False)
except:
print("Node was detached.")
self.out_buff.clear()
class Node:
def __init__(self,
server_address: Address,
set_register: bool = False) -> None:
"""
The Node object constructor.
This object is our low-level abstraction for other peers in the network.
Every node has a ClientSocket that should bind to the Node TCPServer address.
Warnings:
1. Insert an exception handler when initializing the ClientSocket; when a socket closed here we will face to
an exception and we should detach this Node and clear its output buffer.
:param server_address:
:param set_register:
"""
self.server_ip = parse_ip(server_address[0])
self.server_port = server_address[1]
log(f"Node({server_address}): Initialized.")
self.out_buff: List[Packet] = []
self.is_register = set_register
self.__initialize_client_socket()
def __initialize_client_socket(self):
formatted_ip = ".".join(
str(int(part)) for part in self.server_ip.split("."))
self.client = ClientSocket(formatted_ip,
self.server_port,
single_use=False)
def send_message(self) -> None:
"""
Final function to send buffer to the client's socket.
:return:
"""
for packet in self.out_buff:
response = self.client.send(packet.get_buf())
if response != b'ACK':
log(f"Node({self.get_server_address()}): Message of type {packet.get_type()} not ACKed."
)
self.out_buff.clear()
def add_message_to_out_buff(self, message: Packet) -> None:
"""
Here we will add a new message to the server out_buff, then in 'send_message' will send them.
:param message: The message we want to add to out_buff
:return:
"""
self.out_buff.append(message)
def close(self) -> None:
"""
Closing client's object.
:return:
"""
self.client.close()
def get_server_address(self) -> Address:
"""
:return: Server address in a pretty format.
:rtype: Address
"""
return self.server_ip, self.server_port
def __eq__(self, other) -> bool:
return self.server_ip == other.server_ip and self.server_port == other.server_port \
and self.is_register == other.is_register
def __initialize_client_socket(self):
formatted_ip = ".".join(
str(int(part)) for part in self.server_ip.split("."))
self.client = ClientSocket(formatted_ip,
self.server_port,
single_use=False)
from src.tools.simpletcp.clientsocket import ClientSocket
exitFlag = 0
# in_buf = ""
class Obj:
def __init__(self):
self.in_buf = ""
def get_input(self):
self.in_buf += input("command?")
s1 = ClientSocket("192.168.202.221", 5353, single_use=False)
response = s1.send("Hello, World!")
# s2 = ClientSocket("192.168.202.221", 5353, single_use=False)
# buf = ''
# for i in range(3000):
# buf+='a'
# r1 = s2.send(buf)
# r2 = s2.send("...and hello for the last!")
# s2.close()
# s1.close()
# Display the correspondence
# print("s1 sent\t\tHello, World!")
# print("s1 received\t\t{}".format(response.decode("UTF-8")))
# print("-------------------------------------------------")
class Node:
def __init__(self, server_address, set_root=False, set_register=False):
"""
The Node object constructor.
This object is our low-level abstraction for other peers in the network.
Every node has a ClientSocket that should bind to the Node TCPServer address.
Warnings:
1. Insert an exception handler when initializing the ClientSocket; when a socket closed here we will face to
an exception and we should detach this Node and clear its output buffer.
:param server_address:
:param set_root:
:param set_register:
"""
self.is_root = set_root
self.is_registered = set_register
self.server_ip = Node.parse_ip(server_address[0])
self.server_port = Node.parse_port(server_address[1])
print("New Node Created\n\tServer Address: ", server_address)
print(self.server_ip, self.server_port)
try:
self.client = ClientSocket(mode=server_address[0],
port=int(server_address[1]),
single_use=False)
except:
raise ConnectionRefusedError
self.out_buff = []
self.in_buff = []
def send_message(self):
"""
Final function to send buffer to the client's socket.
:return:
"""
for data in self.out_buff:
rcvd_data = self.client.send(data)
self.in_buff.append(rcvd_data)
self.out_buff = []
def add_message_to_out_buff(self, message):
"""
Here we will add a new message to the server out_buff, then in 'send_message' will send them.
:param message: The message we want to add to out_buff
:return:
"""
self.out_buff.append(message)
def close(self):
"""
Closing client's object.
:return:
"""
self.client.close()
def get_server_address(self):
"""
:return: Server address in a pretty format.
:rtype: tuple
"""
return self.server_ip, self.server_port
@staticmethod
def parse_ip(ip):
"""
Automatically change the input IP format like '192.168.001.001'.
:param ip: Input IP
:type ip: str
:return: Formatted IP
:rtype: str
"""
return '.'.join(str(int(part)).zfill(3) for part in ip.split('.'))
@staticmethod
def parse_port(port):
"""
Automatically change the input IP format like '05335'.
:param port: Input IP
:type port: str
:return: Formatted IP
:rtype: str
"""
return str(int(port)).zfill(5)
class Node:
def __init__(self, server_address, set_register=False):
"""
The Node object constructor.
This object is our low-level abstraction for other peers in the network.
Every node has a ClientSocket that should bind to the Node TCPServer address.
Warnings:
1. Insert an exception handler when initializing the ClientSocket; when a socket closed here we will face to
an exception and we should detach this Node and clear its output buffer.
:param server_address:
:param set_root:
:param set_register:
"""
self.server_ip = Node.parse_ip(server_address[0])
self.server_port = Node.parse_port(server_address[1])
self.register = set_register
self.out_buff = []
try:
# self.client = ClientSocket(self.server_ip, self.server_port, single_use=False)
self.client = ClientSocket(server_address[0],
server_address[1],
single_use=False)
print("from client connecting to the server: " + server_address)
#print("client address",server_address)
except:
"heree"
self.out_buff.clear()
def send_message(self):
"""
Final function to send buffer to the client's socket.
:return:
"""
ans = 'not send'
if len(self.out_buff) == 1 and not self.out_buff[0] == '':
ans = self.client.send(self.out_buff[0])
else:
s = "".join(self.out_buff)
if not s == '':
ans = self.client.send(s)
self.out_buff.clear()
return ans
def add_message_to_out_buff(self, message):
"""
Here we will add a new message to the server out_buff, then in 'send_message' will send them.
:param message: The message we want to add to out_buff
:return:
"""
self.out_buff.append(message)
def close(self):
"""
Closing client's object.
:return:
"""
self.client.close()
def get_server_address(self):
"""
:return: Server address in a pretty format.
:rtype: tuple
"""
return self.server_ip, self.server_port
def is_register(self):
return self.register
@staticmethod
def parse_ip(ip):
"""
Automatically change the input IP format like '192.168.001.001'.
:param ip: Input IP
:type ip: str
:return: Formatted IP
:rtype: str
"""
print(ip)
return '.'.join(str(int(part)).zfill(3) for part in ip.split('.'))
@staticmethod
def parse_port(port):
"""
Automatically change the input IP format like '05335'.
:param port: Input IP
:type port: str
:return: Formatted IP
:rtype: str
"""
return str(int(port)).zfill(5)
@staticmethod
def parse_address(address):
return Node.parse_ip(address[0]), Node.parse_port(address[1])
class Node:
def __init__(self, server_address, set_root=False, set_register=False):
"""
The Node object constructor.
This object is our low level abstraction for other peers in the network.
Every node has a ClientSocket that should bind to the Node TCPServer address.
Warnings:
1. Insert an exception handler when initialising the ClientSocket; when a socket closed here we will face to
an exception and we should detach this Node and clear it's output buffer.
:param server_address:
:param set_root:
:param set_register:
"""
self.server_ip = Node.parse_ip(server_address[0])
self.server_port = Node.parse_port(server_address[1])
print("Server Address: ", server_address)
self.out_buff = []
self.is_root = set_root
self.is_register_connection = set_register
try:
self.client = ClientSocket(self.server_ip,
int(self.server_port, 10),
single_use=False)
except:
print("Node was detached.")
self.out_buff.clear()
def send_message(self):
"""
Final function to send buffer to the clients socket.
:return:
"""
for b in self.out_buff:
response = self.client.send(bytes(b))
print("Response: ", response)
if response != b'ACK':
print("The ",
self.get_server_address()[0], ": ",
self.get_server_address()[1],
" did not response with b'ACK'. ", response)
self.out_buff.clear()
def add_message_to_out_buff(self, message):
"""
Here we will add new message to the server out_buff, then in 'send_message' will send them.
:param message: The message we want to add to out_buff
:return:
"""
self.out_buff.append(message)
def close(self):
"""
Closing client object.
:return:
"""
self.client.close()
def get_server_address(self):
"""
:return: Server address in a pretty format.
:rtype: tuple
"""
return self.server_ip, self.server_port
def get_standard_server_address(self):
"""
:return: Server address in standard format.
:rtype: tuple
"""
port_prime = int(self.server_port)
return self.server_ip, port_prime
@staticmethod
def parse_ip(ip):
"""
Automatically change the input IP format like '192.168.001.001'.
:param ip: Input IP
:type ip: str
:return: Formatted IP
:rtype: str
"""
return '.'.join(str(int(part)).zfill(3) for part in ip.split('.'))
@staticmethod
def parse_port(port):
"""
Automatically change the input IP format like '05335'.
:param port: Input IP
:type port: str
:return: Formatted IP
:rtype: str
"""
return str(int(port)).zfill(5)