def __init__(self, port, ip, client_process):
self.channel_port = port
self.ip = ip
self.registry = UserRegistry()
self.client_process = client_process
self.receiver = MessageReceiver(self.ip, self.channel_port)
logger.info("Server initialized.")
def __init__(self, address=("127.0.0.1", 7222), buffer_size=65536):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
registry = Registry()
self._message_receiver = MessageReceiver(
IncomingMessageTranslator(
[registry,
Broadcaster(registry,
MessageSender(OutgoingMessageTranslator(), sock))
]), address, buffer_size)
class Inbus(object):
def __init__(self, address=("127.0.0.1", 7222), buffer_size=65536):
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
registry = Registry()
self._message_receiver = MessageReceiver(
IncomingMessageTranslator(
[registry,
Broadcaster(registry,
MessageSender(OutgoingMessageTranslator(), sock))
]), address, buffer_size)
def run(self):
while True:
try:
self._message_receiver.wait_and_process_message()
except:
# TODO: logging
pass
def __init__(self, client_ip: str, server_ip: str, process, port=None):
"""
Initializes the client.
server_ip - the server's ip address.
port - the reception port of the server and the clients on the channel.
process - properly received messages are passed to this function.
"""
logger.info("Client initialized.")
self.process = process
self.receiver = MessageReceiver(client_ip, port)
self.server_ip = server_ip
self.channel_port = port
Thread(name="Client Listening Thread",
target=self.__process_messages, daemon=True).start()
def run(self):
# Initiate the connection to the server and receiver
self.connection.connect((self.host, self.server_port))
print("-------- : Connected to host: {}".format(self.host))
MessageReceiver(self, self.connection)
d = {} # new dictonary for creating the payload
while True:
# get message from user
message = input().split(' ', 1)
d['request'] = message[0]
try:
d['content'] = message[1]
except:
# empty content
d['content'] = ''
payload = json.dumps(d) # convert to json
self.send_payload(payload) # send payload
if d['request'] == 'logout':
return self.disconnect()
class Server:
"""
Murmur server.
"""
def __init__(self, port, ip, client_process):
self.channel_port = port
self.ip = ip
self.registry = UserRegistry()
self.client_process = client_process
self.receiver = MessageReceiver(self.ip, self.channel_port)
logger.info("Server initialized.")
def start_processing(self):
"""
Starts the server for actual processing.
"""
logger.info("Server processing started.")
Thread(name='Server Processing Thread',
target=self.__process_requests,
daemon=True).start()
def __process_requests(self):
"""
Processes local and network messages. If it originates from a known
client, it will try to parse the command or send it to everyone if it
is not a command. If it originated from an unknown client it will try
to register them.
"""
for received_message in self.receiver:
if self.registry.ip_known(received_message.sender):
logger.info("Message received from registered client.")
if received_message.body.startswith(COMMAND_FLAG_CHAR):
logger.debug("Message was a command.")
self.parse(received_message.body)
else:
logger.debug("Message was generic.")
self.send_to_all(received_message)
else:
logger.info("Message received from an unregistered client.")
self.attempt_to_register(received_message)
def parse(self, message: Message):
"""
Try to make sense out of a command sent to the server from a registered
client.
message - a message object
"""
pass
def register_hosting_client(self, username: str):
"""
Registers the hosting client's username with the registry.
username - a client's username
"""
if self.validate_name(username):
self.registry.register(username, 'local')
def attempt_to_register(self, message: Message):
"""
Called when a message is received from an unregistered client. Tries to
match the sent message with the proper registration format. If it can't
register the client, the client is ignored.
message - a Message object to parse.
"""
logger.info("Attempting to register client.")
successful_parse = re.match(r'\/regi (.{1,30})', message.body)
if successful_parse and self.validate_name(successful_parse.group(1)):
logger.info("Client successfully registered.")
self.registry.register(successful_parse.group(1), message.sender)
else:
logger.info("Client not registered") # Ignore the message
def validate_name(self, username: str) -> bool:
"""
Checks to see if the username is valid.
username - a string for the registering client's username
"""
return not self.registry.name_taken(username)
def send(self, message_body: str, target: str):
"""
Sends a message to a client. If the message fails to send, the target
is removed from the registry and presumed to be disconnected.
target - the ip of the message recipient.
message_body - a string to send the target.
"""
if target == 'local':
self.client_process(message_body)
else:
with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as sock:
try:
sock.settimeout(1)
sock.connect((target, self.channel_port))
sock.send(message_body.encode())
except socket.timeout:
self.registry.delete_ip(target)
def send_to_all(self, message: Message):
"""
Sends a message to all ips in the registry. Appends the username before
sending the message.
message - a message object
"""
to_send = self.registry.get_user(message.sender) + ": " + message.body
for ip in self.registry.ip():
self.send(to_send, ip)
def send_as_hosting_user(self, message_body: str):
"""
Sends a message under the server's registered user name.
message_body - a string to send
"""
self.receiver.receive(Message(message_body, 'local'))
all_services[i % len(all_services)] for i in [provider, provider + 1]
]
print("Provider {} starting as {} with services".format(provider, mailbox_id),
services)
names_bindings = {
'people': "#.ppl.#",
'satellites': "#.sat.#",
'cargo': "#.cgo.#"
}
exchange_name = 'business'
admin_ex_name = 'admin'
# administrative message queue:
receiver = MessageReceiver(mailbox_id)
receiver.bind_to_exchange(
admin_ex_name, ['#.' + mailbox_id + '.#', '#.providers.#', '#.all.#'])
admin_thread = threading.Thread(target=receiver.start_receiving)
admin_thread.start()
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange=exchange_name, exchange_type='topic')
def callback(ch, method, properties, body):
print("Provider {} received {}".format(provider, body))
order_data = body.decode('utf-8').split()
from message_receiver import MessageReceiver
import threading
business_ex_name = 'business'
admin_ex_name = 'admin'
# exchange
connection = pika.BlockingConnection(
pika.ConnectionParameters(host='localhost'))
channel = connection.channel()
channel.exchange_declare(exchange=admin_ex_name, exchange_type='topic')
# sniffer queue:
receiver = MessageReceiver('admin_inbox')
receiver.bind_to_exchange(business_ex_name, ['#'])
admin_thread = threading.Thread(target=receiver.start_receiving)
admin_thread.start()
# read input and send messages
while True:
command = input("Admin console: ")
if command in ['q', 'quit', 'exit']:
break
try:
[r_key, msg] = command.split(" ", 1)
body = "Admin to {}: {}".format(r_key, msg)
channel.basic_publish(exchange=admin_ex_name,
routing_key=r_key,
body=body)