def add_next_client(self):
connection = self.nextPendingConnection()
ip = connection.peerAddress().toString()[7:]
port = connection.peerPort()
client = Client(ip, port, connection, self)
if ip in self.connections:
connection.disconnectFromHost()
return
client.send(Message(self.get_ip(), self.online, Mode.Neighb))
self.add_client(client)
def export(output_dir: str) -> None:
"""Export collections to csv."""
mongo_client = Client()
mongo_client.set_db()
all_collections = mongo_client.collections()
documents = mongo_client.fetch_documents(all_collections)
df = mongo_client.convert_to_df(documents)
mongo_client.export_to_csv(df, output_dir)
def setUp(self):
# arrange
self.ip = '127.0.0.1'
self.port = 666
with patch('source.server.Server') as mock:
self.server = Server('dude', 666, mock)
self.client = Client(self.ip, self.port, QTcpSocket(), self.server)
self.server.peer_manager.last_client = self.client
self.online = {self.ip: self.server.client_info}
self.message = Message(self.ip, self.online, Mode.Neighb)
class PeerManager:
def __init__(self, server):
self.server = server
def update_connections(self, online):
if len(self.server.connections) >= OPTIMAL_CONNECT_NUMBER:
return
online = list(map(lambda key: (key, online[key].incidents_cnt),
online))
online.sort(key=lambda x: x[1])
i = 0
online_cnt = len(online)
while i < online_cnt and len(
self.server.connections) < OPTIMAL_CONNECT_NUMBER:
ip = online[i][0]
if ip != self.server.get_ip(
) and ip not in self.server.connections:
self.set_connection(ip, self.server.port)
i += 1
self.server.update_client_info()
def set_connection(self, ip, port):
socket = QTcpSocket()
self.last_client = Client(ip, port, socket, self.server)
socket.connected.connect(self._share_data)
self.last_client.connect()
def add_client(self, message):
if message.mode == Mode.Neighb and message.sender_ip not in self.server.connections:
self.server.add_client(self.last_client)
self.server.merge_online(message)
def _share_data(self):
self.last_client.socket.connected.disconnect(self._share_data)
if len(self.server.connections) >= OPTIMAL_CONNECT_NUMBER:
self.last_client.socket.disconnectFromHost()
return
if self.last_client.ip in self.server.connections:
self.last_client.socket.disconnectFromHost()
return
message = Message(self.server.get_ip(), self.server.online,
Mode.Neighb)
self.last_client.send(message)
def test_add_client_to_connections(self):
# arrange
with patch('source.server.Server') as mock:
server = Server('dude', 666, mock)
client = Client('127.0.0.1', 666, QTcpSocket(), server)
# act
server.add_client(client)
# assert
self.assertEqual(server.connections[client.ip], client)
def test_update_client_info(self):
# arrange
with patch('source.server.Server') as mock:
server = Server('dude', 666, mock)
client = Client('127.0.0.1', 666, QTcpSocket(), server)
server.connections[client.ip] = client
# act
server.update_client_info()
# assert
self.assertEqual(server.client_info.incidents_cnt, 1)
def run(phrase: str) -> None:
"""Run scraper."""
scrapper = Scrapper(phrase)
scrapper.get_similar_words()
scrapper.scrap_raw_data()
mongo_client = Client()
mongo_client.set_db()
mongo_client.insert(data=scrapper.scrapped, collection=phrase)
click.echo(f"{len(scrapper.scrapped)} records saved in database.")
from source.client import Client client = Client() client.start()
def show() -> None:
"""Show all collections."""
mongo_client = Client()
mongo_client.set_db()
mongo_client.collections()
def delete(collection_name: str) -> None:
"""Delete collection from DB."""
mongo_client = Client()
mongo_client.set_db()
mongo_client.delete_collection(collection_name)
def set_connection(self, ip, port):
socket = QTcpSocket()
self.last_client = Client(ip, port, socket, self.server)
socket.connected.connect(self._share_data)
self.last_client.connect()