def authentication_and_create_handler(self, conn, next_id=None):
# принимает один байт для подтверждения
# отправляет следующий номер либо из генератора id_clients, либо из id_PP
bytes_message = conn.recv(cnf.SIZE_HEADER)
if not bytes_message:
print("disconnect")
return False
try:
message = cnf.to_data_message_from_bytes_2(bytes_message)
except:
return False
if message.cmd:
print("пришло что-то странное.... ")
print(message)
return False
elif message.cmd == CMD.NEW_CLIENT: # заглушка, замена аутотификации на сервере. Не забыть изменить!!!
print("Client!")
next_id = self.id_clients.next()
self.create_client_handler(conn, next_id)
elif message.cmd == CMD.NEW_PP:
print('PP')
next_id = self.id_PP.next()
self.create_PP_handler(conn, next_id)
answer = cnf.ntuple_data_message(0, CMD.GET_SELF_ID, self.self_ID,
message.sender, 0, next_id)
bytes_answer = cnf.to_bytes_from_data_message_2(answer)
conn.send(bytes_answer) # TODO !!! ВНИМАНИЕ!!!
return True
def run(self):
sending_to_queue = glb_queue.g_to_main_exchange()
sending_to_queue.next()
while self.is_connect:
# инициализируем и чистим значения при последующих циклах
pack = [] # сборка цепочки сообщений
size_next_mess = 0
current_message = cnf.init_ntuple_data_message()
try:
print ("waiting message...")
recvd_msg = self.sock.recv(cnf.SIZE_HEADER)
except:
print ("reset connect")
self.is_connect = False
continue
if not recvd_msg:
print("reset connect")
self.is_connect = False
continue
current_message = cnf.to_data_message_from_bytes_(bytes(recvd_msg))
if not current_message:
print("reset connect")
self.is_connect = False
continue
self.add_to_packet_from_main_header(current_message)
while current_message.size_next > 0 and self.is_connect:
current_message = cnf.to_data_message_from_bytes_(bytes(self.sock.recv(size_next_mess)))
if not current_message or self._check_mess(current_message):
print("dont have data or is not good. Close session...\n -->> ")
self.is_connect = False
continue
else:
pack.append(current_message.data)
# прием закончен, добавить в CacheClient
self._add_datas_in_packet(pack)
sending_to_queue.send(self.packet)
print("Message is receiving ad add to queue....")
if not self.is_connect:
self._close_session_()
else: return
pass
def g_to_main_exchange():
"""
добавляет в очередь сообщение в байтах
:param point:
:return:
"""
print("init g_to_main_exchange")
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.queue_declare(queue=cnf.server_global_queue_name)
exchange = ''
while True:
packet = yield
try:
packet = cnf.to_bytes_from_data_message(packet)
channel.basic_publish(
exchange=exchange, # точка обмена
routing_key=server_global_queue_name, # имя очереди
body=packet)
print("to queue is ok")
except:
g_my_log.send("to_queue: exit..." + str(packet))
break
return
def _callback_(self, ch, method, properties, body):
"""
анализ сообщения
:param message: сообщение в кодировке
:return:
"""
print("Global queue callback")
# добавить в базы данных
self.DB.add_to_databases(
body
) # добавление в БД, скрыта вся логика добавления и фиксирования ответа в БД
message = cnf.to_data_message_from_bytes_(body)
cmd, rout_key, who_type_receiver = self._get_cmd_(
message), self._get_rout_key_(message), self.get_type_receiver(
message)
if who_type_receiver == cnf.type_receivers['client']:
print("add to queue client")
self._add_to_queue_clients(body, rout_key)
self._basic_ask()
return
elif who_type_receiver == cnf.type_receivers['pp']:
print("add to queue pp")
self._add_to_queue_pp_(body, rout_key)
self._basic_ask()
return
elif who_type_receiver == cnf.type_receivers['server']:
print("for server")
self._basic_ask()
def __init__(self, handler):
Thread.__init__(self)
self.handler = handler
self.sock = self.handler.socket
self.typr_handler = self.handler.type_
self.packet = cnf.init_ntuple_data_message()
pass
def create_queue(name=cnf.server_global_queue_name,
address=cnf.queue_addr,
delivery_mode=2):
connect = pika.BlockingConnection(pika.ConnectionParameters(address))
channel = connect.channel()
queue_ = cnf.ntuple_queue(
name, address, connect, channel,
pika.BasicProperties(delivery_mode=delivery_mode))
queue_.chanl.queue_declare(queue=name)
print("Connect to queue...", (name, address))
return queue_
def _add_datas_in_packet(self, data):
if not data:
data_to_str = ''
else:
data_to_str = ''.join(data) # преобразование списка в строку
self.packet = self.packet._replace(data=(str(self.packet.data) + data_to_str))
self.packet = cnf.ntuple_data_message(
self.packet.id,
self.packet.cmd,
self.packet.sender,
self.packet.recv,
self.packet.size_next,
str(self.packet.data) + data_to_str
)
def parse_message(self, mess):
"""
аналог функции from_bytes_to_data_mesage(), только разбивает байты
не используется
:param mess: bytes
:return: ntuple_data_message, size_next_mess
"""
id_ = int(mess[cnf.id_slise])
cmd = int(mess[cnf.cmd_slice])
sender = int(mess[cnf.sender_slice])
receiver = int(mess[cnf.receiver_slice])
size_next_mess = int(mess[cnf.size_next_mess_slice])
data = int(mess[cnf.data_slice])
return cnf.ntuple_data_message(id_, cmd, sender, receiver, data, size_next_mess), size_next_mess
def main():
TCP_IP = cnf.server_address
TCP_PORT = cnf.PORT
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.connect((TCP_IP, TCP_PORT))
cmd = CMD.NEW_PP
sender = 0
receiver = 100 # id сервера
data = 0
size_next = 0
msg = cnf.ntuple_data_message(0, cmd, sender, receiver, size_next, data)
mess = cnf.to_bytes_from_data_message(msg)
if not sock.send(mess):
return
answer = sock.recv(cnf.SIZE_HEADER)
if not answer:
print("нет ответа")
return
message = cnf.to_data_message_from_bytes_(answer)
self_id = message.data
while 1:
receiver = input("Продолжить, получатель?\n")
id_ = msg.id + 1
msg = cnf.ntuple_data_message(id_, CMD.ON_LIGHT, self_id, receiver,
msg.size_next, msg.data)
mess = cnf.to_bytes_from_data_message(msg)
sock.send(mess)
tmp = sock.recv(cnf.SIZE_HEADER) or None
if not tmp:
sock.close()
return
answer = sock.recv(24)
if not answer:
sock.close()
return
answer_ = cnf.to_data_message_from_bytes_(answer)
print("received ->" + str(answer_))
#!/usr/bin/env python3
import os
import yaml
from configurate import Configurate
file_path = os.path.dirname(os.path.abspath(__file__))
project_path = os.path.abspath(os.path.join(file_path, os.path.pardir))
yml_path = os.path.join(project_path, 'configuration/config.yml')
config = Configurate()
with open(yml_path, 'r') as config_file:
config.merge(yaml.safe_load(config_file))
import yaml
from pkg_resources import resource_filename
from configurate import Configurate
config = Configurate()
config_file_name = resource_filename('fibonacci_service', 'config.yaml')
with open(config_file_name, 'r') as config_file:
config.merge(yaml.load(config_file))