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 send_document():
# Sai do hold e envia documento
self.in_hold = False
# Cria pacote de mensagem e envia ao ADC
message = ACLMessage()
message.set_ontology(out.__name__)
message.set_content(to_elementtree(self.document_to_send))
self.behaviours_enviodedados.send_inform(message)
def action(self):
message = ACLMessage(ACLMessage.REQUEST)
message.add_receiver(AID('supermarket'))
message.set_ontology(
self.agent.session) # Defines the tipe of list required
message.set_content('Please, give me this list')
self.agent.send(message)
display(self.agent,
'I requested for %s products.' % self.agent.session)
def request_external_restoration(self, poda):
"""Requests external restoration to AN"""
display_message(self.aid.name, 'Sending request to AN')
poda_cim = rdf2mygrid.poda_cim(poda=poda)
# poda_cim = pickle.dumps(poda)
message = ACLMessage()
message.set_ontology("R_05")
message.set_content(poda_cim)
message.add_receiver(self.get_an())
while True:
try:
response_an = yield from self.req_restoration.send_request(
message)
display_message(self.aid.name,
f'Restauração externa efetivada')
except FipaFailureHandler as h:
response_an = h.message
display_message(
self.aid.name,
f'Restauração externa falhou: {response_an.content}')
except FipaAgreeHandler:
display_message(self.aid.name, f'Agree recebido')
except FipaProtocolComplete:
break
if response_an.ontology == swc.__name__:
display_message(
self.aid.name,
f'Comando de chaves para concluir restauração internamente')
response_acom = yield from self.send_switch_command(
content=response_an.content, purpose=swc.Purpose.RESTORATION)
display_message(
self.aid.name,
f'Restauração externa concluída com fechamento de chaves internas'
)
def solicitar_propostas(self, poda):
"""Define função que será chamada após cada resposta"""
poda_cim = rdf2mygrid.poda_cim(poda)
# poda_cim = pickle.dumps(poda)
# Elabora mensagem
message = ACLMessage(ACLMessage.CFP)
message.set_protocol(ACLMessage.FIPA_CONTRACT_NET_PROTOCOL)
message.set_ontology("CN_01")
message.set_content(poda_cim)
for aid in self.adc_vizinhos:
message.add_receiver(aid)
propostas_realizaveis = []
while True:
try:
proposta = yield from self.manage_negotiation_behaviour.send_cfp(
message)
display_message(
self.aid.name,
f"Mensagem PROPOSE recebida de {proposta.sender.name}")
content = json.loads(proposta.content)
proposta_realizavel = (content["setores"] != [])
if proposta_realizavel:
# Salva proposta para mais tarde
propostas_realizaveis.append(proposta)
else:
# Rejeita proposta imediatamente
name = message.sender.localname
ramo = proposta.content
display_message(
self.aid.name,
f"Agente {name} possui chave de encontro, mas nao pode colaborar para o ramo {ramo}."
)
reject_message = proposta.create_reply()
reject_message.set_ontology("CN_05")
reject_message.set_content('Proposta não realizável')
self.manage_negotiation_behaviour.send_reject_proposal(
reject_message)
except FipaRefuseHandler as h:
refusal = h.message
display_message(
self.aid.name,
f"Mensagem REFUSE recebida de {refusal.sender.name}")
except FipaCfpComplete:
break
# Dados da melhor proposta
melhor_proposta = None
setores_atendidos = 0
# Escolha do melhor propositor sob algum criterio
if self.criterios["carreg_SE"] and self.criterios["carga_prior"]:
pass
elif self.criterios["carreg_SE"] and self.criterios["perdas"]:
pass
elif self.criterios["carreg_SE"] and self.criterios["chaveamentos"]:
pass
# Apenas carregamento da SE e qtd de setores atendidos
else:
# Varre todas as propostas recebidas
for message in propostas_realizaveis:
display_message(
self.aid.name,
f"Analisando proposta {propostas_realizaveis.index(message) + 1} de {len(propostas_realizaveis)}"
)
# Carrega conteudo da mensagem analisada
content = json.loads(message.content)
name = message.sender.name
display_message(
self.aid.name,
f"Agente {name} pode restaurar ramo {content['setores']} com carregamento de {content['carreg_SE']}% da sua SE"
)
# Verifica se atual proposta atende maior numero de setores
if len(content["setores"]) > setores_atendidos:
melhor_proposta = message
setores_atendidos = len(content["setores"])
# Se atende o mesmo numero de setores, verifica carregamento
elif len(content["setores"]) == setores_atendidos:
content_melhor_atual = json.loads(message.content)
# Se carregamento atual for maior, vira melhor proposta
if content["carreg_SE"] > content_melhor_atual["carreg_SE"]:
melhor_proposta = message
setores_atendidos = len(content["setores"])
# Envia Reject-Proposal para demais agentes
for message in propostas_realizaveis:
if message is melhor_proposta:
continue
resposta = message.create_reply()
resposta.set_ontology("CN_04")
self.manage_negotiation_behaviour.send_reject_proposal(resposta)
# Envia Accept-Proposal para Agente Ganhador
if melhor_proposta is not None:
resposta = melhor_proposta.create_reply()
resposta.set_ontology("CN_04")
resposta.set_content(melhor_proposta.content)
while True:
try:
result = yield from self.manage_negotiation_behaviour.send_accept_proposal(
resposta)
display_message(self.aid.name, "Mensagem INFORM Recebida")
except FipaFailureHandler as h:
result = h.message
display_message(self.aid.name, "Mensagem FAILURE Recebida")
except FipaProtocolComplete:
break
return result
else:
display_message(self.aid.name, "Nenhuma proposta foi acatada.")
return None
