def play(self):
pos = self.play_move()
available[pos] = False
position = lookup[pos]
game_board[position[0]][position[1]] = self.move
display_message(self.aid.localname, "Thinking...")
sleep(1)
for i in range(3):
for j in range(3):
if game_board[i][j] is None:
if j < 2:
print("-", end=" | ")
else:
print("-")
else:
if j < 2:
print(game_board[i][j], end=" | ")
else:
print(game_board[i][j])
# Check for winner
if terminal(game_board):
game_result = winner(game_board)
if game_result is None:
print("\nIts a TIE!!")
else:
print("\nWinner: %s" % game_result)
else:
self.send_message(pos)
def handle_subscribe(self, message):
self.register(message.sender)
display_message(self.agent.aid.name, message.content)
response = message.create_reply()
response.set_performative(ACLMessage.AGREE)
response.set_content('Goal!!!')
self.agent.send(response)
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 __init__(self, port, debug):
self.state = 'IDENT'
self.debug = debug
# dictionary que tem como keys o nome dos agentes e como valor o objeto aid que identifica o agente
# indicado pela chave
self.table = {}
# lista que armazena as mensagens recebidas pelo AMS, devera ser utilizada posteriormente pelo
# serviço de visualização de mensagens
self.messages = []
# aid do agente AMS
self.aid = AID(name='AMS' + '@' + 'localhost' + ':' + str(port))
display_message(
'AMS', 'AMS esta servindo na porta' + str(self.aid.port))
# instancia do objeto que implementa o protocolo AMS
self.protocol = AgentManagementProtocol(self)
# instancia o objeto que realizará a conexão com o banco de dados
self.conn = adbapi.ConnectionPool(
'sqlite3', 'database.db', check_same_thread=False)
self.d = self.createAgentsTable()
self.d.addCallback(self.insert_agent)
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 next_move(self):
self.game.print_board()
display_message(self.aid.localname, self.aid.localname + "'s turn")
# if alpha beta pruning is enabled
if self.game.alpha_beta:
# alpha = -inf, beta = inf
_, cell = self.minimax_with_alpha_beta_pruning(0, -inf, inf, True)
# if alpha beta pruning is disabled
else:
_, cell = self.minimax(0, True)
# making move
self.game.board[cell - 1] = self.mark
self.game.move_number += 1
print(self.aid.localname + " marked cell:", cell)
winner = self.game.check_winner()
if winner == "tie":
self.game.print_board()
print("Game Draw!!!")
return
elif winner == self:
self.game.print_board()
print(self.aid.localname + " Won!!!")
return
self.send_message()
def play_move(self):
display_message(self.aid.localname, "Enter a spot for your move: ")
sleep(1)
count = 0
for i in range(3):
for j in range(3):
count += 1
if game_board[i][j] is None:
if j < 2:
print(count, end=" | ")
else:
print(count)
else:
if j < 2:
print(game_board[i][j], end=" | ")
else:
print(game_board[i][j])
move = int(input(""))
if move < 1 or move > 9:
print("Pick a spot on the board!!")
return self.play_move()
if not available[move]:
print("Pick an empty spot only!!")
return self.play_move()
return move
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 __init__(self, port, debug):
self.state = 'IDENT'
self.debug = debug
# dictionary que tem como keys o nome dos agentes e como valor o objeto aid que identifica o agente
# indicado pela chave
self.table = {}
# lista que armazena as mensagens recebidas pelo AMS, devera ser utilizada posteriormente pelo
# serviço de visualização de mensagens
self.messages = []
# aid do agente AMS
self.aid = AID(name='AMS' + '@' + 'localhost' + ':' + str(port))
display_message(
'AMS', 'AMS esta servindo na porta ' + str(self.aid.port))
# instancia o objeto que realizará a conexão com o banco de dados
self.conn = adbapi.ConnectionPool(
'sqlite3', 'database.db', check_same_thread=False)
self.d = self.createAgentsTable()
self.d.addCallback(self.insert_agent)
# Inicialização do comportamento de verificação das conexões
reactor.callLater(5, self.connection_test_send)
def on_wake(self):
# Preparing a message
call = ACLMessage(ACLMessage.REQUEST)
call.set_content('I need help!')
call.add_receiver(self.agent.attendant)
self.send(call) # Sending a message
display_message(self.agent, 'I am making a call.')
def sending_cmd(self):
CMD = "plaquettes"
display_message(self.aid.localname,
"Acheteur : Envoie d'une commande au courtier")
'''#definir un message de type REQUEST avec un protocole FIPA_REQUEST_PROTOCOL (code en 2 instructions)
-->
-->
'''
'''#donner l'agent expediteur (acheteur) et l'agent recepteur (courtier) (code en 2 instructions)
-->
-->
'''
'''#donner à votre message une ontologie "cmdacheteur"
-->
'''
'''
Le contenu à envoyer est présenté par un objet {piece, quantité}
la fonction pickle de python permet d'englober cette objet et de l'envoyer facilement avec message.set_content
'''
pieceD = {'piece': "plaquettes", 'quantitie': 3}
obD = pickle.dumps(pieceD)
message.set_content(obD)
'''
--> acter l'envoie du message
'''
self.send(message)
def on_request(self, message: ACLMessage):
content = message.content
display_message(self.aid.name, f'I received REQUEST: {content} from {message.sender.name}')
reply = message.create_reply()
reply.set_content(str(eval(content)))
self.calculator_behaviour.send_inform(reply)
def newOrder(self):
display_message(self.aid.localname, 'Nowy cel')
message = ACLMessage(ACLMessage.INFORM)
message.add_receiver(AID('Destinatario'))
message.set_content('Ola')
self.send(message)
print("Gdzie jestescie?")
def connectionMade(self):
"""
connectionMade
--------------
Este método é executado sempre que uma conexão é realizada
com o agente AMS
"""
# armazena as informações do agente conectado por meio do metodo
# transport.getPeer()
peer = self.transport.getPeer()
# laço for percorre as mensagens armazenadas na variavel
# factory.messages e caso alguma mensagem seja para o agente
# conectado esta será enviada
for message in self.factory.messages:
if int(message[0].port) == int(peer.port):
# envia a mensagem por meio do metodo sendLine()
self.sendLine(message[1].get_message())
# remove a mesagem enviada da variavel factory.messages
self.factory.messages.remove(message)
display_message(
self.factory.aid.name,
'Mensagem enviada ao agente ' + message[0].name)
# encerra a conexão com o agente
self.transport.loseConnection()
break
def send_prosal(self):
display_message(self.aid.localname, "sending proposal")
message = ACLMessage()
message.set_performative(ACLMessage.PROPOSE)
message.set_content(json.dumps({'price': self.price}))
message.add_receiver(AID(name="agent2@localhost:8022"))
self.send(message)
def remove_agent(self, message):
#display_message(self.agent.aid.getLocalName(), f"RemoveAgenteBehaviour called: {message}")
message_content = None
try:
message_content = pickle.loads(message.content)
# display_message(self.agent.aid.getLocalName(), f"Received SUCCESS ON PICKLE: {message_content}")
except TypeError as e:
#display_message(self.aid.getLocalName(), "Received TYPE ERROR")
return
if 'action' in message_content.keys():
if message_content['action'] == GameActions.KILL:
display_message(self.agent.aid.getLocalName(),
f"Received KILL command: {message_content}")
position = message_content['position']
port = message_content['port']
game_type = message_content['game_type']
with self.agent.board.lock:
if self.agent.board.get_position(*position) == game_type:
self.agent.board.set_position(GameConstants.GRASS,
*position)
DarwInPython.remove_agent_from_loop(port)
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 handle_inform(self, message):
# carrega conteudo da mensagem recebida
self.content = json.loads(message.content)
if self.content['ref'] == 'R_04':
display_message(self.agent.aid.name, 'Mensagem INFORM recebida')
def connect(self):
self.socket = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
self.socket.connect((self.ip, self.port))
# Atualiza a posição da chave
self.get_breaker_position()
display_message(f'{self.id}@{self.ip}:{self.port}', 'Conectado')
self.run()
def handle_subscribe(self, message):
self.register(message.sender)
display_message(self.agent.aid.name, message.content)
resposta = message.create_reply()
resposta.set_performative(ACLMessage.AGREE)
resposta.set_content('Subscribe message accepted')
self.agent.send(resposta)
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 handle_request(self, message):
super(CompRequest, self).handle_request(message)
display_message(self.agent.aid.localname,
message.content) # conteúdo da msg recebida!!!
# INDICA O TRATAMENTO DE ACORDO COM A REGRA
##############
situacao = 'hiperG' # preciso pegar da mensage.content...
# instancia e chama a classe de regras!
engine = GlicemicControl()
engine.reset()
engine.declare(BloodGlucose(glicemia=situacao))
engine.run()
##############
reply = message.create_reply() # responde a quem solicitou
reply.set_performative(
ACLMessage.INFORM) # setando o rótulo da mensagem (INFORM)
reply.set_content(
"PTA -> PAA: Relatório de Avaliação Recebido!") # seta o conteúdo
self.agent.send(reply) # envia o reply
def do_long_job():
# Massive calculations part I
display_message(self.aid.name, f'Doing long job')
time.sleep(1.5)
question = f'{randint(1, 50)}+{randint(100, 150)}'
return question
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(self, message):
"""Envia uma mensagem ACL para os agentes
especificados no campo receivers da mensagem ACL
"""
message.set_sender(self.aid)
message.set_message_id()
# for percorre os destinatarios da mensagem
for receiver in message.receivers:
for name in self.agentInstance.table:
# if verifica se o nome do destinatario está entre os agentes
# disponíveis
if receiver.localname in name and receiver.localname != self.aid.localname:
# corrige o parametro porta e host gerado aleatoriamente quando apenas um nome
# e dado como identificador de um destinatário
receiver.setPort(self.agentInstance.table[name].port)
receiver.setHost(self.agentInstance.table[name].host)
# se conecta ao agente e envia a mensagem
self.agentInstance.messages.append((receiver, message))
reactor.connectTCP(self.agentInstance.table[name].host,
self.agentInstance.table[name].port,
self.agentInstance)
break
else:
if self.debug:
display_message(
self.aid.localname,
'Agente ' + receiver.name + ' não esta ativo')
else:
pass
def handle_store_messages(self, message, sender):
m = Message(sender=message.sender.localname,
date=message.datetime,
performative=message.performative,
protocol=message.protocol,
content=message.content,
conversation_id=message.conversationID,
message_id=message.messageID,
ontology=message.ontology,
language=message.language)
receivers = list()
for receiver in message.receivers:
receivers.append(receiver.localname)
m.receivers = receivers
a = AgentModel.query.filter_by(name=sender.localname).all()[0]
m.agent_id = a.id
db.session.add(m)
db.session.commit()
if self.debug:
display_message(self.aid.name, 'Message stored')
def connectionMade(self):
"""
connectionMade
--------------
Este método é executado sempre que uma conexão é realizada
com o agente AMS
"""
# armazena as informações do agente conectado por meio do metodo
# transport.getPeer()
peer = self.transport.getPeer()
# laço for percorre as mensagens armazenadas na variavel
# factory.messages e caso alguma mensagem seja para o agente
# conectado esta será enviada
for message in self.factory.messages:
if int(message[0].port) == int(peer.port):
# envia a mensagem por meio do metodo sendLine()
self.sendLine(message[1].get_message())
# remove a mesagem enviada da variavel factory.messages
self.factory.messages.remove(message)
display_message(
self.factory.aid.name,
'Mensagem enviada ao agente ' + message[0].name)
# encerra a conexão com o agente
self.transport.loseConnection()
break
def handle_reject_propose(self, message):
"""
"""
super(AuctionPropose, self).handle_reject_propose(message)
display_message(self.agent.aid.name,
'REJECT_PROPOSAL message received')
def async_propose():
self.contract_net.send_propose(reply)
# Wait for response
try:
accept_proposal = yield reply
display_message(
self.aid.name,
f'I received ACCEPT-PROPOSAL: {accept_proposal.content} from {accept_proposal.sender.name}'
)
# I'mma do some job in another thread
def job():
display_message(self.aid.name, f"I'mma do my job")
time.sleep(5)
inform_message = accept_proposal.create_reply()
inform_message.set_content(10 * int(reply.content))
# Use reactor thread to send final results
call_from_thread(
lambda: self.contract_net.send_inform(inform_message))
call_in_thread(job)
except FipaRejectProposalHandler as h:
reject_proposal = h.message
display_message(
self.aid.name,
f'I received REJECT-PROPOSAL: {reject_proposal.content} from {reject_proposal.sender.name}'
)
def send(self, message):
"""Envia uma mensagem ACL para os agentes
especificados no campo receivers da mensagem ACL
"""
message.set_sender(self.aid)
# for percorre os destinatarios da mensagem
for receiver in message.receivers:
for name in self.agentInstance.table:
# if verifica se o nome do destinatario está entre os agentes
# disponíveis
if receiver.localname in name and receiver.localname != self.aid.localname:
# corrige o parametro porta e host gerado aleatoriamente quando apenas um nome
# e dado como identificador de um destinatário
receiver.setPort(self.agentInstance.table[name].port)
receiver.setHost(self.agentInstance.table[name].host)
# se conecta ao agente e envia a mensagem
self.agentInstance.messages.append((receiver, message))
reactor.connectTCP(self.agentInstance.table[
name].host, self.agentInstance.table[name].port, self.agentInstance)
break
else:
if self.debug:
display_message(
self.aid.localname, 'Agente ' + receiver.name + ' não esta ativo')
else:
pass
def handle_reject_propose(self, message):
"""
"""
super(CompContNet2, self).handle_reject_propose(message)
display_message(self.agent.aid.name,
'Mensagem REJECT_PROPOSAL recebida')
def _send(self, message, receivers):
# "for" iterates on the message receivers
for receiver in receivers:
for name in self.agentInstance.table:
# "if" verifies if the receiver name is among the available agents
if receiver.localname in name and receiver.localname != self.aid.localname:
# corrects the port and host parameters randomly generated when only a name
# is given as a identifier of a receiver.
receiver.setPort(self.agentInstance.table[name].port)
receiver.setHost(self.agentInstance.table[name].host)
# makes a connection to the agent and sends the message.
self.agentInstance.messages.append((receiver, message))
if self.debug:
print(('[MESSAGE DELIVERY]',
message.performative,
'FROM',
message.sender.name,
'TO',
receiver.name))
try:
reactor.connectTCP(self.agentInstance.table[
name].host, self.agentInstance.table[name].port, self.agentInstance)
except:
self.agentInstance.messages.pop()
display_message(self.aid.name, 'Error delivery message!')
break
else:
if self.debug:
display_message(
self.aid.localname, 'Agent ' + receiver.name + ' is not active')
else:
pass
def _handle_cfp(self, message):
"""
"""
super(CompContNet2, self).handle_cfp(message)
self.message = message
content = json.loads(message.content)
if content['ref'] == 'CN_01':
display_message(self.agent.aid.name, 'Mensagem CFP recebida')
# self.agent.ramos_nao_energizados = pickle.loads(
# json.loads(self.message.content)['dados'])
chaves_recomp = selec_ramos_possiveis(self.agent.podas,
self.agent.alimentador)
if chaves_recomp:
# verifica a potencia disponivel nos
# transformadores da subestacao
potencia_disponivel = calcular_potencia_disponivel(self.agent.subestacao)
resposta = self.message.create_reply()
resposta.set_performative(ACLMessage.PROPOSE)
resposta.set_content(
json.dumps({'ref': 'CN_02',
'dados': {'potencia': potencia_disponivel}}
))
self.agent.send(resposta)
else:
resposta = self.message.create_reply()
resposta.set_performative(ACLMessage.REFUSE)
resposta.set_content(json.dumps({'ref': 'CN_02'}))
self.agent.send(resposta)
def handle_agree(self, message):
# carrega conteudo da mensagem recebida
self.content = json.loads(message.content)
if self.content['ref'] == 'R_06':
display_message(self.agent.aid.name, 'Mensagem AGREE recebida')
def handle_subscribe(self, message):
self.register(message.sender)
display_message(self.agent.aid.name, message.content)
resposta = message.create_reply()
resposta.set_performative(ACLMessage.AGREE)
resposta.set_content('Pedido de subscricao aceito')
self.agent.send(resposta)
def _cretateAgentsTable(self, transaction):
display_message(
self.aid.name, 'Tabela de agentes criada no banco de dados.')
self.dbid = 'agents_' + str(uuid4().time)
s = 'CREATE TABLE ' + self.dbid + '( id INTEGER PRIMARY KEY AUTOINCREMENT, ' +\
'name VARCHAR(20), ' +\
'port INTEGER);'
transaction.execute(s)
def handle_request(self, message):
super(CompRequest, self).handle_request(message)
display_message(self.agent.aid.localname, 'mensagem request recebida')
now = datetime.now()
reply = message.create_reply()
reply.set_performative(ACLMessage.INFORM)
reply.set_content(now.strftime('%d/%m/%Y - %H:%M:%S'))
self.agent.send(reply)
def clientConnectionFailed(self, connector, reason):
"""Este método é chamado quando ocorre uma
falha na conexão de um cliente com o servidor
"""
if self.debug:
display_message(self.aid.name, 'Falha na Conexão')
else:
pass
reactor.stop()
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 _handle_cfp(self, message):
"""
"""
super(CompContNet2, self).handle_cfp(message)
self.message = message
display_message(self.agent.aid.name, 'Mensagem CFP recebida')
resposta = self.message.create_reply()
resposta.set_performative(ACLMessage.PROPOSE)
resposta.set_content(str(self.agent.pot_disp))
self.agent.send(resposta)
def handle_accept_propose(self, message):
"""
"""
super(CompContNet2, self).handle_accept_propose(message)
display_message(self.agent.aid.name,
'Mensagem ACCEPT_PROPOSE recebida')
resposta = message.create_reply()
resposta.set_performative(ACLMessage.INFORM)
resposta.set_content('OK')
self.agent.send(resposta)
def connection_test_send(self):
"""Este método é executado ciclicamente com o objetivo de
verificar se os agentes estão conectados
"""
if self.debug:
display_message(self.aid.name,
'Enviando mensagens de verificação da conexão...')
for name, aid in self.table.iteritems():
if self.debug:
display_message(
self.aid.name,
'Tentando conexão com agente ' + name + '...')
reactor.connectTCP(aid.host, int(aid.port), self)
else:
reactor.callLater(1, self.connection_test_send)
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 handle_store_messages(self, message, sender):
m = Message(sender=message.sender.localname,
date=datetime.datetime.now(),
performative=message.performative,
protocol=message.protocol,
content=message.content,
conversation_id=message.conversationID,
message_id=message.messageID,
ontology=message.ontology,
language=message.language)
receivers = list()
for receiver in message.receivers:
receivers.append(receiver.localname)
m.receivers = receivers
a = Agent.query.filter_by(name=sender.localname).all()[0]
m.agent_id = a.id
db.session.add(m)
db.session.commit()
display_message(self.fact.aid.name, 'Message stored')
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 handle_inform(self, message):
display_message(self.agent.aid.localname, message.content)
def handle_propose(self, message):
"""
"""
super(CompContNet1, self).handle_propose(message)
display_message(self.agent.aid.name, 'Mensagem PROPOSE recebida')
def createAgentsTable(self):
display_message(
self.aid.name, 'Tabela de agentes criada no banco de dados.')
return self.conn.runInteraction(self._cretateAgentsTable)
def handle_cancel(self, message):
self.deregister(self, message.sender)
display_message(self.agent.aid.name, message.content)
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 handle_inform(self, message):
"""
"""
super(CompContNet1, self).handle_inform(message)
display_message(self.agent.aid.name, 'Mensagem INFORM recebida')
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)
def handle_agree(self, message):
display_message(self.agent.aid.name, message.content)
def __init__(self, aid):
super(AgenteHelloWorld, self).__init__(aid=aid, debug=True)
display_message(self.aid.localname, 'Hello World!')
def handle_refuse(self, message):
"""
"""
super(CompContNet1, self).handle_refuse(message)
display_message(self.agent.aid.name, 'Mensagem REFUSE recebida')
