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()