766 lines
31 KiB
Python
766 lines
31 KiB
Python
# Copyright (C) 2020 by eichhornchen, ÿnérant
|
|
# SPDX-License-Identifier: GPL-3.0-or-later
|
|
|
|
from datetime import datetime
|
|
from random import randint, uniform
|
|
from typing import Any, Tuple
|
|
# from ipaddress import IPv6Address
|
|
from threading import Thread, RLock
|
|
import curses
|
|
import re
|
|
import socket
|
|
import time
|
|
|
|
from .messages import Packet, DataTLV, HelloTLV, GoAwayTLV, GoAwayType, NeighbourTLV
|
|
|
|
|
|
class Hazelnut:
|
|
"""
|
|
A hazelnut is a connected client, with its socket.
|
|
"""
|
|
def __init__(self, nickname: str = None, address: str = "localhost", port: int = 2500):
|
|
self.nickname = nickname
|
|
self.id = -1
|
|
|
|
try:
|
|
# Resolve DNS as an IPv6
|
|
address = socket.getaddrinfo(address, None, socket.AF_INET6)[0][4][0]
|
|
except socket.gaierror:
|
|
# This is not a valid IPv6. Assume it can be resolved as an IPv4, and we use IPv4-mapping
|
|
# to compute a valid IPv6.
|
|
# See https://fr.wikipedia.org/wiki/Adresse_IPv6_mappant_IPv4
|
|
address = "::ffff:" + socket.getaddrinfo(address, None, socket.AF_INET)[0][4][0]
|
|
|
|
self.address = address # IPv6Address(address)
|
|
self.port = port
|
|
|
|
|
|
class Squirrel(Hazelnut):
|
|
"""
|
|
The squirrel is the user of the program. It can speak with other clients, that are called hazelnuts.
|
|
"""
|
|
def __init__(self, instance: Any, nickname: str):
|
|
super().__init__(nickname, instance.bind_address, instance.bind_port)
|
|
|
|
# Random identifier on 64 bits
|
|
self.id = randint(0, 1 << 64 - 1)
|
|
self.incr_nonce = 0
|
|
|
|
# Create UDP socket
|
|
self.socket = socket.socket(socket.AF_INET6, socket.SOCK_DGRAM)
|
|
# Bind the socket
|
|
self.socket.bind((self.address, self.port))
|
|
|
|
self.squinnondation = instance
|
|
|
|
self.input_buffer = ""
|
|
self.input_index = 0
|
|
self.last_line = -1
|
|
|
|
# Lock the refresh function in order to avoid concurrent refresh
|
|
self.refresh_lock = RLock()
|
|
|
|
self.history = []
|
|
self.received_messages = dict()
|
|
self.recent_messages = dict() # of the form [Pkt(DataTLV), date of first reception,
|
|
# dict(neighbour, date of the next send, nb of times it has already been sent)]
|
|
self.history_pad = curses.newpad(curses.LINES - 2, curses.COLS)
|
|
self.input_pad = curses.newpad(1, curses.COLS)
|
|
self.emoji_pad = curses.newpad(18, 12)
|
|
self.emoji_panel_page = -1
|
|
|
|
curses.init_color(curses.COLOR_WHITE, 1000, 1000, 1000)
|
|
for i in range(curses.COLOR_BLACK + 1, curses.COLOR_WHITE):
|
|
curses.init_pair(i + 1, i, curses.COLOR_BLACK)
|
|
|
|
# dictionnaries of neighbours
|
|
self.potentialhazelnuts = dict()
|
|
self.activehazelnuts = dict() # of the form [hazelnut, time of last hello,
|
|
# time of last long hello, is symmetric]
|
|
self.nbNS = 0
|
|
self.minNS = 3 # minimal number of symmetric neighbours a squirrel needs to have.
|
|
|
|
self.add_system_message(f"Listening on {self.address}:{self.port}")
|
|
self.add_system_message(f"I am {self.id}")
|
|
|
|
def new_hazel(self, address: str, port: int) -> Hazelnut:
|
|
"""
|
|
Returns a new hazelnut (with no id nor nickname)
|
|
"""
|
|
hazelnut = Hazelnut(address=address, port=port)
|
|
return hazelnut
|
|
|
|
def is_active(self, hazel: Hazelnut) -> bool:
|
|
return (hazel.address, hazel.port) in self.activehazelnuts
|
|
|
|
def is_potential(self, hazel: Hazelnut) -> bool:
|
|
return (hazel.address, hazel.port) in self.potentialhazelnuts
|
|
|
|
def remove_from_potential(self, address: str, port: int) -> None:
|
|
self.potentialhazelnuts.pop((address, port), None)
|
|
|
|
def find_hazelnut(self, address: str, port: int) -> Hazelnut:
|
|
"""
|
|
Translate an address into a hazelnut. If this hazelnut does not exist,
|
|
creates a new hazelnut.
|
|
"""
|
|
if (address, port) in self.activehazelnuts:
|
|
return self.activehazelnuts[(address, port)][0]
|
|
hazelnut = Hazelnut(address=address, port=port)
|
|
return hazelnut
|
|
|
|
def send_packet(self, client: Hazelnut, pkt: Packet) -> int:
|
|
"""
|
|
Send a formatted packet to a client.
|
|
"""
|
|
self.refresh_lock.acquire()
|
|
if len(pkt) > 1024:
|
|
# The packet is too large to be sent by the protocol. We split the packet in subpackets.
|
|
return sum(self.send_packet(client, subpkt) for subpkt in pkt.split(1024))
|
|
res = self.send_raw_data(client, pkt.marshal())
|
|
self.refresh_lock.release()
|
|
return res
|
|
|
|
def send_raw_data(self, client: Hazelnut, data: bytes) -> int:
|
|
"""
|
|
Send a raw packet to a client.
|
|
"""
|
|
self.refresh_lock.acquire()
|
|
res = self.socket.sendto(data, (client.address, client.port))
|
|
self.refresh_lock.release()
|
|
return res
|
|
|
|
def receive_packet(self) -> Tuple[Packet, Hazelnut]:
|
|
"""
|
|
Receive a packet from the socket and translate it into a Python object.
|
|
Warning: the process is blocking, it should be ran inside a dedicated thread.
|
|
"""
|
|
data, addr = self.receive_raw_data()
|
|
return Packet.unmarshal(data), self.find_hazelnut(addr[0], addr[1])
|
|
|
|
def receive_raw_data(self) -> Tuple[bytes, Any]:
|
|
"""
|
|
Receive a packet from the socket.
|
|
"""
|
|
return self.socket.recvfrom(1024)
|
|
|
|
def wait_for_key(self) -> None:
|
|
"""
|
|
Infinite loop where we are waiting for a key of the user.
|
|
"""
|
|
while True:
|
|
self.refresh_history()
|
|
self.refresh_input()
|
|
if not self.squinnondation.no_emoji:
|
|
self.refresh_emoji_pad()
|
|
try:
|
|
key = self.squinnondation.screen.get_wch(
|
|
curses.LINES - 1, min(3 + len(self.nickname) + self.input_index, curses.COLS - 4))
|
|
except curses.error:
|
|
continue
|
|
|
|
if key == curses.KEY_MOUSE:
|
|
try:
|
|
_, x, y, _, attr = curses.getmouse()
|
|
self.handle_mouse_click(y, x, attr)
|
|
continue
|
|
except curses.error:
|
|
# This is not a valid click
|
|
continue
|
|
|
|
self.handle_key_pressed(key)
|
|
|
|
def handle_key_pressed(self, key: str) -> None: # noqa: C901
|
|
"""
|
|
Process the key press from the user.
|
|
"""
|
|
if key == "\x7f": # backspace
|
|
# delete character at the good position
|
|
if self.input_index:
|
|
self.input_index -= 1
|
|
self.input_buffer = self.input_buffer[:self.input_index] + self.input_buffer[self.input_index + 1:]
|
|
return
|
|
elif key == curses.KEY_LEFT:
|
|
# Navigate in the message to the left
|
|
self.input_index = max(0, self.input_index - 1)
|
|
return
|
|
elif key == curses.KEY_RIGHT:
|
|
# Navigate in the message to the right
|
|
self.input_index = min(len(self.input_buffer), self.input_index + 1)
|
|
return
|
|
elif key == curses.KEY_UP:
|
|
# Scroll up in the history
|
|
self.last_line = min(max(curses.LINES - 3, self.last_line - 1), len(self.history) - 1)
|
|
return
|
|
elif key == curses.KEY_DOWN:
|
|
# Scroll down in the history
|
|
self.last_line = min(len(self.history) - 1, self.last_line + 1)
|
|
return
|
|
elif key == curses.KEY_PPAGE:
|
|
# Page up in the history
|
|
self.last_line = min(max(curses.LINES - 3, self.last_line - (curses.LINES - 3)), len(self.history) - 1)
|
|
return
|
|
elif key == curses.KEY_NPAGE:
|
|
# Page down in the history
|
|
self.last_line = min(len(self.history) - 1, self.last_line + (curses.LINES - 3))
|
|
return
|
|
elif key == curses.KEY_HOME:
|
|
# Place the cursor at the beginning of the typing word
|
|
self.input_index = 0
|
|
return
|
|
elif key == curses.KEY_END:
|
|
# Place the cursor at the end of the typing word
|
|
self.input_index = len(self.input_buffer)
|
|
return
|
|
elif isinstance(key, int):
|
|
# Unmanaged complex key
|
|
return
|
|
elif key != "\n":
|
|
# Insert the pressed key in the current message
|
|
new_buffer = self.input_buffer[:self.input_index] + key + self.input_buffer[self.input_index:]
|
|
if len(DataTLV.construct(f"{self.nickname}: {new_buffer}", None)) > 255 - 8 - 4:
|
|
# The message is too long to be sent once. We don't allow the user to type any other character.
|
|
curses.beep()
|
|
return
|
|
self.input_buffer = new_buffer
|
|
self.input_index += 1
|
|
return
|
|
|
|
# Send message to neighbours
|
|
msg = self.input_buffer
|
|
self.input_buffer = ""
|
|
self.input_index = 0
|
|
|
|
if not msg:
|
|
return
|
|
|
|
msg = f"{self.nickname}: {msg}"
|
|
self.add_message(msg)
|
|
|
|
pkt = Packet.construct(DataTLV.construct(msg, self))
|
|
for hazelnut in list(self.activehazelnuts.values()):
|
|
self.send_packet(hazelnut[0], pkt)
|
|
|
|
def handle_mouse_click(self, y: int, x: int, attr: int) -> None:
|
|
"""
|
|
The user clicks on the screen, at coordinates (y, x).
|
|
According to the position, we can indicate what can be done.
|
|
"""
|
|
|
|
if not self.squinnondation.no_emoji:
|
|
if y == curses.LINES - 1 and x >= curses.COLS - 3:
|
|
# Click on the emoji, open or close the emoji pad
|
|
self.emoji_panel_page *= -1
|
|
elif self.emoji_panel_page > 0 and y == curses.LINES - 4 and x >= curses.COLS - 5:
|
|
# Open next emoji page
|
|
self.emoji_panel_page += 1
|
|
elif self.emoji_panel_page > 1 and y == curses.LINES - curses.LINES // 2 - 1 \
|
|
and x >= curses.COLS - 5:
|
|
# Open previous emoji page
|
|
self.emoji_panel_page -= 1
|
|
elif self.emoji_panel_page > 0 and y >= curses.LINES // 2 - 1 and x >= curses.COLS // 2 - 1:
|
|
pad_y, pad_x = y - (curses.LINES - curses.LINES // 2) + 1, \
|
|
(x - (curses.COLS - curses.COLS // 3) + 1) // 2
|
|
# Click on an emoji on the pad to autocomplete an emoji
|
|
self.click_on_emoji_pad(pad_y, pad_x)
|
|
|
|
def click_on_emoji_pad(self, pad_y: int, pad_x: int) -> None:
|
|
"""
|
|
The emoji pad contains the list of all available emojis.
|
|
Clicking on a emoji auto-complete the emoji in the input pad.
|
|
"""
|
|
import emoji
|
|
from emoji import unicode_codes
|
|
|
|
height, width = self.emoji_pad.getmaxyx()
|
|
height -= 1
|
|
width -= 1
|
|
|
|
emojis = list(unicode_codes.UNICODE_EMOJI)
|
|
emojis = [c for c in emojis if len(c) == 1]
|
|
size = (height - 2) * (width - 4) // 2
|
|
page = emojis[(self.emoji_panel_page - 1) * size:self.emoji_panel_page * size]
|
|
index = pad_y * (width - 4) // 2 + pad_x
|
|
char = page[index]
|
|
if char:
|
|
demojized = emoji.demojize(char)
|
|
if char != demojized:
|
|
for c in reversed(demojized):
|
|
curses.ungetch(c)
|
|
|
|
def add_message(self, msg: str) -> None:
|
|
"""
|
|
Store a new message into the history.
|
|
"""
|
|
self.history.append(msg)
|
|
if self.last_line == len(self.history) - 2:
|
|
self.last_line += 1
|
|
|
|
def receive_message_from(self, tlv: DataTLV, msg: str, sender_id: int, nonce: int, relay: Hazelnut) -> bool:
|
|
"""
|
|
This method is called by a DataTLV, sent by a real person.
|
|
This add the message in the history if not already done.
|
|
Returns True iff the message was not already received previously.
|
|
"""
|
|
if (sender_id, nonce) not in self.received_messages:
|
|
# If it is a new message, add it to recent_messages
|
|
d = self.make_inundation_dict()
|
|
pkt = Packet().construct(tlv)
|
|
self.recent_messages[(sender_id, nonce)] = [pkt, time.time(), d]
|
|
|
|
# in all cases, remove the sender from the list of neighbours to be inundated
|
|
self.remove_from_inundation(relay, sender_id, nonce)
|
|
|
|
if (sender_id, nonce) in self.received_messages:
|
|
return False
|
|
|
|
self.add_message(msg) # for display purposes
|
|
self.received_messages[(sender_id, nonce)] = Message(msg, sender_id, nonce)
|
|
return True
|
|
|
|
def make_inundation_dict(self) -> dict:
|
|
"""
|
|
Takes the activehazels dictionnary and returns a list of [hazel, date+random, 0]
|
|
"""
|
|
res = dict()
|
|
hazels = list(self.activehazelnuts.items())
|
|
for key, hazel in hazels:
|
|
if hazel[3]: # Only if the neighbour is symmetric
|
|
next_send = uniform(1, 2)
|
|
res[key] = [hazel[0], time.time() + next_send, 0]
|
|
return res
|
|
|
|
def remove_from_inundation(self, hazel: Hazelnut, sender_id: int, nonce: int) -> None:
|
|
"""
|
|
Remove the sender from the list of neighbours to be inundated
|
|
"""
|
|
self.refresh_lock.acquire()
|
|
if (sender_id, nonce) in self.recent_messages:
|
|
# If a peer is late in its acknowledgement, the absence of the previous if causes an error.
|
|
self.recent_messages[(sender_id, nonce)][2].pop((hazel.address, hazel.port), None)
|
|
|
|
if not self.recent_messages[(sender_id, nonce)][2]: # If dictionnary is empty, remove the message
|
|
self.recent_messages.pop((sender_id, nonce), None)
|
|
self.refresh_lock.release()
|
|
|
|
def clean_inundation(self) -> None:
|
|
"""
|
|
Remove messages which are overdue (older than 2 minutes) from the inundation dictionnary.
|
|
"""
|
|
self.refresh_lock.acquire()
|
|
|
|
for key in self.recent_messages:
|
|
if time.time() - self.recent_messages[key][1] > 120:
|
|
self.recent_messages.pop(key)
|
|
|
|
self.refresh_lock.release()
|
|
|
|
def main_inundation(self) -> None:
|
|
"""
|
|
The main inundation function.
|
|
"""
|
|
self.refresh_lock.acquire()
|
|
|
|
for key in self.recent_messages:
|
|
k = list(self.recent_messages[key][2].keys())
|
|
for key2 in k:
|
|
if time.time() >= self.recent_messages[key][2][key2][1]:
|
|
self.add_system_message(f"inundating {self.recent_messages[key][2][key2][0].id} with message {key}")
|
|
|
|
# send the packet if it is overdue
|
|
self.send_packet(self.recent_messages[key][2][key2][0], self.recent_messages[key][0])
|
|
|
|
# change the time until the next send
|
|
a = self.recent_messages[key][2][key2][2]
|
|
self.recent_messages[key][2][key2][2] = a + 1
|
|
next_send = uniform(2 ** (a - 1), 2 ** a)
|
|
self.recent_messages[key][2][key2][1] = time.time() + next_send
|
|
|
|
if self.recent_messages[key][2][key2][2] >= 5: # the neighbour is not reactive enough
|
|
gatlv = GoAwayTLV().construct(GoAwayType.TIMEOUT, f"{self.id} No acknowledge")
|
|
pkt = Packet().construct(gatlv)
|
|
self.send_packet(self.recent_messages[key][2][key2][0], pkt)
|
|
self.activehazelnuts.pop(key2)
|
|
self.potentialhazelnuts[key2] = self.recent_messages[key][2][key2][0]
|
|
self.recent_messages[key][2].pop(key2)
|
|
|
|
self.refresh_lock.release()
|
|
|
|
def add_system_message(self, msg: str) -> None:
|
|
"""
|
|
Add a new system log message.
|
|
TODO: Configure logging levels to ignore some messages.
|
|
"""
|
|
return self.add_message(f"system: *{msg}*" if not self.squinnondation.no_markdown else f"system: {msg}")
|
|
|
|
def print_markdown(self, pad: Any, y: int, x: int, msg: str,
|
|
bold: bool = False, italic: bool = False, underline: bool = False, strike: bool = False) -> int:
|
|
"""
|
|
Parse a markdown-formatted text and format the text as bold, italic or text text.
|
|
***text***: bold, italic
|
|
**text**: bold
|
|
*text*: italic
|
|
__text__: underline
|
|
_text_: italic
|
|
~~text~~: strikethrough
|
|
"""
|
|
# Replace :emoji_name: by the good emoji
|
|
if not self.squinnondation.no_emoji:
|
|
import emoji
|
|
msg = emoji.emojize(msg, use_aliases=True)
|
|
|
|
if self.squinnondation.no_markdown:
|
|
pad.addstr(y, x, msg)
|
|
return len(msg)
|
|
|
|
underline_match = re.match("(.*)__(.*)__(.*)", msg)
|
|
if underline_match:
|
|
before, text, after = underline_match.group(1), underline_match.group(2), underline_match.group(3)
|
|
len_before = self.print_markdown(pad, y, x, before, bold, italic, underline)
|
|
len_mid = self.print_markdown(pad, y, x + len_before, text, bold, italic, not underline)
|
|
len_after = self.print_markdown(pad, y, x + len_before + len_mid, after, bold, italic, underline)
|
|
return len_before + len_mid + len_after
|
|
|
|
italic_match = re.match("(.*)_(.*)_(.*)", msg)
|
|
if italic_match:
|
|
before, text, after = italic_match.group(1), italic_match.group(2), italic_match.group(3)
|
|
len_before = self.print_markdown(pad, y, x, before, bold, italic, underline)
|
|
len_mid = self.print_markdown(pad, y, x + len_before, text, bold, not italic, underline)
|
|
len_after = self.print_markdown(pad, y, x + len_before + len_mid, after, bold, italic, underline)
|
|
return len_before + len_mid + len_after
|
|
|
|
bold_italic_match = re.match("(.*)\\*\\*\\*(.*)\\*\\*\\*(.*)", msg)
|
|
if bold_italic_match:
|
|
before, text, after = bold_italic_match.group(1), bold_italic_match.group(2),\
|
|
bold_italic_match.group(3)
|
|
len_before = self.print_markdown(pad, y, x, before, bold, italic, underline, strike)
|
|
len_mid = self.print_markdown(pad, y, x + len_before, text, not bold, not italic, underline, strike)
|
|
len_after = self.print_markdown(pad, y, x + len_before + len_mid, after, bold, italic, underline, strike)
|
|
return len_before + len_mid + len_after
|
|
|
|
bold_match = re.match("(.*)\\*\\*(.*)\\*\\*(.*)", msg)
|
|
if bold_match:
|
|
before, text, after = bold_match.group(1), bold_match.group(2), bold_match.group(3)
|
|
len_before = self.print_markdown(pad, y, x, before, bold, italic, underline, strike)
|
|
len_mid = self.print_markdown(pad, y, x + len_before, text, not bold, italic, underline, strike)
|
|
len_after = self.print_markdown(pad, y, x + len_before + len_mid, after, bold, italic, underline, strike)
|
|
return len_before + len_mid + len_after
|
|
|
|
italic_match = re.match("(.*)\\*(.*)\\*(.*)", msg)
|
|
if italic_match:
|
|
before, text, after = italic_match.group(1), italic_match.group(2), italic_match.group(3)
|
|
len_before = self.print_markdown(pad, y, x, before, bold, italic, underline, strike)
|
|
len_mid = self.print_markdown(pad, y, x + len_before, text, bold, not italic, underline, strike)
|
|
len_after = self.print_markdown(pad, y, x + len_before + len_mid, after, bold, italic, underline, strike)
|
|
return len_before + len_mid + len_after
|
|
|
|
strike_match = re.match("(.*)~~(.*)~~(.*)", msg)
|
|
if strike_match:
|
|
before, text, after = strike_match.group(1), strike_match.group(2), strike_match.group(3)
|
|
len_before = self.print_markdown(pad, y, x, before, bold, italic, underline, strike)
|
|
len_mid = self.print_markdown(pad, y, x + len_before, text, bold, italic, underline, not strike)
|
|
len_after = self.print_markdown(pad, y, x + len_before + len_mid, after, bold, italic, underline, strike)
|
|
return len_before + len_mid + len_after
|
|
|
|
size = len(msg)
|
|
|
|
attrs = 0
|
|
attrs |= curses.A_BOLD if bold else 0
|
|
attrs |= curses.A_ITALIC if italic else 0
|
|
attrs |= curses.A_UNDERLINE if underline else 0
|
|
if strike:
|
|
msg = "".join(c + "\u0336" for c in msg)
|
|
|
|
remaining_lines = curses.LINES - 3 - (y + x // (curses.COLS - 1)) + 1
|
|
if remaining_lines > 0:
|
|
# Don't print the end of the line if it is too long
|
|
space_left_on_line = (curses.COLS - 2) - (x % (curses.COLS - 1))
|
|
msg = msg[:space_left_on_line + max(0, (curses.COLS - 1) * (remaining_lines - 1))]
|
|
if msg:
|
|
pad.addstr(y + x // (curses.COLS - 1), x % (curses.COLS - 1), msg, attrs)
|
|
return size
|
|
|
|
def refresh_history(self) -> None:
|
|
"""
|
|
Rewrite the history of the messages.
|
|
"""
|
|
self.refresh_lock.acquire()
|
|
|
|
y, x = self.squinnondation.screen.getmaxyx()
|
|
if curses.is_term_resized(curses.LINES, curses.COLS):
|
|
curses.resizeterm(y, x)
|
|
self.history_pad.resize(curses.LINES - 2, curses.COLS - 1)
|
|
self.input_pad.resize(1, curses.COLS - 1)
|
|
|
|
self.history_pad.erase()
|
|
|
|
y_offset = 0
|
|
for i, msg in enumerate(self.history[max(0, self.last_line - curses.LINES + 3):self.last_line + 1]):
|
|
if i + y_offset > curses.LINES - 3:
|
|
break
|
|
|
|
msg = re.sub("([^:]*): (.*)", "<\\1> \\2", msg, 1)
|
|
|
|
if not re.match("<.*> .*", msg):
|
|
msg = "<unknown> " + msg
|
|
match = re.match("<(.*)> (.*)", msg)
|
|
nickname = match.group(1)
|
|
msg = match.group(2)
|
|
full_msg = f"<{nickname}> {msg}"
|
|
color_id = sum(ord(c) for c in nickname) % 6 + 1
|
|
true_width = self.print_markdown(self.history_pad, i + y_offset, 0, full_msg)
|
|
self.history_pad.addstr(i + y_offset, 1, nickname, curses.A_BOLD | curses.color_pair(color_id + 1))
|
|
y_offset += true_width // (curses.COLS - 1)
|
|
self.history_pad.refresh(0, 0, 0, 0, curses.LINES - 2, curses.COLS)
|
|
|
|
self.refresh_lock.release()
|
|
|
|
def refresh_input(self) -> None:
|
|
"""
|
|
Redraw input line. Must not be called while the message is not sent.
|
|
"""
|
|
self.refresh_lock.acquire()
|
|
|
|
self.input_pad.erase()
|
|
color_id = sum(ord(c) for c in self.nickname) % 6 + 1
|
|
self.input_pad.addstr(0, 0, "<")
|
|
self.input_pad.addstr(0, 1, self.nickname, curses.A_BOLD | curses.color_pair(color_id + 1))
|
|
self.input_pad.addstr(0, 1 + len(self.nickname), "> ")
|
|
msg = self.input_buffer
|
|
if self.input_index >= curses.COLS - len(self.nickname) - 7:
|
|
msg = msg[self.input_index - (curses.COLS - len(self.nickname) - 7):self.input_index]
|
|
msg = msg[:curses.COLS - len(self.nickname) - 7]
|
|
self.input_pad.addstr(0, 3 + len(self.nickname), msg)
|
|
if not self.squinnondation.no_emoji:
|
|
self.input_pad.addstr(0, self.input_pad.getmaxyx()[1] - 3, "😀")
|
|
self.input_pad.refresh(0, 0, curses.LINES - 1, 0, curses.LINES - 1, curses.COLS - 1)
|
|
|
|
self.refresh_lock.release()
|
|
|
|
def refresh_emoji_pad(self) -> None:
|
|
"""
|
|
Display the emoji pad if necessary.
|
|
"""
|
|
if self.squinnondation.no_emoji:
|
|
return
|
|
|
|
from emoji import unicode_codes
|
|
|
|
self.refresh_lock.acquire()
|
|
|
|
self.emoji_pad.erase()
|
|
|
|
if self.emoji_panel_page > 0:
|
|
height, width = curses.LINES // 2, curses.COLS // 3
|
|
self.emoji_pad.resize(height + 1, width + 1)
|
|
self.emoji_pad.addstr(0, 0, "┏" + (width - 2) * "━" + "┓")
|
|
self.emoji_pad.addstr(0, (width - 14) // 2, " == EMOJIS == ")
|
|
for i in range(1, height):
|
|
self.emoji_pad.addstr(i, 0, "┃" + (width - 2) * " " + "┃")
|
|
self.emoji_pad.addstr(height - 1, 0, "┗" + (width - 2) * "━" + "┛")
|
|
|
|
emojis = list(unicode_codes.UNICODE_EMOJI)
|
|
emojis = [c for c in emojis if len(c) == 1]
|
|
size = (height - 2) * (width - 4) // 2
|
|
page = emojis[(self.emoji_panel_page - 1) * size:self.emoji_panel_page * size]
|
|
|
|
if self.emoji_panel_page != 1:
|
|
self.emoji_pad.addstr(1, width - 2, "⬆")
|
|
if len(page) == size:
|
|
self.emoji_pad.addstr(height - 2, width - 2, "⬇")
|
|
|
|
for i in range(height - 2):
|
|
for j in range((width - 4) // 2 + 1):
|
|
index = i * (width - 4) // 2 + j
|
|
if index < len(page):
|
|
self.emoji_pad.addstr(i + 1, 2 * j + 1, page[index])
|
|
|
|
self.emoji_pad.refresh(0, 0, curses.LINES - height - 2, curses.COLS - width - 2,
|
|
curses.LINES - 2, curses.COLS - 2)
|
|
|
|
self.refresh_lock.release()
|
|
|
|
def potential_to_contact(self) -> list:
|
|
"""
|
|
Returns a list of hazelnuts the squirrel should contact if it does
|
|
not have enough symmetric neighbours.
|
|
"""
|
|
self.refresh_lock.acquire()
|
|
|
|
res = []
|
|
lp = len(self.potentialhazelnuts)
|
|
val = list(self.potentialhazelnuts.values())
|
|
|
|
for i in range(min(lp, max(0, self.minNS - self.nbNS))):
|
|
a = randint(0, lp - 1)
|
|
res.append(val[a])
|
|
|
|
self.refresh_lock.release()
|
|
return res
|
|
|
|
def send_hello(self) -> None:
|
|
"""
|
|
Sends a long HelloTLV to all active neighbours.
|
|
"""
|
|
self.refresh_lock.acquire()
|
|
|
|
for hazelnut in self.activehazelnuts.values():
|
|
htlv = HelloTLV().construct(16, self, hazelnut[0])
|
|
pkt = Packet().construct(htlv)
|
|
self.send_packet(hazelnut[0], pkt)
|
|
|
|
self.refresh_lock.release()
|
|
|
|
def verify_activity(self) -> None:
|
|
"""
|
|
All neighbours that have not sent a HelloTLV in the last 2
|
|
minutes are considered not active.
|
|
"""
|
|
self.refresh_lock.acquire()
|
|
|
|
val = list(self.activehazelnuts.values()) # create a copy because the dict size will change
|
|
|
|
for hazelnut in val:
|
|
if time.time() - hazelnut[1] > 2 * 60:
|
|
gatlv = GoAwayTLV().construct(GoAwayType.TIMEOUT, "you did not talk to me")
|
|
pkt = Packet().construct(gatlv)
|
|
self.send_packet(hazelnut[0], pkt)
|
|
self.activehazelnuts.pop((hazelnut[0].address, hazelnut[0].port))
|
|
self.potentialhazelnuts[(hazelnut[0].address, hazelnut[0].port)] = hazelnut[0]
|
|
|
|
self.refresh_lock.release()
|
|
|
|
def send_neighbours(self) -> None:
|
|
"""
|
|
Update the number of symmetric neighbours and
|
|
send all neighbours NeighbourTLV
|
|
"""
|
|
self.refresh_lock.acquire()
|
|
|
|
nb_ns = 0
|
|
# could send the same to all neighbour, but it means that neighbour
|
|
# A could receive a message with itself in it -> if the others do not pay attention, trouble
|
|
for key, hazelnut in self.activehazelnuts.items():
|
|
if time.time() - hazelnut[2] <= 2 * 60:
|
|
nb_ns += 1
|
|
self.activehazelnuts[key][3] = True
|
|
ntlv = NeighbourTLV().construct(hazelnut[0].address, hazelnut[0].port)
|
|
pkt = Packet().construct(ntlv)
|
|
for destination in self.activehazelnuts.values():
|
|
if destination[0].id != hazelnut[0].id:
|
|
self.send_packet(destination[0], pkt)
|
|
else:
|
|
self.activehazelnuts[key][3] = False
|
|
self.nbNS = nb_ns
|
|
|
|
self.refresh_lock.release()
|
|
|
|
|
|
class Worm(Thread):
|
|
"""
|
|
The worm is the hazel listener.
|
|
It always waits for an incoming packet, then it treats it, and continues to wait.
|
|
It is in a dedicated thread.
|
|
"""
|
|
def __init__(self, squirrel: Squirrel, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.squirrel = squirrel
|
|
|
|
def run(self) -> None:
|
|
while True:
|
|
try:
|
|
pkt, hazelnut = self.squirrel.receive_packet()
|
|
pkt.validate_data()
|
|
except ValueError as error:
|
|
self.squirrel.add_system_message("An error occurred while receiving a packet: {}".format(error))
|
|
else:
|
|
for tlv in pkt.body:
|
|
tlv.handle(self.squirrel, hazelnut)
|
|
self.squirrel.refresh_history()
|
|
self.squirrel.refresh_input()
|
|
|
|
|
|
class HazelManager(Thread):
|
|
"""
|
|
A process to cleanly manage the squirrel's neighbours
|
|
"""
|
|
def __init__(self, squirrel: Squirrel, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.squirrel = squirrel
|
|
self.last_potential = 0
|
|
self.last_check = 0
|
|
self.last_neighbour = 0
|
|
|
|
htlv = HelloTLV().construct(8, self.squirrel)
|
|
pkt = Packet().construct(htlv)
|
|
self.hellopkt = pkt
|
|
|
|
def run(self) -> None:
|
|
while True:
|
|
# First part of neighbour management: ensure the squirrel has enough
|
|
# symmetric neighbours.
|
|
if time.time() - self.last_potential > 30:
|
|
to_contact = self.squirrel.potential_to_contact()
|
|
|
|
for hazel in to_contact:
|
|
self.squirrel.send_packet(hazel, self.hellopkt)
|
|
self.last_potential = time.time()
|
|
|
|
# Second part: send long HelloTLVs to neighbours every 30 seconds
|
|
if time.time() - self.last_check > 30:
|
|
self.squirrel.add_system_message(f"I have {len(list(self.squirrel.activehazelnuts.values()))} friends")
|
|
self.squirrel.send_hello()
|
|
self.last_check = time.time()
|
|
|
|
# Third part: get rid of inactive neighbours
|
|
self.squirrel.verify_activity()
|
|
|
|
# Fourth part: verify symmetric neighbours and send NeighbourTLV every minute
|
|
if time.time() - self.last_neighbour > 60:
|
|
self.squirrel.send_neighbours()
|
|
self.last_neighbour = time.time()
|
|
|
|
# Avoid infinite loops
|
|
time.sleep(1)
|
|
|
|
|
|
class Inondator(Thread):
|
|
"""
|
|
A process to manage the inondation
|
|
"""
|
|
def __init__(self, squirrel: Squirrel, *args, **kwargs):
|
|
super().__init__(*args, **kwargs)
|
|
self.squirrel = squirrel
|
|
self.last_check = 0
|
|
|
|
def run(self) -> None:
|
|
while True:
|
|
# clean the dictionnary
|
|
if time.time() - self.last_check > 30:
|
|
self.squirrel.clean_inundation()
|
|
self.last_check = time.time()
|
|
|
|
# inundate
|
|
self.squirrel.main_inundation()
|
|
|
|
# Avoid infinite loops
|
|
time.sleep(1)
|
|
|
|
|
|
class Message:
|
|
"""
|
|
This class symbolises the data sent by a real client, excluding system messages.
|
|
This is useful to check unicity or to save and load messages.
|
|
"""
|
|
content: str
|
|
# TODO: Replace the id by the good (potential) hazel
|
|
sender_id: int
|
|
nonce: int
|
|
created_at: datetime
|
|
|
|
def __init__(self, content: str, sender_id: int, nonce: int, created_at: datetime = None):
|
|
self.content = content
|
|
self.sender_id = sender_id
|
|
self.nonce = nonce
|
|
self.created_at = created_at or datetime.now()
|