def send_propose(self, message: ACLMessage): message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) message.set_performative(ACLMessage.PROPOSE) response = yield AgentSession(self, message) return response
def connectionMade(self): """ Este método é executado sempre que uma conexão é executada entre um cliente e um servidor """ # fase de identificação do agente com o AMS if self.factory.state == 'IDENT': # cria a mensagem de registro no AMS msg = ACLMessage() msg.add_receiver( AID(name='AMS' + '@' + self.factory.ams['name'] + ':' + str(self.factory.ams['port']))) msg.set_sender(self.factory.aid) msg.set_performative(ACLMessage.INFORM) msg.set_content(dumps(self.factory.aid)) # envia a mensagem ao AMS self.factory.state = 'READY' self.sendLine(msg.get_message()) self.transport.loseConnection() else: peer = self.transport.getPeer() for message in self.factory.messages: if int(message[0].port) == int(peer.port): self.sendLine(message[1].get_message()) self.factory.messages.remove(message) self.transport.loseConnection() break
def send_agree(self, message: ACLMessage): message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL) message.set_performative(ACLMessage.AGREE) # Send message to all receivers self.agent.send(message)
def send_inform(self, message: ACLMessage): message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) message.set_performative(ACLMessage.INFORM) # Send message to all receivers self.agent.send(message)
def send_subscribe(self, message: ACLMessage): message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL) message.set_performative(ACLMessage.SUBSCRIBE) response = yield AgentSession(self, message) return response
def send_refuse(self, message: ACLMessage): message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) message.set_performative(ACLMessage.REFUSE) # Send message to all receivers self.agent.send(message)
def send_failure(self, message: ACLMessage): message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) message.set_performative(ACLMessage.FAILURE) # Send message to all receivers self.agent.send(message)
def lineReceived(self, line): """Este método é executado sempre que uma mesagem é recebida pelo agente Sniffer """ # 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.ui.listWidget.clear() # loop for verifica se os agentes enviados na lista do AMS já estão # cadastrados na tabela do agente self.fact.table = loads(message.content) for agent in self.fact.table: serifFont = QtGui.QFont(None, 10, QtGui.QFont.Bold) item = QtGui.QListWidgetItem(str(agent) + '\n') item.setFont(serifFont) self.fact.ui.listWidget.addItem(item) # caso a mensagem recebida seja de um agente a lista de mensagens deste # agente é atualizada else: PeerProtocol.lineReceived(self, line)
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(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 on_time(self): super(Time, self).on_time() message = ACLMessage(ACLMessage.INFORM) message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL) message.set_content(str(sin(self.inc))) self.notify(message) self.inc += 0.1
def send_not_understood(self, message: ACLMessage): message.set_performative(ACLMessage.NOT_UNDERSTOOD) # Send message to all receivers self.agent.send(message) return AgentSession(self, message)
def send_subscribe(self, message: ACLMessage): message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL) message.set_performative(ACLMessage.SUBSCRIBE) # Send message to all receivers self.agent.send_until(message) return message
def send_refuse(self, message: ACLMessage): message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) message.set_performative(ACLMessage.REFUSE) # Send message to all receivers self.agent.send_until(message) return message
def send_reject_proposal(self, message: ACLMessage): message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) message.set_performative(ACLMessage.REJECT_PROPOSAL) # Send message to all receivers self.agent.send_until(message) return message
def send_agree(self, message: ACLMessage): message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) message.set_performative(ACLMessage.AGREE) # Send message to all receivers self.agent.send_until(message) return message
def send_request(self, message: ACLMessage): # Only individual messages assert len(message.receivers) == 1 message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) message.set_performative(ACLMessage.REQUEST) response = yield AgentSession(self, message) return response
def send_message(self, receiver_agent, book): message = ACLMessage(ACLMessage.INFORM) message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) message.add_receiver(receiver_agent) self.add_all_agents(message.receivers) if book is None: message.set_content('Requested book is not available') else: message.set_content(book) self.send(message)
def inform(self, message: ACLMessage): """Use low-level twisted method to send message""" message.set_performative(ACLMessage.INFORM) receiver = message.receivers[0] try: self.agent.agentInstance.messages.append((receiver, message)) reactor.connectTCP(receiver.host, receiver.port, self.agent.agentInstance) except: self.agent.agentInstance.messages.pop()
def update_ams(self, ams): super(Agent, self).update_ams(ams) message = ACLMessage(ACLMessage.SUBSCRIBE) message.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL) ams_aid = AID('ams@' + self.ams['name'] + ':' + str(self.ams['port'])) message.add_receiver(ams_aid) message.set_content('IDENT') message.set_system_message(is_system_message=True) self.comport_ident = SubscribeBehaviour(self, message) self.system_behaviours.append(self.comport_ident)
def connectionLost(self, reason): if self.message is not None: try: message = ACLMessage() message.set_message(self.message) except: print('Message not understood') print(self.message) return return message
def one_request(self, receiver): message = ACLMessage() message.add_receiver(receiver) while True: try: response = yield from self.req.send_request(message) except FipaMessageHandler as h: response = h.message except FipaProtocolComplete: break return response
def clientConnectionFailed(self, connector, reason): for name, aid in self.table.iteritems(): if aid.port == connector.port: display_message( self.aid.name, 'O agente ' + aid.name + ' esta desconectado.') print reason self.table.pop(name) message = ACLMessage(ACLMessage.INFORM) message.set_sender(self.aid) message.set_content(dumps(self.table)) self.protocol.broadcast_message(message) break
def lineReceived(self, line): """ Quando uma mensagem é enviada ao AMS este método é executado. Quando em fase de identificação, o AMS registra o agente em sua tabele de agentes ativos """ message = ACLMessage() # carrega a mesagem recebida no objeto message message.set_message(line) # como o agente AMS só recebe mensagens self.handle_identif(loads(message.content))
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('I have received Student Object successfully') 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 send_message(self): try: message = ACLMessage(ACLMessage.INFORM) message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) message.add_receiver(self.computer_agent) self.add_all_agents(message.receivers) print("Human's Turn") i = None j = None #check wrong inputs by human while (True): digit = True in_range = True new_pos = True pos = input('Enter your position:') if not pos.isdigit(): digit = False print("Please enter a digit!") continue pos = int(pos) if (pos < 1 or pos > 9): in_range = False print("Enter between 1-9") continue # mapping the position entered with board position if (pos <= 3): i = 0 elif (pos > 3 and pos <= 6): i = 1 else: i = 2 if (pos % 3 == 0): j = 2 else: j = pos % 3 - 1 if (board[i][j] != '_'): new_pos = False print("Already occupied!") continue break board[i][j] = 'X' print_board() result = finished() if (result == 'X'): print("You won !") sys.exit() elif (result == "Tie"): print("Tie\n") sys.exit() message.set_content('Human Agent played "X" at position' + str(pos)) self.send(message) except: print("")
def send_message(self, receiver_agent): try: message = ACLMessage(ACLMessage.INFORM) message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) message.add_receiver(receiver_agent) self.add_all_agents(message.receivers) print("Computer's Turn") start = time.time() (m, pos_x, pos_y) = maximize() finish = time.time() print("time =", round((finish - start), 5), "sec") board[pos_x][pos_y] = 'O' print_board() result = finished() if (result == 'O'): print("Computer won !") sys.exit() elif (result == "Tie"): print("tie") sys.exit() message.set_content('Computer Agent played "O" at position') self.send(message) except: print("")
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 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 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()
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, 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 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 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 lineReceived(self, line): """ Este método é executado sempre que uma mesagem é recebida pelo agente Sniffer """ message = ACLMessage() message.set_message(line) display_message(self.factory.aid.name, 'Mensagem recebida de: ' + str(message.sender.name)) # 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 message.sender.name: self.factory.ui.listWidget.clear() # loop for verifica se os agentes enviados na lista do AMS já estão # cadastrados na tabela do agente self.factory.table = loads(message.content) for agent in self.factory.table: serifFont = QtGui.QFont(None, 10, QtGui.QFont.Bold) item = QtGui.QListWidgetItem(str(agent) + '\n') item.setFont(serifFont) self.factory.ui.listWidget.addItem(item) # caso a mensagem recebida seja de um agente a lista de mensagens deste # agente é atualizada elif message.performative == ACLMessage.INFORM: display_message( self.factory.aid.name, 'Lista de Mensagens Recebida') agent = message.sender.name for i in self.factory.agents_messages: if agent == i: messages = self.factory.agents_messages[i] messages.extend(loads(message.content)) self.factory.agents_messages[i] = messages break else: self.factory.agents_messages[agent] = loads(message.content) print self.factory.agents_messages[agent] self.show_messages(self.factory.agents_messages[agent])
def onItemChanged(self, current, previous): for name, aid in self.table.iteritems(): if name in current.text() and not ('Sniffer' in name): message = ACLMessage(ACLMessage.REQUEST) message.set_sender(self.aid) message.add_receiver(aid) message.set_content('Request messages history') self.messages.append((aid, message)) reactor.connectTCP(aid.host, aid.port, self) break
def __init__(self, aid): super(AgenteIniciante, self).__init__(aid=aid, debug=False) message = ACLMessage(ACLMessage.CFP) message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL) message.set_content('60.0') message.add_receiver(AID('AP1')) message.add_receiver(AID('AP2')) comp = CompContNet1(self, message) self.behaviours.append(comp) self.call_later(2.0, comp.on_start)
def connectionMade(self): """ Este método é executado sempre que uma conexão é executada entre um cliente e um servidor """ # fase de identificação do agente com o AMS if self.fact.state == 'IDENT': # 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(self.fact.aid)) # envia a mensagem ao AMS self.fact.state = 'READY' self.sendLine(msg.get_message()) self.transport.loseConnection() display_message(self.fact.aid.localname, "Mensagem de autenticacao enviada") else: PeerProtocol.connectionMade(self)
def __init__(self, aid): super(AgenteRelogio, self).__init__(aid=aid) # mensagem que requisita horario do horario message = ACLMessage(ACLMessage.REQUEST) message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) message.add_receiver(AID(name='horario')) message.set_content('time') self.comport_request = CompRequest2(self, message) self.comport_temp = ComportTemporal(self, 1.0, message) self.behaviours.append(self.comport_request) self.behaviours.append(self.comport_temp)
def filter(self, message): state = True if self.conversationID != None and self.conversationID != message.conversationID: state = False if self.sender != None and self.sender != message.sender: state = False if self.performative != None and self.performative != message.performative: state = False if self.protocol != None and self.protocol != message.protocol: state = False return state if __name__ == '__main__': message = ACLMessage(ACLMessage.REQUEST) message.set_sender(AID('lucas')) message.add_receiver('allana') message.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) filtro = Filter() filtro.set_protocol(ACLMessage.FIPA_REQUEST_PROTOCOL) if filtro.filter(message): print message.as_xml() else: print 'A mensagem foi barrada pelo protocolo'
def __init__(self, aid): super(AgenteParticipante, self).__init__(aid) self.protocol = SubscribeParticipant(self) self.timed = Time(self, self.protocol.notify) self.behaviours.append(self.protocol) self.behaviours.append(self.timed) if __name__ == '__main__': set_ams('localhost', 5000, debug=False) editor = AgenteParticipante(AID('editor')) editor.ams = {'name': 'localhost', 'port': 5000} msg = ACLMessage(ACLMessage.SUBSCRIBE) msg.set_protocol(ACLMessage.FIPA_SUBSCRIBE_PROTOCOL) msg.set_content('Pedido de subscricao') msg.add_receiver('editor') ass1 = AgenteInitiator(AID('assinante_1'), msg) ass1.ams = {'name': 'localhost', 'port': 5000} ass2 = AgenteInitiator(AID('assinante_2'), msg) ass2.ams = {'name': 'localhost', 'port': 5000} agentes = [editor, ass1, ass2] start_loop(agentes, gui=True)
def handle_identif(self, aid): """ handle_identif -------------- Este método é utilizado para cadastrar o agente que esta se identificando na tabela de agentes ativos. """ if aid.name in self.factory.table: display_message( 'AMS', 'Falha na Identificacao do agente ' + aid.name) # prepara mensagem de resposta message = ACLMessage(ACLMessage.REFUSE) message.set_sender(self.factory.aid) message.add_receiver(aid) message.set_content( 'Ja existe um agente com este identificador. Por favor, escolha outro.') # envia mensagem self.sendLine(message.get_message()) return self.aid = aid self.factory.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.factory.aid) for receiver in self.factory.table.values(): message.add_receiver(receiver) message.set_content(dumps(self.factory.table)) self.broadcast_message(message)
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 connectionLost(self, reason): if self.message is not None: message = ACLMessage() message.set_message(self.message) return message
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 """ # TODO: Melhorar o armazenamento e a troca deste tipo de mensagem # entre o agente e o agente Sniffer # 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() # este método é executado caso a mensagem recebida tenha sido enviada pelo Agente Sniffer # que requisita a tabela de mensagens do agente elif 'Sniffer' in line: # se for a primeira mensagem recebida do agente Sniffer, então seu endereço, isto é nome # e porta, é armazenado na variável do tipo dicionário # self.fact.sniffer message = ACLMessage() message.set_message(line) if self.fact.debug: display_message( self.fact.aid.name, 'Solicitação do Sniffer Recebida') else: pass self.sniffer_message(message) self.transport.loseConnection() # recebe uma parte da mensagem enviada else: PeerProtocol.lineReceived(self, line)