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