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 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 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 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 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 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 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 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.')
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 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 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 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 create_message(slave, params):
content = {
var.name: var.getter()
for var in slave.vars.values()
if var.causality == pade.fmi.Fmi2Causality.input
}
content.update(params)
message = ACLMessage(ACLMessage.FIPA_REQUEST_PROTOCOL)
message.set_performative(ACLMessage.REQUEST)
message.set_sender(slave.wrapper_aid)
message.add_receiver(slave.agent_aid)
message.set_message_id()
message.set_conversation_id(str(uuid1()))
message.set_content(json.dumps(content))
message.set_datetime_now()
return pickle.dumps(message)
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 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'
state = False
if self.performative != None and self.performative != message.performative:
state = False
if self.protocol != None and self.protocol != message.protocol:
state = False
if self.ontology != None and self.ontology != message.ontology:
state = False
if self.language != None and self.language != message.language:
state = False
return state
if __name__ == '__main__':
message = ACLMessage(ACLMessage.REQUEST)
message.set_sender(AID('john'))
message.add_receiver('mary')
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('The message was blocked by the protocol.')
def sending_message(self):
message = ACLMessage(ACLMessage.INFORM)
message.set_sender(AID('Reconhecedor_Voz'))
message.add_receiver(AID('Semantizador'))
message.set_content('Ola')
self.send(message)
