def handle_identif(self, aid): """Este método é utilizado para cadastrar o agente que esta se identificando na tabela de agentes ativos. """ if aid.name in self.fact.table: display_message( 'AMS', 'Falha na Identificacao do agente ' + aid.name) # prepara mensagem de resposta message = ACLMessage(ACLMessage.REFUSE) message.set_sender(self.fact.aid) message.add_receiver(aid) message.set_content( 'Ja existe um agente com este identificador. Por favor, escolha outro.') # envia mensagem self.send_message(message.get_message()) return self.aid = aid self.fact.table[self.aid.name] = self.aid display_message( 'AMS', 'Agente ' + aid.name + ' identificado com sucesso') # prepara mensagem de resposta message = ACLMessage(ACLMessage.INFORM) message.set_sender(self.fact.aid) for receiver in self.fact.table.values(): message.add_receiver(receiver) message.set_content(dumps(self.fact.table)) self.fact.broadcast_message(message)
def on_time(self): super(AnalisaLances, self).on_time() message = ACLMessage(ACLMessage.INFORM) message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL) # Se ja tiverem lances registrados, vemos o atual maior lance e definimos ele como novo minimo if self.agent.lances: # Verifica se existe apenas um agente concorrente # Caso positivo o vencedor é declarado e o programa é encerrado. novo_lance_minimo = max(self.agent.lances.values()) if len(self.agent.lances) == 1: winner = list(self.agent.lances.keys())[0] self.agent.logger.log(self.agent.aid.name, f'O vencedor foi o comprador {winner}!') msg = ACLMessage(ACLMessage.INFORM) msg.add_receiver(AID(winner)) msg.set_content('vencedor') self.agent.send(msg) else: self.agent.logger.log( self.agent.aid.name, f'Novo valor a bater {novo_lance_minimo}') # Caso contrario, damos o primeiro lance minimo do leilao. Que deveria vir do objeto leiloado else: novo_lance_minimo = self.agent.objeto_leiloado.valor_inicial self.agent.logger.log( self.agent.aid.name, 'Iniciando leilão do item {} com valor inicial de R${}'. format(self.agent.objeto_leiloado.nome, novo_lance_minimo)) # usa o protocolo do editor para mandar o novo lance minimo a todos os compradores self.agent.lances.clear() message.set_content(f'lance:{novo_lance_minimo}') self.notify(message)
def handle_all_proposes(self, proposes): """ """ super(CompContNet1, self).handle_all_proposes(proposes) best_proposer = None higher_power = 0.0 other_proposers = list() display_message(self.agent.aid.name, 'Analyzing ball passing possibilities...') i = 1 # logic to select proposals by the higher available power. for message in proposes: content = message.content power = float(content) display_message(self.agent.aid.name, 'Analyzing ball passing chances {i}'.format(i=i)) display_message(self.agent.aid.name, 'Chances of receiving: {pot}'.format(pot=power)) i += 1 if power > higher_power: if best_proposer is not None: other_proposers.append(best_proposer) higher_power = power best_proposer = message.sender else: other_proposers.append(message.sender) display_message( self.agent.aid.name, 'The ball passed with potential: {pot} VA'.format( pot=higher_power)) if other_proposers != []: display_message( self.agent.aid.name, 'Telling the contingent the ball will not be passed to him...') answer = ACLMessage(ACLMessage.REJECT_PROPOSAL) answer.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) answer.set_content('') for agent in other_proposers: answer.add_receiver(agent) self.agent.send(answer) if best_proposer is not None: display_message( self.agent.aid.name, 'Passing the ball to {}'.format(self.agent.aid.name)) answer = ACLMessage(ACLMessage.ACCEPT_PROPOSAL) answer.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) answer.set_content('OK') answer.add_receiver(best_proposer) self.agent.send(answer)
def handle_all_proposes(self, proposes): """ """ super(CompContNet1, self).handle_all_proposes(proposes) melhor_propositor = None maior_potencia = 0.0 demais_propositores = list() display_message(self.agent.aid.name, 'Analisando propostas...') i = 1 for message in proposes: content = json.loads(message.content) potencia = content['dados']['potencia'] display_message(self.agent.aid.name, 'Analisando proposta {i}'.format(i=i)) display_message(self.agent.aid.name, 'Potencia Ofertada: {pot}'.format(pot=potencia)) i += 1 if potencia > maior_potencia: if melhor_propositor is not None: demais_propositores.append(melhor_propositor) maior_potencia = potencia melhor_propositor = message.sender else: demais_propositores.append(message.sender) display_message(self.agent.aid.name, 'A melhor proposta foi de: {pot} VA'.format( pot=maior_potencia)) if demais_propositores != []: display_message(self.agent.aid.name, 'Enviando respostas de recusa...') resposta = ACLMessage(ACLMessage.REJECT_PROPOSAL) resposta.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) resposta.set_content(json.dumps({'ref': 'CN_03'}, indent=4)) for agente in demais_propositores: resposta.add_receiver(agente) self.agent.send(resposta) if melhor_propositor is not None: display_message(self.agent.aid.name, 'Enviando resposta de aceitacao...') resposta = ACLMessage(ACLMessage.ACCEPT_PROPOSAL) resposta.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) resposta.set_content( json.dumps({'ref': 'CN_03', 'dados': json.loads(message.content)['dados']}, indent=4)) resposta.add_receiver(melhor_propositor) self.agent.send(resposta)
def react(self, message): super(Auto, self).react(message) if message.performative == ACLMessage.PROPOSE: display_message(self.aid.localname, "Да, какую машину выбрали?") message = ACLMessage() message.set_performative(ACLMessage.ACCEPT_PROPOSAL) message.set_content(json.dumps({'flag': False})) message.add_receiver(AID(name="agent_client@localhost:8011")) self.send(message) elif message.performative == ACLMessage.ACCEPT_PROPOSAL: content = json.loads(message.content) price = content['price'] if price == 0: self.type = content['type'] price = self.calculate_price() message = ACLMessage() message.set_performative(ACLMessage.ACCEPT_PROPOSAL) display_message(self.aid.localname, "Она стоит {}".format(price)) message.set_content(json.dumps({'flag': True, 'price': price})) message.add_receiver(AID(name="agent_client@localhost:8011")) self.send(message) else: display_message(self.aid.localname, "Автосалон получил {}".format(price)) display_message(self.aid.localname, "Вот ключи от вашей машины") display_message( self.aid.localname, "Не забудьте пристегнуть ремни во время поездки") display_message(self.aid.localname, "Всего хорошего и до свидания") elif message.performative == ACLMessage.REJECT_PROPOSAL: content = json.loads(message.content) price = content['price'] min_price = self.min_price() if min_price <= price: display_message( self.aid.localname, "Если вас эта стоимость не устраивает, мы можем снизить стоимость автомобиля" ) message = ACLMessage() message.set_performative(ACLMessage.ACCEPT_PROPOSAL) message.set_content(json.dumps({'flag': True, 'price': price})) message.add_receiver(AID(name="agent_client@localhost:8011")) self.send(message) else: display_message( self.aid.localname, "Извините, но на этот автомобиль нельзя снизить цену") message = ACLMessage() message.set_performative(ACLMessage.REJECT_PROPOSAL) message.add_receiver(AID(name="agent_client@localhost:8011")) self.send(message)
def handle_all_proposes(self, proposes): """ """ super(CompContNet1, self).handle_all_proposes(proposes) best_proposer = None higher_power = 0.0 other_proposers = list() display_message(self.agent.aid.name, 'Analyzing proposals...') i = 1 # logic to select proposals by the higher available power. for message in proposes: content = message.content power = float(content) display_message(self.agent.aid.name, 'Analyzing proposal {i}'.format(i=i)) display_message(self.agent.aid.name, 'Power Offered: {pot}'.format(pot=power)) i += 1 if power > higher_power: if best_proposer is not None: other_proposers.append(best_proposer) higher_power = power best_proposer = message.sender else: other_proposers.append(message.sender) display_message( self.agent.aid.name, 'The best proposal was: {pot} VA'.format(pot=higher_power)) if other_proposers != []: display_message(self.agent.aid.name, 'Sending REJECT_PROPOSAL answers...') answer = ACLMessage(ACLMessage.REJECT_PROPOSAL) answer.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) answer.set_content('') for agent in other_proposers: answer.add_receiver(agent) self.agent.send(answer) if best_proposer is not None: display_message(self.agent.aid.name, 'Sending ACCEPT_PROPOSAL answer...') answer = ACLMessage(ACLMessage.ACCEPT_PROPOSAL) answer.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) answer.set_content('OK') answer.add_receiver(best_proposer) self.agent.send(answer)
def handle_all_proposes(self, proposes): """ """ super(CompContNet1, self).handle_all_proposes(proposes) melhor_propositor = None maior_potencia = 0.0 demais_propositores = list() display_message(self.agent.aid.name, 'Analisando propostas...') i = 1 # lógica de seleção de propostas pela maior potência disponibilizada for message in proposes: content = message.content potencia = float(content) display_message(self.agent.aid.name, 'Analisando proposta {i}'.format(i=i)) display_message(self.agent.aid.name, 'Potencia Ofertada: {pot}'.format(pot=potencia)) i += 1 if potencia > maior_potencia: if melhor_propositor is not None: demais_propositores.append(melhor_propositor) maior_potencia = potencia melhor_propositor = message.sender else: demais_propositores.append(message.sender) display_message(self.agent.aid.name, 'A melhor proposta foi de: {pot} VA'.format( pot=maior_potencia)) if demais_propositores != []: display_message(self.agent.aid.name, 'Enviando respostas de recusa...') resposta = ACLMessage(ACLMessage.REJECT_PROPOSAL) resposta.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) resposta.set_content('') for agente in demais_propositores: resposta.add_receiver(agente) self.agent.send(resposta) if melhor_propositor is not None: display_message(self.agent.aid.name, 'Enviando resposta de aceitacao...') resposta = ACLMessage(ACLMessage.ACCEPT_PROPOSAL) resposta.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) resposta.set_content('OK') resposta.add_receiver(melhor_propositor) self.agent.send(resposta)
def react(self, message): super(Buyer, self).react(message) if message.performative == ACLMessage.PROPOSE: display_message(self.aid.localname, "Hello!") display_message(self.aid.localname, "How much you growth last month?") message = ACLMessage(performative=ACLMessage.PROPOSE) message.add_receiver(self.connection) self.send(message) elif message.performative == ACLMessage.ACCEPT_PROPOSAL: content = json.loads(message.content) is_start_of_negotiation = content['is_start_of_negotiation'] if not is_start_of_negotiation: random_number = int(random.randint(0, 2)) random_type = self.metrics[random_number] display_message(self.aid.localname, "Let's talk about {}".format(random_type)) display_message(self.aid.localname, "We can invest {}$".format(self.hedge)) message = ACLMessage() message.set_performative(ACLMessage.ACCEPT_PROPOSAL) message.set_content( json.dumps({ 'type': random_type, 'price': 0 })) message.add_receiver(AID(name="startup@localhost:8022")) self.send(message) else: growth = content['growth'] price = content['price'] if self.hedge >= price or ( growth and (price / self.hedge < growth / 100)): display_message(self.aid.localname, "We invest, take money") message = ACLMessage() message.set_performative(ACLMessage.ACCEPT_PROPOSAL) message.set_content(json.dumps({'price': price})) message.add_receiver(AID(name="startup@localhost:8022")) self.send(message) else: display_message(self.aid.localname, "To expensive for such valuation") display_message( self.aid.localname, "We can suggest only {}$".format( (self.hedge * growth) / 100)) message = ACLMessage() message.set_performative(ACLMessage.REJECT_PROPOSAL) message.set_content(json.dumps({'price': self.hedge})) message.add_receiver(AID(name="startup@localhost:8022")) self.send(message) elif message.performative == ACLMessage.REJECT_PROPOSAL: display_message(self.aid.localname, "Thanks, see u")
def react(self, message): super(Seller, self).react(message) if message.performative == ACLMessage.PROPOSE: display_message(self.aid.localname, "Which value u interested in?") message = ACLMessage() message.set_performative(performative=ACLMessage.ACCEPT_PROPOSAL) message.set_content(json.dumps({'is_start_of_negotiation': False})) message.add_receiver(self.connection) self.send(message) elif message.performative == ACLMessage.ACCEPT_PROPOSAL: content = json.loads(message.content) price = content['price'] if price == 0: self.type = content['type'] self.type_growth[self.type] = self.calculate_growth() price_to_sell = self.calculate_price() message = ACLMessage(performative=ACLMessage.ACCEPT_PROPOSAL) display_message( self.aid.localname, "We growth on {}% last month".format( self.type_growth[self.type])) display_message(self.aid.localname, "We want {}$".format(price_to_sell)) message.set_content( json.dumps({ 'is_start_of_negotiation': True, 'growth': self.type_growth[self.type], 'price': price_to_sell })) message.add_receiver(self.connection) self.send(message) else: display_message(self.aid.localname, "Waiting for your lawyer") display_message(self.aid.localname, "See u") elif message.performative == ACLMessage.REJECT_PROPOSAL: content = json.loads(message.content) price = content['price'] min_price = self.calculate_price() if min_price <= price: display_message(self.aid.localname, "Agreed") message = ACLMessage(performative=ACLMessage.ACCEPT_PROPOSAL) message.set_content( json.dumps({ 'is_start_of_negotiation': True, 'price': price, 'growth': self.type_growth[self.type] })) message.add_receiver(self.connection) self.send(message) else: display_message(self.aid.localname, "YCombinator always been") message = ACLMessage(performative=ACLMessage.REJECT_PROPOSAL) message.add_receiver(self.connection) self.send(message)
def react(self, message): super(Client, self).react(message) if message.performative == ACLMessage.PROPOSE: display_message(self.aid.localname, "Добрый день!") display_message(self.aid.localname, "Я хочу купить машину") display_message(self.aid.localname, "Что можете предложить?") message = ACLMessage() message.set_performative(ACLMessage.PROPOSE) message.add_receiver(AID(name="agent_auto@localhost:8022")) self.send(message) elif message.performative == ACLMessage.ACCEPT_PROPOSAL: content = json.loads(message.content) flag = content['flag'] if not flag: random_number = int(random.randint(0, 3)) random_type = self.model_auto[random_number] display_message( self.aid.localname, "Я хочу приобрести {} машину".format(random_type)) display_message(self.aid.localname, "Я располагаю суммой {}".format(self.price)) message = ACLMessage() message.set_performative(ACLMessage.ACCEPT_PROPOSAL) message.set_content( json.dumps({ 'type': random_type, 'price': 0 })) message.add_receiver(AID(name="agent_auto@localhost:8022")) self.send(message) else: price = content['price'] if self.price >= price: display_message(self.aid.localname, "Этот вариант мне походит ") message = ACLMessage() message.set_performative(ACLMessage.ACCEPT_PROPOSAL) message.set_content(json.dumps({'price': price})) message.add_receiver(AID(name="agent_auto@localhost:8022")) self.send(message) else: display_message(self.aid.localname, "У меня столько нет") display_message(self.aid.localname, "Сейчас у меня{}".format(self.price)) message = ACLMessage() message.set_performative(ACLMessage.REJECT_PROPOSAL) message.set_content(json.dumps({'price': self.price})) message.add_receiver(AID(name="agent_auto@localhost:8022")) self.send(message) elif message.performative == ACLMessage.REJECT_PROPOSAL: display_message(self.aid.localname, "Спасибо, до свидания")
def async_request(): message = ACLMessage() message.set_content('request') message.add_receiver(self.receiver) while True: try: response = yield from self.request.send_request( message) print('informed') queue.put_nowait( response.performative == ACLMessage.INFORM) queue.put_nowait(response.content == 'inform') except FipaAgreeHandler as m: response = m.message print('agreed') queue.put_nowait( response.performative == ACLMessage.AGREE) queue.put_nowait(response.content == 'agree') except FipaProtocolComplete: break message = ACLMessage() message.set_content('request') message.add_receiver(self.receiver) while True: try: response = yield from self.request.send_request( message) print('informed2') queue.put_nowait( response.performative == ACLMessage.INFORM) queue.put_nowait(response.content == 'inform') except FipaAgreeHandler as m: response = m.message print('agreed2') queue.put_nowait( response.performative == ACLMessage.AGREE) queue.put_nowait(response.content == 'agree') except FipaProtocolComplete: break queue.put_nowait(None)
def lineReceived(self, line): """Este método é executado sempre que uma nova mensagem é recebida pelo agente, tanto no modo cliente quanto no modo servidor :param line: mensagem recebida pelo agente """ # fase 2 de identificação do agente com o AMS. Nesta fase o agente AMS retorna uma mensagem # ao agente com uma tabela de todos os agentes presentes na rede if self.fact.state == 'IDENT2' and 'AMS' in line: message = ACLMessage() message.set_message(line) self.fact.table = loads(message.content) if self.fact.debug: display_message( self.fact.aid.name, 'Tabela atualizada: ' + str(self.fact.table.keys())) else: pass # alteração do estado de em fase de identificação # para pronto para receber mensagens self.fact.state = 'READY' self.fact.on_start() # self.transport.loseConnection() # caso o agente não esteja na fase 2 de identificação, então estará na fase # de recebimento de mensagens, e assim estará pronto para executar seus # comportamentos else: # este método é executado caso a mensagem recebida tenha sido # enviada pelo AMS para atualização da tabela de agentes disponíveis if 'AMS' in line: message = ACLMessage() message.set_message(line) self.fact.table = loads(message.content) if self.fact.debug: display_message( self.fact.aid.name, 'Tabela atualizada: ' + str(self.fact.table.keys())) else: pass self.transport.loseConnection() # recebe uma parte da mensagem enviada else: PeerProtocol.lineReceived(self, line)
def action(self): # Preparing a message to 'pong' message = ACLMessage(ACLMessage.INFORM) message.add_receiver(self.agent.pong) message.set_content('PING') # Sending the message self.send(message)
def connectionMade(self): """Este método é executado sempre que uma conexão é executada entre um agente no modo cliente e um agente no modo servidor """ # fase 1 de identificação do agente com o AMS if self.fact.state == 'IDENT1': # cria a mensagem de registro no AMS msg = ACLMessage() msg.add_receiver( AID(name='AMS@' + self.fact.ams['name'] + ':' + str(self.fact.ams['port']))) msg.set_sender(self.fact.aid) msg.set_performative(ACLMessage.INFORM) msg.set_content(dumps({'ref': 'IDENT', 'aid': self.fact.aid})) # envia a mensagem ao AMS e atualiza a flag de identificação para a # fase 2 self.fact.state = 'IDENT2' self.send_message(msg.get_message()) # se não é a fase de identificação 1 então o agente tenta enviar as mensagens presentes # na fila de envio representada pela variável self.fact.messages else: # captura o host conectado ao agente por meio do metodo # self.transport.getPeer() PeerProtocol.connectionMade(self)
def send_message(self): message = ACLMessage(ACLMessage.QUERY_IF) message.set_protocol(ACLMessage.FIPA_QUERY_PROTOCOL) message.add_receiver(self.receiver_agent) self.add_all_agents(message.receivers) message.set_content(self.message) self.send(message)
def send_response(self, response, sender): answer = ACLMessage(ACLMessage.ACCEPT_PROPOSAL) answer.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) answer.set_content(pickle.dumps(response)) answer.add_receiver(sender) self.agent.send(answer)
def do_long_job_callback(question): request_calc = ACLMessage() request_calc.set_content(question) request_calc.add_receiver(self.calculator_aid) while True: try: response_calc = yield from self.consult_behavior.send_request( request_calc) display_message( self.aid.name, f'I received INFORM: {response_calc.content} from {response_calc.sender.name}' ) except FipaProtocolComplete: break def more_long_job(): # Massive calculations part II display_message(self.aid.name, f'Doing second long job') time.sleep(1.25) return response_calc.content def more_long_job_callback(result): # There is still a reference to the incoming request display_message(self.aid.name, f'Calling callback') reply_inform = message.create_reply() reply_inform.set_content(f'The result is: {result}') self.inform_behavior.send_inform(reply_inform) print('END OF PROTOCOL') # Another blocking method in other thread, this time using callback defer_to_thread(more_long_job, more_long_job_callback)
def async_request(receiver): # Message to send message = ACLMessage() message.set_content('Would you do me a favor?') message.add_receiver(receiver) while True: try: response_message = yield from self.request_behavior.send_request( message) content = response_message.content display_message( self.aid.name, f'I received INFORM: {content} from {response_message.sender.name}' ) except FipaAgreeHandler as e: response_message = e.message content = response_message.content display_message( self.aid.name, f'I received AGREE: {content} from {response_message.sender.name}' ) except FipaProtocolComplete as e: display_message( self.aid.name, f'I received all messages from {receiver.name}!') break
def call_subscribe(self, publisher_aid): # Message to send message = ACLMessage() message.set_content('Subscribe me, please!') message.add_receiver(publisher_aid) while True: try: # Expecting INFORM by default inform = yield from self.subscribe.send_subscribe(message) display_message( self.aid.name, f'I received INFORM: {inform.content} from {inform.sender.name}' ) except FipaAgreeHandler as h: agree = h.message display_message( self.aid.name, f'I received AGREE: {agree.content} from {agree.sender.name}' ) except FipaRefuseHandler as h: refusal = h.message display_message( self.aid.name, f'I received REFUSE: {refusal.content} from {refusal.sender.name}' ) except FipaFailureHandler as h: failure = h.message display_message( self.aid.name, f'I received FAILURE: {failure.content} from {failure.sender.name}' ) except FipaProtocolComplete: break
def __init__(self, host, port, session, main_ams=True, debug=False): self.ams_aid = AID('ams@' + str(host) + ':' + str(port)) super(AMS, self).__init__(self.ams_aid, debug=debug) self.ams = {'name': str(host), 'port': str(port)} super(AMS, self).update_ams(self.ams) self.host = host self.port = port self.session = session self.main_ams = main_ams self.agents_conn_time = dict() self.comport_ident = PublisherBehaviour(self) # message to check the connection. message = ACLMessage(ACLMessage.REQUEST) message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) self.add_all(message) message.set_content('CONNECTION') message.set_system_message(is_system_message=True) self.comport_conn_verify = CompConnectionVerify(self, message) self.comport_send_conn_messages = ComportSendConnMessages( self, message, 4.0) self.comport_conn_verify_timed = ComportVerifyConnTimed(self, 10.0) self.comport_conn_verify_reg = CompVerifyRegister(self) self.system_behaviours.append(self.comport_ident) self.system_behaviours.append(self.comport_conn_verify) self.system_behaviours.append(self.comport_send_conn_messages) self.system_behaviours.append(self.comport_conn_verify_timed) self.system_behaviours.append(self.comport_conn_verify_reg) self.on_start()
def asking_land_price(self): display_message(self.aid.localname, 'Going to meet land owner') msg = "I need to buy the house. What is the price?" message = ACLMessage(ACLMessage.INFORM) message.add_receiver(AID('land_owner')) message.set_content(msg) self.send(message)
def send_message(self, receiver_agent): message = ACLMessage(ACLMessage.INFORM) message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) message.add_receiver(receiver_agent) self.add_all_agents(message.receivers) message.set_content(self.message) self.send(message)
def async_cfp(): # Message to send message = ACLMessage() message.set_content('Send me proposals, please!') for r in recipients_aid: message.add_receiver(r) self.contract_net.send_cfp(message) proposals_received = [] while True: try: # Expecting PROPOSAL by default proposal = yield message display_message( self.aid.name, f'I received PROPOSE: {proposal.content} from {proposal.sender.name}' ) proposals_received.append(proposal) except FipaRefuseHandler as h: refusal = h.message display_message( self.aid.name, f'I received REFUSE: {refusal.content} from {refusal.sender.name}' ) except FipaCfpComplete: break try: best_value = max(int(m.content) for m in proposals_received) except ValueError: display_message(self.aid.name, f'No proposals!') return best_proposal = next(m for m in proposals_received if int(m.content) == best_value) # Reject message for message in filter(lambda m: m != best_proposal, proposals_received): reply = message.create_reply() reply.set_content('Rejected, sorry!') # It does not create a session self.contract_net.send_reject_proposal(reply) # Accept message reply = best_proposal.create_reply() reply.set_content('Accepted!') # It creates a session self.contract_net.send_accept_proposal(reply) try: # Expects INFORM by default inform = yield reply content = inform.content display_message( self.aid.name, f'I received INFORM: {content} from {inform.sender.name}') except FipaFailureHandler as h: failure = h.message
def individual_request(receiver): message = ACLMessage() message.set_ontology(swc.__name__) message.set_content(message_content) message.add_receiver(receiver) while True: try: response = yield from self.p_command.send_request(message) display_message( self.aid.name, f'[Comando de Chave] Inform: {response.content}') except FipaRefuseHandler as h: response = h.message display_message( self.aid.name, f'[Comando de Chave] Refuse: {response.content}') except FipaFailureHandler as h: response = h.message display_message( self.aid.name, f'[Comando de Chave] Failure: {response.content}') except FipaAgreeHandler: pass except FipaProtocolComplete: break return response
def __init__(self, aid): super(BallReceivingWinger, self).__init__(aid=aid, debug=False) print('Winger') message = ACLMessage(ACLMessage.SUBSCRIBE) message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL) message.set_content("Ball!!") self.call_later(8.0, self.launch_subscriber_protocol, message)
def connectionLost(self, reason): """Este método executa qualquer coisa quando uma conexão é perdida :param reason: Identifica o problema na perda de conexão """ if self.message is not None: message = PeerProtocol.connectionLost(self, reason) # envia mensagem recebida para o AMS # montagem da mensagem a ser enviada ao AMS _message = ACLMessage(ACLMessage.INFORM) ams_aid = AID(name='AMS@' + self.fact.ams['name'] + ':' + str(self.fact.ams['port'])) _message.add_receiver(ams_aid) _message.set_sender(self.fact.aid) _message.set_content(dumps({'ref': 'MESSAGE', 'message': message})) # fim da montagem da mensagem # armazenamento da mensagem para envio self.fact.messages.append((ams_aid, _message)) # estabelecimento de conexão com AMS reactor.connectTCP(self.fact.ams['name'], int(self.fact.ams['port']), self.fact) # execução do comportamento Agent.react à mensagem # recebida self.message = None self.fact.react(message)
def on_time(self): super(Time, self).on_time() message = ACLMessage(ACLMessage.INFORM) message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL) message.set_content(str(random.random())) self.notify(message) self.inc += 0.1
def on_tick(self): message = ACLMessage(ACLMessage.INFORM) message.add_receiver(self.agent.receiver) message.set_content('Message #%d' % self.counter) self.send(message) self.counter += 1 display_message(self.agent, 'Message sent to receiver.')
def notify(self): message = ACLMessage(ACLMessage.INFORM) message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL) message.set_content(dumps(self.agent.agentInstance.table)) message.set_system_message(is_system_message=True) self.STATE = 0 super(PublisherBehaviour, self).notify(message)
def handle_request(self, message): # carrega o conteudo da mensagem recebida self.content = json.loads(message.content) if self.content['ref'] == 'R_04': display_message(self.agent.aid.name, 'Mensagem REQUEST recebida') # cria resposta para a mensagem recebida resposta = message.create_reply() resposta.set_performative(ACLMessage.INFORM) content = json.dumps({'ref': 'R_04'}, indent=4) resposta.set_content(content) self.agent.send(resposta) rams_desener = self.encontrar_rams_desener() message = ACLMessage(ACLMessage.CFP) message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) message.set_content(json.dumps({'ref': 'CN_01', 'dados': pickle.dumps(rams_desener) }, indent=4)) for agente in self.agent.topologia['alimentadores'].keys(): if self.agent.aid.localname not in agente: message.add_receiver(AID(agente)) # lança comportamento ContractNet na versão Iniciante comp = CompContNet1(self.agent, message) self.agent.behaviours.append(comp) comp.on_start()