def run(self):
if self.own_id == self.root_id:
# Await for DHT to get stable
time.sleep(3)
# Print the ring order for debug
self.node_comm.print_ring()
# Start building the table from the root node
self.node_comm.propagate_table()
# Await for DHT to get stable
time.sleep(3)
# Print the ring order for debug
self.node_comm.print_table()
done = False
while not done:
foodRequest = self.node_comm.queueIn.get()
if foodRequest is not None:
# o cliente esta pronto a ir buscar
if foodRequest['method'] == 'COOK':
self.cook(foodRequest['args'])
else:
work()
def main(ip, port):
# create a logger for the client
logger = logging.getLogger('Clerk')
# setup zmq
logger.info('Setup ZMQ')
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect('tcp://{}:{}'.format(ip, port))
while True:
logger.info('Request Task')
p = pickle.dumps({"method": REQ_TASK})
socket.send(p)
p = socket.recv()
o = pickle.loads(p)
logger.info('Received %s', o)
work(3)
logger.info("Task Ready")
p = pickle.dumps({"method": TASK_READY, "args": o})
socket.send(p)
p = socket.recv()
o = pickle.loads(p)
if not o:
break
socket.close()
context.term()
return 0
def waiter_work(self, comm, port, timeout):
# get discovery table
self.discovery_table = comm.get_ringIDs()
while self.discovery_table == None:
self.discovery_table = comm.get_ringIDs()
work(0.5)
self.logger.info("Discovery Table from Comm thread: %s",
self.discovery_table)
while True:
request = comm.get_in_queue()
if request is not None:
self.logger.info("Request from queue: %s", request)
# Wait for a random time
delta = random.gauss(int(config['ACTION']['MEAN']),
float(config['ACTION']['STD_DEVIATION']))
self.logger.info('Wait for %f seconds', delta)
work(delta)
if request['method'] == 'CLIENT_PICKUP':
# Add to ticket queue
self.clients_tickets.append(request['args']['TICKET'])
self.logger.debug("Tickets: %s", self.clients_tickets)
elif request['method'] == 'DELIVER':
ticket_id = request['args']['TICKET']
if ticket_id in self.clients_tickets:
self.clients_tickets.remove(ticket_id)
client_addr = request['args']['CLIENT_ADDR']
msg = {'method': 'ORDER_DELIVER', 'args': ticket_id}
self.send(client_addr, msg) # send ticket to client
def run(self):
self.comm_object.start()
#TODO: adicionar tempos de espera
while True:
while True:
if self.comm_object.out_queue.qsize != 0:
break
work(5)
o = self.comm_object.out_queue.get()
self.comm_object.logger.info('Waiter Received ORDER: %s ',
o['args'])
order_id = uuid.uuid4()
order = o['args']
# Envia para o sucessor a order c/ ID e quantidades pedidas
o = {
'method': 'SEND_ORDER',
'args': {
'order_ID': order_id,
'order': order
}
}
self.comm_object.send(self.comm_object.successor_addr, o)
self.comm_object.logger.info('Waiter Sent ORDER no %s, %s',
order_id, order)
# Envia para o restaurante para devolver o Order_ID ao cliente
o = {'method': 'NOTE_ORDER', 'args': order_id}
self.comm_object.send(self.comm_object.restAddr, o)
self.comm_object.logger.info(
'Waiter sent Ticket number %s to preare: %s', order_id, order)
def run(self):
while True:
o = self.node_entity.queue_out.get()
self.logger.info("O %s", o)
if o['method'] == 'ORDER':
work()
self.send_order(o['client_addr'], o['args'])
def order_cost(self, order):
# Wait for a random time
delta = random.gauss(2, 0.5)
self.logger.info('Calculating order cost for %f seconds', delta)
work(delta)
total_cost = order['fries'] * self.fries_price
total_cost += order['drink'] * self.drink_price
total_cost += order['hamburger'] * self.hamburger_price
return total_cost
def wait_on_item(self, food):
# wait until acces is granted to equipment needed
answer = self.node_comm.queueIn.get()
if answer['method'] == 'ACCESS_GRANTED' and answer['args'][
'equipment'] == food:
# access granted to equipment
time = self.equipmentsTime[answer['args']['equipment']]
work(time)
return
else: # put msg back in queueIn to be processed again
self.node_comm.queueIn.put(answer)
self.wait_on_item(food)
def run(self):
while True:
o = self.node_entity.queue_out.get()
self.logger.info("Waiter: %s", o)
if o['method'] == 'PICKUP':
work()
self.pickup(o['client_addr'], o['args'])
if o['method'] == 'COMPLETED_REQ':
work()
self.send_req(o['ticket'], o['args'])
def run(self):
if self.own_id == self.root_id:
# Await for DHT to get stable
time.sleep(3)
# Print the ring order for debug
self.node_comm.print_ring()
# Start building the table from the root node
self.node_comm.propagate_table()
# Await for DHT to get stable
time.sleep(3)
# Print the ring order for debug
self.node_comm.print_table()
done = False
while not done:
foodRequest = self.node_comm.queueIn.get()
if foodRequest is not None:
# send confirmation with ticket to client
orderTicket = uuid.uuid1()
msg = {
'method': 'ORDER_RECVD',
'args': {
'orderTicket': orderTicket,
'client_addr': foodRequest['args']['client_addr']
}
} # send confirmation back to client
self.node_comm.queueOut.put(msg)
msg = {
'method': 'COOK',
'args': {
'dest': 'Cook',
'order': foodRequest['args']['order'],
'client_addr': foodRequest['args']['client_addr'],
'orderTicket': orderTicket
}
}
self.node_comm.queueOut.put(msg)
# self.logger.debug("Put %s in the out queue")
work()
else:
work()
def main(port, ring, timeout):
# Create a logger for the client
logger = logging.getLogger('Client')
# UDP Socket
sock = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
sock.settimeout(timeout)
sock.bind(('localhost', port))
# Generate a request
order = {'hamburger': 0, 'fries': 0, 'drink': 0}
quantity = random.randint(1, 5)
for i in range(quantity):
order[random.choice(['hamburger', 'fries', 'drink'])] += 1
# Wait for a random time
delta = random.gauss(int(config['ACTION']['MEAN']),
float(config['ACTION']['STD_DEVIATION']))
logger.info('Wait for %f seconds', delta)
work(delta)
# Request some food
logger.info('Request some food: %s', order)
p = pickle.dumps({'method': 'ORDER', 'args': order})
sock.sendto(p, ring)
# Wait for Ticket
p, addr = sock.recvfrom(1024)
o = pickle.loads(p)
logger.info('Received ticket %s', o['args'])
# Pickup order
logger.info('Pickup order %s', o['args'])
p = pickle.dumps({'method': 'PICKUP', 'args': o['args']})
sock.sendto(p, ring)
# Wait for order
p, addr = sock.recvfrom(1024)
o = pickle.loads(p)
logger.info('Got order %s', o['args'])
# Close socket
sock.close()
return 0
def main(ip, port):
logger = logging.getLogger('Client')
logger.info('Setup ZMQ')
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect('tcp://{}:{}'.format(ip, port))
logger.info("Im going to the restaurant!")
traveling()
logger.info('Request some food')
p = pickle.dumps({
"method": ORDER,
"args": {
"hamburger": food(),
"batata": food(),
"bebida": food()
}
})
socket.send(p)
p = socket.recv()
o = pickle.loads(p)
logger.info('Received %s', o)
work()
while True:
logger.info('Pickup order %s', o)
p = pickle.dumps({"method": PICKUP, "args": o})
socket.send(p)
p = socket.recv()
s = pickle.loads(p)
logger.info('Got %s', s)
if s != "EMPTY":
logger.info("I GOT MY ORDER! BYE!!!")
break
wait()
socket.close()
context.term()
return 0
def run(self): # Overrides run() from parent
self.logger.info('Receptionist start working')
while True:
# request from receptionist to restaurant for new requests in queue
new_req.req_type = "receptionist_req_for_new"
self.socket.send(pickle.dumps(new_req))
# receive a compress object --- request from client (is in queue from drive-through)
p = self.socket.recv()
# use pickle to load the object
o = pickle.loads(p)
# print the object
self.logger.info('Receptionist received %s', o)
# generate the number of seconds the work will take
seconds = math.fabs(random.gauss(self.mu, self.sigma))
self.logger.info('Will work for %f seconds', seconds)
# work(sleep) for the previous amount of seconds
work(seconds)
# message from receptionist to pending queue
new_req.req_type = "receptionist_to_pending"
new_req.req_id = uuid.uuid1()
save_id = new_req.req_id
new_req.client_id = uuid.uuid1()
new_req.items = o.req_items
self.socket.send(pickle.dumps(new_req))
# message from receptionist to cook queue
for item in o.req_items:
new_req.req_type = item.item_type + "_todo"
new_req.quantity = item.quantity
self.socket.send(pickle.dumps(new_req))
# message from receptionist to client (req. ack. and info.)
new_req.req_type = "req_ack"
new_req.req_id = save_id
# close the socket
self.socket.close()
def run(self):
self.comm_object.start()
#self.Logger.info('Starting Restaurant')
while True:
while True:
if self.comm_object.out_queue.qsize != 0:
break
work(5)
o = self.comm_object.out_queue.get()
#TODO: adicionar tempos de espera
self.comm_object.logger.info(
'Restaurant Received ORDER to COOK: %s ', o['args'])
self.Grill_quantity = o['args']['order']['hamburger']
self.Fries_quantity = o['args']['order']['fries']
self.Drinks_quantity = o['args']['order']['drink']
# Griller
if self.Grill_quantity != 0:
self.comm_object.logger.info('Grilling %s hamburgers',
self.Grill_quantity)
for i in range(self.Grill_quantity):
time.sleep(random.gauss(3, 0.5))
# Fries
if self.Fries_quantity != 0:
self.comm_object.logger.info('Frying %s fries',
self.Fries_quantity)
for i in range(self.Fries_quantity):
time.sleep(random.gauss(5, 0.5))
# Drinks
if self.Drinks_quantity != 0:
self.comm_object.logger.info('Serving %s drinks',
self.Drinks_quantity)
for i in range(self.Drinks_quantity):
time.sleep(random.gauss(1, 0.5))
o = {'method': 'COOKEED_ORDER', 'args': o['args']}
self.comm_object.send(self.comm_object.successor_addr, o)
self.comm_object.logger.info('Restaurant Sent COOKED ORDER no %s',
o['args'])
def run(self):
self.logger.info('Start working')
while True:
# receive a compress object
p = self.socket.recv()
# use pickle to load the object
o = pickle.loads(p)
# print the object
self.logger.info('Worker received %s', o)
# generate the number of seconds the work will take
seconds = math.fabs(random.gauss(self.mu, self.sigma))
self.logger.info('Will work for %f seconds', seconds)
# work(sleep) for the previous amount of seconds
work(seconds)
# use pickle to dump a object
p = pickle.dumps('ACK')
# send it
self.socket.send(p)
# close the socket
self.socket.close()
def run(self):
if self.own_id == self.root_id:
# Await for DHT to get stable
time.sleep(3)
# Print the ring order for debug
self.node_comm.print_ring()
# Start building the table from the root node
self.node_comm.propagate_table()
# Await for DHT to get stable
time.sleep(3)
# Print the ring order for debug
self.node_comm.print_table()
done = False
while not done:
if not self.queueWaiting.empty(): # if request is waiting
self.lockEquipment(self.queueWaiting.get())
else:
foodRequest = self.node_comm.queueIn.get()
if foodRequest is not None: # if new request came in
# print('What came in:', foodRequest['method'])
if foodRequest['method']=='EQPT_REQ':
# print('Sending to func lockEquipment')
self.lockEquipment(foodRequest['args'])
elif foodRequest['method']=='EQPT_USED':
# print('Sending to func releaseEquipment')
self.releaseEquipment(foodRequest['args'])
# else:
# print('Did not enter any')
else:
work()
def main(ip, port):
logger = logging.getLogger('Deliver')
logger.info('Setup ZMQ')
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect('tcp://{}:{}'.format(ip, port))
while True:
logger.info('Request Food')
p = pickle.dumps({"method": REQ_FOOD})
socket.send(p)
p = socket.recv()
o = pickle.loads(p)
logger.info('Received %s', o)
if o == "EMPTY":
logger.info("Going to wait...")
wait()
continue
work()
logger.info("Sending Food For Pickup")
p = pickle.dumps({"method": ORDER_FOR_PICKUP, "args": o})
socket.send(p)
p = socket.recv()
o = pickle.loads(p)
if not o:
break
socket.close()
context.term()
return 0
def clk_work(self, comm, port, timeout):
# get discovery table
self.discovery_table = comm.get_ringIDs()
while self.discovery_table == None:
self.discovery_table = comm.get_ringIDs()
work(0.5)
self.logger.info("Discovery Table from Comm thread: %s",
self.discovery_table)
while True:
request = comm.get_in_queue()
if request is not None:
self.logger.info("Request from queue: %s", request)
# Wait for a random time
delta = random.gauss(int(config['ACTION']['MEAN']), float(
config['ACTION']['STD_DEVIATION']))
self.logger.info('Wait for %f seconds', delta)
work(delta)
client_addr = request['args']['CLIENT_ADDR']
order_id = uuid.uuid1()
msg = {'method': 'ORDER_RECEIVED', 'args': order_id}
self.send(client_addr, msg) # send ticket to client
if isinstance(self.discovery_table['CHEF'], list):
msg = {'method': 'TOKEN', 'args': {'method': 'COOK', 'args': {
'id': self.discovery_table['CHEF'][self.count], 'order': request['args']['order'],
'CLIENT_ADDR': request['args']['CLIENT_ADDR'], 'TICKET': order_id}}}
self.count = (
self.count+1) % len(self.discovery_table['CHEF'])
else:
msg = {'method': 'TOKEN', 'args': {'method': 'COOK', 'args': {
'id': self.discovery_table['CHEF'], 'order': request['args']['order'],
'CLIENT_ADDR': request['args']['CLIENT_ADDR'], 'TICKET': order_id}}}
self.logger.debug(msg)
comm.put_out_queue(msg)
def main(ip, port):
# create a logger for the client
logger = logging.getLogger('Client')
# setup zmq
logger.info('Setup ZMQ')
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect('tcp://{}:{}'.format(ip, port))
while True:
logger.info('Request some food')
p = pickle.dumps({"method": ORDER, "args": {"hamburger": 1}})
socket.send(p)
p = socket.recv()
o = pickle.loads(p)
logger.info('Received %s', o)
#receives object with ID of order and waits for it
work(3)
logger.info('Pickup order %s', o)
p = pickle.dumps({"method": PICKUP, "args": o})
socket.send(p)
p = socket.recv()
o = pickle.loads(p)
logger.info('Got %s', o)
if not o:
break
socket.close()
context.term()
return 0
def run(self):
if self.own_id == self.root_id:
# Await for DHT to get stable
time.sleep(3)
# Print the ring order for debug
self.node_comm.print_ring()
# Start building the table from the root node
self.node_comm.propagate_table()
# Await for DHT to get stable
time.sleep(3)
# Print the ring order for debug
self.node_comm.print_table()
done = False
while not done:
foodRequest = self.node_comm.queueIn.get()
if foodRequest is not None:
if len(self.queueWaiting) != 0:
self.deliver(self.queueWaiting[0])
#o cliente esta pronto a ir buscar
if foodRequest['method'] == 'PICKUP':
self.wait_in_line(foodRequest['args'])
#caso a comida esteja pronta
elif foodRequest['method'] == 'ORDER_DONE':
self.queueDone.append(foodRequest['args']['orderTicket'])
self.deliver(foodRequest['args'])
work()
else:
work()
if len(rooms.keys()) != 0:
print(f"There are already {len(rooms)} visited rooms")
# Initialize the Game
response = debounce(game_init, game_state)
room = Room(response)
print(f"Current room: {room}")
player.play(room)
record_move(rooms, room)
# Game Mode
print(f"Please choose running mode:")
print(f"1 - automatic traversal")
print(f"2 - manual")
print(f"3 - work to find and sell items")
print(f"4 - mine for coins")
print(f"5 - change name")
running_mode = int(input())
if running_mode == 1:
traverse(rooms, player, game_state)
elif running_mode == 2:
repl(rooms, player, game_state)
elif running_mode == 3:
work(rooms, player, game_state)
elif running_mode == 4:
mine(rooms, player, game_state)
elif running_mode == 5:
change_name(rooms, player, game_state)
def run(self):
# socket for sending the finished request back to the client
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client_socket.settimeout(3)
client_socket.bind(('localhost', self.port + 100))
# pending pickup orders
pending_order = {}
# get entities table
entities_table = self.comm_thread.get_nodes_table()
while entities_table is None:
entities_table = self.comm_thread.get_nodes_table()
work(0.5)
self.logger.info('Entities table: %s', entities_table)
done = False
while not done:
# waiting for client pickup request
p, addr = recv(client_socket)
if p is not None:
# Wait for a random time
delta = random.gauss(2, 0.5)
self.logger.info('Wait for %f seconds', delta)
work(delta)
o = pickle.loads(p)
method = o['method']
self.logger.info('Received client request: %s', method)
if method == 'PICKUP':
ticket_no = o['args']['ticket_no']
self.logger.info('Client pickup request')
if ticket_no not in pending_order:
pending_order[ticket_no] = o['args']['order']
elif method == 'ORDER':
self.logger.info('Order: %s', o['args'])
self.logger.info('Forwarding ORDER request to Clerk')
to_send = {'method':'CLIENT_ORDER','args':{'client_addr':addr,'order':o['args'], 'id':entities_table['Clerk'][0]}}
self.comm_thread.put_send_requests(to_send)
else:
try:
self.logger.debug('Getting received request')
recv_request = self.comm_thread.get_recv_requests()
if recv_request is None:
work(0.5)
continue
except:
self.logger.debug('Error getting received request')
continue
if recv_request is not None:
# Wait for a random time
delta = random.gauss(2, 0.5)
self.logger.info('Wait for %f seconds', delta)
work(delta)
# token parsing
method = recv_request['method']
client_addr = recv_request['args']['client_addr']
ticket_no = recv_request['args']['ticket_no']
self.logger.info('Received %s request', method)
if method == 'CLIENT_PICKUP':
self.logger.info('Client pickup request')
order = recv_request['args']['order']
if ticket_no not in list(pending_order.keys()):
pending_order[ticket_no] = order
elif method == 'ORDER_READY':
if ticket_no in list(pending_order.keys()):
order = pending_order[ticket_no]
del pending_order[ticket_no]
# get order total cost
order_cost = self.order_cost(order)
self.logger.info('Payment request for order No. %s', ticket_no)
self.logger.info('Total cost: $%s', order_cost)
send(client_socket, client_addr, order_cost)
payed = False
while not payed:
# waiting for client payment
p, addr = recv(client_socket)
if p is not None:
o = pickle.loads(p)
self.logger.info('Received payment amount of $%s', o['amount'])
self.logger.info('Order ready: %s', order)
self.logger.info('Sending finished order to client address: %s', client_addr)
send(client_socket, client_addr, order)
payed = True
def run():
# generate the number of seconds the work will take and work (sleep)
seconds = math.fabs(random.gauss(self.mu, self.sigma))
self.logger.info('Use grill for %f seconds', seconds)
work(seconds)
def run(self):
# load the configuration file
config = configparser.ConfigParser()
config.read('../config.ini')
# socket for receiving clients requests
client_socket=socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client_socket.settimeout(3)
client_socket.bind(('localhost', self.port + 100)) # client_port = port + 100
# create kitchen equipments
barbecue_grill = BarbecueGrill(config)
fryer = Fryer(config)
bar = Bar(config)
# get entities table
entities_table = self.comm_thread.get_nodes_table()
while entities_table is None:
entities_table = self.comm_thread.get_nodes_table()
work(0.5)
self.logger.info('Entities table: %s', entities_table)
done = False
while not done:
# waiting for client order
p, addr = recv(client_socket)
if p is not None:
# Wait for a random time
delta = random.gauss(2, 0.5)
self.logger.info('Wait for %f seconds', delta)
work(delta)
o = pickle.loads(p)
method = o['method']
self.logger.info('Request received: %s', method)
if method == 'ORDER':
self.logger.info('Order: %s', o['args'])
self.logger.info('Forwarding ORDER request to Clerk')
args = {'client_addr': addr,'order': o['args'], 'id': entities_table['Clerk'][0]}
o = {'method':'CLIENT_ORDER', 'args': args}
self.comm_thread.put_send_requests(o)
if method == 'PICKUP':
self.logger.info('Forwarding PICKUP request to Waiter')
args = {'client_addr':addr,'order': o['args']['order'],'ticket_no': o['args']['ticket_no'], 'id': entities_table['Waiter'][0]}
o = {'method':'CLIENT_PICKUP', 'args': args}
self.comm_thread.put_send_requests(o)
else:
request = self.comm_thread.get_recv_requests()
if request is not None:
self.logger.debug('Request %s', request)
client_addr = request['args']['client_addr']
ticket_no = request['args']['ticket_no']
from_id = request['args']['from']
# check witch kitchen equipment is beeing requested
if request['method'] == 'REQUEST_BARBECUE_GRILL':
if self.using_barbecue_grill is None:
self.logger.info('Barbecue grill request by Chef %s', from_id)
time = barbecue_grill.to_grill()
args = {'equipment': 'barbecue_grill','time': time, 'client_addr': client_addr, 'ticket_no': ticket_no, 'id': from_id}
o = {'method': 'COOK_TIME', 'args': args}
self.using_barbecue_grill = from_id
self.comm_thread.put_send_requests(o)
else:
self.barbecue_grill_order.put({'client_addr':client_addr,'ticket_no':ticket_no,'id':from_id})
elif request['method'] =='REQUEST_FRYER':
if self.using_fryer is None:
self.logger.info('Fryer request by Chef %s', from_id)
time = fryer.to_fry()
args = {'equipment':'fryer','time': time, 'client_addr': client_addr, 'ticket_no': ticket_no, 'id': from_id}
o = {'method': 'COOK_TIME', 'args': args}
self.using_fryer = from_id
self.comm_thread.put_send_requests(o)
else:
self.fryer_order.put({'client_addr':client_addr,'ticket_no':ticket_no,'id':from_id})
elif request['method'] =='REQUEST_BAR':
if self.using_bar is None:
self.logger.info('Bar request by Chef %s', from_id)
time = bar.prepare_drink()
args = {'equipment':'bar','time': time, 'client_addr': client_addr, 'ticket_no': ticket_no, 'id': from_id}
o = {'method': 'COOK_TIME', 'args': args}
self.using_bar = from_id
self.comm_thread.put_send_requests(o)
else:
self.bar_order.put({'client_addr':client_addr,'ticket_no':ticket_no,'id':from_id})
elif request['method'] == 'FREE_BARBECUE_GRILL':
if self.using_barbecue_grill == from_id:
# check if there are other barbecue grill requests
if self.barbecue_grill_order.qsize() != 0:
req = self.barbecue_grill_order.get()
client_addr = req['client_addr']
ticket_no = req['ticket_no']
from_id = req['id']
self.logger.info('Barbecue Grill request by Chef %s', from_id)
time = barbecue_grill.to_grill()
args = {'equipment':'barbecue_grill','time': time, 'client_addr': client_addr, 'ticket_no': ticket_no, 'id': from_id,'olaaaa':'olaaa'}
o = {'method': 'COOK_TIME', 'args': args}
self.using_barbecue_grill = from_id
self.comm_thread.put_send_requests(o)
else:
self.logger.info('Barbecue Grill is free')
self.using_barbecue_grill = None
elif request['method'] == 'FREE_FRYER':
if self.using_fryer == from_id:
# check if there are other fryer requests
if self.fryer_order.qsize() != 0:
req = self.fryer_order.get()
client_addr = req['client_addr']
ticket_no = req['ticket_no']
from_id = req['id']
self.logger.info('Fryer request by Chef %s', from_id)
time = fryer.to_fry()
args = {'equipment':'fryer','time': time, 'client_addr': client_addr, 'ticket_no': ticket_no, 'id': from_id}
o = {'method': 'COOK_TIME', 'args': args}
self.using_fryer = from_id
self.comm_thread.put_send_requests(o)
else:
self.logger.info('Fryer is free')
self.using_fryer = None
elif request['method'] == 'FREE_BAR':
if self.using_bar == from_id:
if self.bar_order.qsize()!=0:
req=self.bar_order.get()
client_addr = req['client_addr']
ticket_no = req['ticket_no']
from_id=req['id']
time = bar.prepare_drink()
self.logger.info('Bar request by Chef %s', from_id)
args = {'equipment':'bar','time': time, 'client_addr': client_addr, 'ticket_no': ticket_no, 'id': from_id}
o = {'method': 'COOK_TIME', 'args': args}
self.using_bar = from_id
self.comm_thread.put_send_requests(o)
else:
self.logger.info('Bar is free')
self.using_bar = None
def chef_work(self, comm, port, timeout):
# get discovery table
self.discovery_table = comm.get_ringIDs()
while self.discovery_table == None:
self.discovery_table = comm.get_ringIDs()
work(0.5)
self.logger.info("Discovery Table from Comm thread: %s",
self.discovery_table)
done = False
while not done:
request = comm.get_in_queue()
if request is not None:
if request['method'] == 'COOK':
order = {
'client': request['args']['CLIENT_ADDR'],
'orderID': request['args']['TICKET'],
'order': request['args']['order'],
'grill': 1,
'drinks': 1,
'frier': 1
}
order['client'] = request['args']['CLIENT_ADDR']
order['orderID'] = request['args']['TICKET']
order['order'] = request['args']['order']
# Check which equipments we'll need (f.ex if we need 3 hamburgers, well store grill = -2 and then increment it by 1 each time we get the grill, noting that well be done when grill = 1)
for i in request['args']['order']:
if i == 'hamburger':
order['grill'] -= request['args']['order'][
'hamburger']
if i == 'drinks':
order['drinks'] -= request['args']['order'][
'drinks']
if i == 'fries':
order['frier'] -= request['args']['order']['fries']
# Add to queue
self.ordersQ.put(order)
self.logger.info("Order added to Queue : %d - %d - %d",
order['grill'], order['frier'],
order['drinks'])
elif request['method'] == 'GRILL_TOKEN':
self.logger.debug("GRILL ACQUIRED")
if "grill" in self.requestList:
# Grill
delta = random.gauss(
int(config['GRILL']['MEAN']),
float(config['GRILL']['STD_DEVIATION']))
self.logger.info('Grilling for %f seconds', delta)
work(delta)
self.requestList.remove('grill')
self.currentOrder['grill'] += 1
self.logger.debug("GRILL RELEASED")
comm.put_out_queue(request)
elif request['method'] == 'FRIER_TOKEN':
self.logger.debug("FRIER ACQUIRED")
if "frier" in self.requestList:
# Fry
delta = random.gauss(
int(config['FRYER']['MEAN']),
float(config['FRYER']['STD_DEVIATION']))
self.logger.info('Frying for %f seconds', delta)
work(delta)
self.requestList.remove('frier')
self.currentOrder['frier'] += 1
self.logger.debug("FRIER RELEASED")
comm.put_out_queue(request)
elif request['method'] == 'DRINKS_TOKEN':
self.logger.debug("DRINKS ACQUIRED")
if "drinks" in self.requestList:
# Grill
delta = random.gauss(
int(config['DRINKS_BAR']['MEAN']),
float(config['DRINKS_BAR']['STD_DEVIATION']))
self.logger.info('Pouring for %f seconds', delta)
work(delta)
self.requestList.remove('drinks')
self.currentOrder['drinks'] += 1
self.logger.debug("DRINKS RELEASED")
comm.put_out_queue(request)
else:
# If we're not cooking anything right now
if self.currentOrder['client'] == None:
if self.ordersQ.qsize(
) == 0: # If we have no orders continue the loop
continue
else:
self.currentOrder = self.ordersQ.get(
) # Get cook order from queue
self.logger.info("Working on order %s",
self.currentOrder)
# If order is ready
if self.currentOrder['grill'] == 1 and self.currentOrder[
'frier'] == 1 and self.currentOrder['drinks'] == 1:
msg = {
'method': 'TOKEN',
'args': {
'method': 'DELIVER',
'args': {
'id': self.discovery_table['WAITER'],
'order': self.currentOrder['order'],
'CLIENT_ADDR': self.currentOrder['client'],
'TICKET': self.currentOrder['orderID']
}
}
}
self.logger.info("ORDER READY - %s",
self.currentOrder['client'])
self.currentOrder = {
'client': None,
'orderID': None,
'order': None,
'grill': 0,
'frier': 0,
'drinks': 0
} # Reset current order
comm.put_out_queue(msg)
elif len(self.requestList
) == 0: # Register and Request equipments necessary
self.requestList = []
# Check which equipments we need
if self.currentOrder['grill'] != 1:
for i in range(1 - self.currentOrder['grill']):
self.requestList.append('grill')
if self.currentOrder['drinks'] != 1:
for i in range(1 - self.currentOrder['drinks']):
self.requestList.append('drinks')
if self.currentOrder['frier'] != 1:
for i in range(1 - self.currentOrder['frier']):
self.requestList.append('frier')
def request_fries(self):
self.frier.acquire()
work()
self.frier.release()
def run(self):
food_done = dict.fromkeys(['hamburger', 'fries', 'drink'], 0)
cooking_item = False
item_index = 0
while True:
o = self.node_entity.queue_out.get()
self.logger.info("O: %s", o)
if o['method'] == 'SEND_ORDER':
self.req.append((o['ticket'], o['args']))
self.add_to_do(o['args'])
if o['method'] == 'USE_FRIES':
if not o['args']:
self.node_entity.queue_in.put({
'entity': 'Restaurant',
'args': None,
'method': 'USING_FRY'
})
work(5, 0.5)
self.to_do.pop(item_index)
item_index = 0
food_done['fries'] += 1
self.node_entity.queue_in.put({
'entity': 'Restaurant',
'args': None,
'method': 'STOPPED_FRY'
})
else:
item_index += 1
cooking_item = False
if o['method'] == 'USE_GRILL':
if not o['args']:
self.node_entity.queue_in.put({
'entity': 'Restaurant',
'args': None,
'method': 'USING_GRILL'
})
work(3, 0.5)
self.to_do.pop(item_index)
item_index = 0
food_done['hamburger'] += 1
self.node_entity.queue_in.put({
'entity': 'Restaurant',
'args': None,
'method': 'STOPPED_GRILL'
})
else:
item_index += 1
cooking_item = False
if o['method'] == 'USE_DRINK':
if not o['args']:
self.node_entity.queue_in.put({
'entity': 'Restaurant',
'args': None,
'method': 'USING_DRINK'
})
work(1, 0.5)
self.to_do.pop(item_index)
item_index = 0
food_done['drink'] += 1
self.node_entity.queue_in.put({
'entity': 'Restaurant',
'args': None,
'method': 'STOPPED_DRINK'
})
else:
item_index += 1
cooking_item = False
if self.completed(food_done):
ticket, completed_req = self.req.pop()
for key in food_done:
food_done[key] -= completed_req[key]
self.node_entity.queue_in.put({
'entity': 'Waiter',
'method': 'COMPLETED_REQ',
'args': completed_req,
'ticket': ticket
})
if not cooking_item:
if len(self.to_do) > 0:
item = self.to_do[item_index]
cooking_item = True
self.node_entity.queue_in.put({
'entity': 'Restaurant',
'args': None,
'method': 'ask_' + item
})
def main(ip, port):
# create a logger for the client
logger = logging.getLogger('Receptionist')
# setup zmq
logger.info('Setup ZMQ')
context = zmq.Context()
socket = context.socket(zmq.REQ)
socket.connect('tcp://{}:{}'.format(ip, port))
mu = 0.01, sigma = 0.005
while True:
logger.info('Waiting for new order')
p = pickle.dumps({"method": REQ_TASK})
socket.send(p)
p = socket.recv()
o = pickle.loads(p)
logger.info('Received %s', o)
# receives request from client
# generate the number of seconds the work will take
seconds = math.fabs(random.gauss(mu, sigma))
self.logger.info('Will work for %f seconds', seconds)
# work(sleep) for the previous amount of seconds
work(seconds)
# processes order's items and puts them into each queue
logger.info('Putting items in respective queue')
for item in o[1].items():
if item[0] == "hamburger":
p = pickle.dumps({
"method": PUT_HAMBURGER,
"args": item[1]
}) # pass argument and quantity as argument
elif item[0] == "fries":
p = pickle.dumps({
"method": PUT_FRIES,
"args": item[1]
}) # pass argument and quantity as argument
elif item[0] == "drink":
p = pickle.dumps({
"method": PUT_DRINK,
"args": item[1]
}) # pass argument and quantity as argument
socket.send(p)
# put order in pending queue
logger.info("Putting order in pending queue")
p = pickle.dumps({"method": PUT_IN_PENDING, "args": o})
socket.send(p)
p = socket.recv()
o = pickle.loads(p)
if not o:
break
socket.close()
context.term()
return 0
def run(self):
# socket for receiving clients requests
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client_socket.settimeout(3)
client_socket.bind(
('localhost', self.port + 100)) # client_port = port + 100
# get entities table
entities_table = self.comm_thread.get_nodes_table()
while entities_table is None:
entities_table = self.comm_thread.get_nodes_table()
work(0.5)
self.logger.info('Entities table: %s', entities_table)
done = False
while not done:
# waiting for client order
p, addr = recv(client_socket)
if p is not None:
# Wait for a random time
delta = random.gauss(2, 0.5)
self.logger.info('Wait for %f seconds', delta)
work(delta)
o = pickle.loads(p)
method = o['method']
self.logger.info('Request received: %s', method)
# received client order
if method == 'ORDER':
self.logger.info('Order: %s', o['args'])
to_send = {
'method': 'CLIENT_ORDER',
'args': {
'client_addr': addr,
'order': o['args'],
'id': entities_table['Clerk'][0]
}
}
self.comm_thread.put_send_requests(to_send)
# received client request to pickup his order
if method == 'PICKUP':
to_send = {
'method': 'CLIENT_PICKUP',
'args': {
'client_addr': addr,
'order': o['args']['order'],
'ticket_no': o['args']['ticket_no'],
'id': entities_table['Waiter'][0]
}
}
self.comm_thread.put_send_requests(to_send)
else:
self.logger.debug('Getting received request')
recv_request = self.comm_thread.get_recv_requests()
if recv_request is not None:
self.logger.debug('Request received %s', recv_request)
method = recv_request['method']
client_addr = recv_request['args']['client_addr']
ticket_no = recv_request['args']['ticket_no']
if method == 'COOK_ORDER':
self.logger.info('Cook order No. %s received',
ticket_no)
# not currently cooking
if not any(self.currently_cooking):
order = recv_request['args']['order']
n_fries = 0
n_drink = 0
n_hamburger = 0
if 'hamburger' in order:
n_hamburger = order['hamburger']
if 'fries' in order:
n_fries = order['fries']
if 'drink' in order:
n_drink = order['drink']
recv_request['args']['fries_cook'] = n_fries
recv_request['args'][
'hamburger_cook'] = n_hamburger
recv_request['args']['drink_cook'] = n_drink
args = {}
args['client_addr'] = client_addr
args['ticket_no'] = ticket_no
args['id'] = entities_table['Drive-Through'][0]
args['from'] = self.id
self.currently_cooking[ticket_no] = recv_request[
'args']
if n_hamburger != 0:
self.logger.info('Requesting Barbecue Grill')
o = {
'method': 'REQUEST_BARBECUE_GRILL',
'args': args
}
elif n_fries != 0:
self.logger.info('Requesting Fryer')
o = {'method': 'REQUEST_FRYER', 'args': args}
elif n_drink != 0:
self.logger.info('Requesting Bar')
o = {'method': 'REQUEST_BAR', 'args': args}
self.comm_thread.put_send_requests(o)
else:
self.cook_order.put(recv_request['args'])
elif method == 'COOK_TIME':
# after requesting a certain kitchen equipment, chef is ready to cook
equipment = recv_request['args']['equipment']
ticket_no = recv_request['args']['ticket_no']
time = recv_request['args']['time']
if equipment == 'fryer':
self.logger.info('Using fryer for %s seconds',
time)
self.currently_cooking[ticket_no][
'fries_cook'] -= 1
args = {
'client_addr': client_addr,
'ticket_no': ticket_no,
'id': entities_table['Drive-Through'][0],
'from': self.id
}
o = {'method': 'FREE_FRYER', 'args': args}
elif equipment == 'barbecue_grill':
self.logger.info(
'Using barbecue grill for %s seconds', time)
self.currently_cooking[ticket_no][
'hamburger_cook'] -= 1
args = {
'client_addr': client_addr,
'ticket_no': ticket_no,
'id': entities_table['Drive-Through'][0],
'from': self.id
}
o = {'method': 'FREE_BARBECUE_GRILL', 'args': args}
elif equipment == 'bar':
self.logger.info('Using bar for %s seconds', time)
self.currently_cooking[ticket_no][
'drink_cook'] -= 1
args = {
'client_addr': client_addr,
'ticket_no': ticket_no,
'id': entities_table['Drive-Through'][0],
'from': self.id
}
o = {'method': 'FREE_BAR', 'args': args}
# simulating work
work(time)
self.comm_thread.put_send_requests(o)
# chef if the order is ready
drinks_left = self.currently_cooking[ticket_no][
'drink_cook']
hamburgers_left = self.currently_cooking[ticket_no][
'hamburger_cook']
fries_left = self.currently_cooking[ticket_no][
'fries_cook']
if drinks_left == 0 and hamburgers_left == 0 and fries_left == 0:
# Order is ready
self.logger.info('Order No. %s ready', ticket_no)
args = {
'client_addr': client_addr,
'ticket_no': ticket_no,
'id': entities_table['Waiter'][0]
}
o = {'method': 'ORDER_READY', 'args': args}
del self.currently_cooking[ticket_no]
# send to Waiter
self.comm_thread.put_send_requests(o)
# start preparing the next order in the queue
if self.cook_order.qsize() != 0:
item = self.cook_order.get()
order = item['order']
client_addr = item['client_addr']
ticket_no = item['ticket_no']
n_fries = 0
n_drink = 0
n_hamburger = 0
if 'hamburger' in order:
n_hamburger = order['hamburger']
if 'fries' in order:
n_fries = order['fries']
if 'drink' in order:
n_drink = order['drink']
item['fries_cook'] = n_fries
item['hamburger_cook'] = n_hamburger
item['drink_cook'] = n_drink
args = {}
args['client_addr'] = client_addr
args['ticket_no'] = ticket_no
args['id'] = entities_table['Drive-Through'][0]
args['from'] = self.id
self.currently_cooking[ticket_no] = item
if n_hamburger != 0:
self.logger.info(
'Requesting Barbecue Grill')
o = {
'method': 'REQUEST_BARBECUE_GRILL',
'args': args
}
elif n_fries != 0:
self.logger.info('Requesting Fryer')
o = {
'method': 'REQUEST_FRYER',
'args': args
}
elif n_drink != 0:
self.logger.info('Requesting Bar')
o = {'method': 'REQUEST_BAR', 'args': args}
self.comm_thread.put_send_requests(o)
else:
# if order is not ready, continue requesting kitchen equipments
args = {
'client_addr': client_addr,
'ticket_no': ticket_no,
'id': entities_table['Drive-Through'][0],
'from': self.id
}
if self.currently_cooking[ticket_no][
'drink_cook'] != 0:
self.logger.info('Requesting Bar')
o = {'method': 'REQUEST_BAR', 'args': args}
elif self.currently_cooking[ticket_no][
'hamburger_cook'] != 0:
self.logger.info('Requesting Barbecue Grill')
o = {
'method': 'REQUEST_BARBECUE_GRILL',
'args': args
}
elif self.currently_cooking[ticket_no][
'fries_cook'] != 0:
self.logger.info('Requesting Fryer')
o = {'method': 'REQUEST_FRYER', 'args': args}
self.comm_thread.put_send_requests(o)
def run(self):
# socket to give clients a ticket number for their order
client_socket = socket.socket(socket.AF_INET, socket.SOCK_DGRAM)
client_socket.settimeout(3)
client_socket.bind(('localhost', self.port + 100))
# get entities table
entities_table = self.comm_thread.get_nodes_table()
while entities_table is None:
entities_table = self.comm_thread.get_nodes_table()
work(0.5)
self.logger.info('Entities table: %s', entities_table)
# all orders
#orders = {}
done = False
while not done:
# waiting for client order
p, addr = recv(client_socket)
if p is not None:
# Wait for a random time
delta = random.gauss(2, 0.5)
self.logger.info('Wait for %f seconds', delta)
work(delta)
o = pickle.loads(p)
method = o['method']
self.logger.info('Received client request: %s', method)
if o['method'] == 'ORDER':
self.logger.info('Order: %s', o['args'])
# ticket number to identify client order
ticket_no = str(uuid.uuid4())
order = o['args']
#orders[ticket_no] = order
# send cook order to chef
args = {}
args['client_addr'] = addr
args['order'] = order
args['ticket_no'] = ticket_no
args['id'] = choose_node('Chef', entities_table)
self.logger.info('Sending cook order to one Chef')
self.comm_thread.put_send_requests({
'method': 'COOK_ORDER',
'args': args
})
# send ticket number back to the client
self.logger.info('Ticket number: %s', ticket_no)
args = {'ticket_no': ticket_no, 'order': order}
send(client_socket, addr, {
'method': 'ORDER_REP',
'args': args
})
elif method == 'PICKUP':
args = {}
args['client_addr'] = addr
args['order'] = o['args']['order']
args['ticket_no'] = o['args']['ticket_no']
args['id'] = entities_table['Waiter'][0]
self.logger.info('Forwarding pickup request to Waiter')
self.comm_thread.put_send_requests({
'method': 'CLIENT_PICKUP',
'args': args
})
else:
try:
self.logger.debug('Getting received request')
request = self.comm_thread.get_recv_requests()
if request is None:
work(0.5)
continue
except:
self.logger.debug('Error getting received request')
continue
if request is not None:
self.logger.debug('Request %s', request)
# Wait for a random time
delta = random.gauss(2, 0.5)
self.logger.info('Wait for %f seconds', delta)
work(delta)
if request['method'] == 'CLIENT_ORDER':
# ticket number to identify client order
ticket_no = str(uuid.uuid4())
client_addr = request['args']['client_addr']
order = request['args']['order']
#orders[ticket_no] = order
# send cook order to chef
self.logger.info('Sending cook order to one Chef')
args = {}
args['client_addr'] = client_addr
args['order'] = order
args['ticket_no'] = ticket_no
args['id'] = choose_node('Chef', entities_table)
self.comm_thread.put_send_requests({
'method': 'COOK_ORDER',
'args': args
})
# send ticket number back to the client
self.logger.info('Ticket number: %s', ticket_no)
args = {'ticket_no': ticket_no, 'order': order}
send(client_socket, client_addr, {
'method': 'ORDER_REP',
'args': args
})
def request_burger(self):
self.grill.acquire()
work()
self.grill.release()
