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