def setup(self):
print(f"[{self.jid}] Hello World! I'm agent {self.jid}")
# Update topology - waiting for request from manager
template_msg = Template()
template_msg.sender = self.manager_jid
template_msg.set_metadata('performative', 'request')
self.add_behaviour(UpdateTopology(period=config.UPDATE_TOPOLOGY_FREQ),
template_msg)
# Handler for subscribe request
template_msg = Template()
template_msg.set_metadata('performative', 'subscribe')
self.add_behaviour(Subscribe(), template_msg)
# Reporting to manager
self.add_behaviour(
SendReportForSubscribers(period=config.SEND_REPORT_FREQ))
# Get data from sensors
self.add_behaviour(GetCars(period=config.GET_DATA_FREQ))
self.add_behaviour(GetLightsStatus(period=config.GET_DATA_FREQ))
# Control lights
#self.add_behaviour(ChangeLights(config.CHANGE_LIGHTS_FREQ))
# Answering protocol
self.add_behaviour(
CrossroadsMessanger.NegotiatingProtocolParticipant())
self.add_behaviour(CrossroadsMessanger.NegotiatingProtocolInitiator())
def __init__(self, jid, password, *, graph, workflow, factory_creator, storage_username, verify_security=False,
neighbours=None, agent_type=None, produced_components=None, is_recovered=False):
"""
Simulation agent initializer.
:param jid: agent username in XMPP server, e.g. 'agent 0'
:param password: agent password in XMPP server, e.g. 'agent 0'
:param verify_security: XMPP server parameter - whether agents should be verified or not
:param neighbours: list of agents' username (e.g. 'agent 0') being the agent neighbours (for whom the agent can
sent a message)
"""
super().__init__(jid=jid, password=password, verify_security=verify_security)
if neighbours is None:
neighbours = dict()
self.username = jid
self.neighbours = neighbours
self.successors = self.neighbours['successors']
self.predecessors = self.neighbours['predecessors']
self.propagate_behav = None
self.listen_behav = None
self.agentType = agent_type
self.factory_creator = factory_creator
self.storage_username = storage_username
self.produced_components = produced_components
self.workflow = workflow
self.graph = graph
template = Template()
template.set_metadata("performative", "inform")
self.common_template = template
self.message_thread_counter_list = []
self.sent_messages_registry = []
self.respawn_after_breakdown = is_recovered
self.was_ever_revived = is_recovered
async def setup(self):
"""Executed when the agent starts."""
logger.info("ImageAgent starting . . .")
# Ingredients names
with open((CNN_DIR / 'classes.csv'), 'r') as f:
self.CLASS_NAMES = list(csv.reader(f))[0]
# Uncomment if TensorFlow for GPU is enabled.
# gpus = tf.config.experimental.list_physical_devices('GPU')
# if gpus:
# try:
# # Currently, memory growth needs to be the same across GPUs
# for gpu in gpus:
# tf.config.experimental.set_memory_growth(gpu, True)
# logical_gpus = tf.config.experimental.list_logical_devices(
# 'GPU')
# print(len(gpus), "Physical GPUs,", len(
# logical_gpus), "Logical GPUs")
# except RuntimeError as e:
# # Memory growth must be set before GPUs have been initialized
# print(e)
b = self.ClassifyBehaviour()
t = Template()
t.set_metadata("performative", "request")
self.add_behaviour(b, t)
def run_strategy(self):
"""
Runs the strategy for the directory agent.
"""
template = Template()
template.set_metadata("protocol", QUERY_PROTOCOL)
self.add_behaviour(self.strategy(), template)
def Launch_Sight_ResponderBehaviour(self):
class CyclicBehaviourSight(Behaviour):
async def run(self):
msg = await self.receive(timeout=100000)
if msg:
s_content = msg.body
s_content = s_content.split()
FOVObjects = self.agent.GetObjectsInFieldOfView(s_content[1])
s_content = " #: " + str(len(FOVObjects)) + " "
for s in FOVObjects:
s_content += "TEAM: " + str(s.m_eTeam) + " TYPE: " + str(s.m_eType)
s_content += " ANGLE: " + str(s.m_dAngle) + " DISTANCE: " + str(s.m_dDistance) + " "
s_content += "HEALTH: " + str(s.m_iHealth)
s_content += " ( " + str(s.m_Position.x) + " , " + str(s.m_Position.y) + " , " + str(s.m_Position.z) + " ) "
reply = msg.make_reply()
reply.body = s_content
reply.set_metadata("performative", "sight")
await self.send(reply)
template = Template()
template.set_metadata("performative", "sight")
self.add_behaviour(CyclicBehaviourSight(), template)
def _get_backups(agent, term, intention):
"""Request for backup agents. This action sends a FIPA REQUEST
message to the service agent asking for those who offer the
Backup service.
"""
class GetBackupBehaviour(OneShotBehaviour):
async def run(self):
msg = Message()
msg.set_metadata(PERFORMATIVE, PERFORMATIVE_GET)
msg.to = self.agent.service_jid
msg.body = json.dumps({NAME: BACKUP_SERVICE, TEAM: self.agent.team})
await self.send(msg)
result = await self.receive(timeout=LONG_RECEIVE_WAIT)
if result:
result = json.loads(result.body)
self.agent.soldiers_count = len(result)
logger.info("{} got {} fieldops: {}".format(self.agent.name, self.agent.soldiers_count, result))
self.agent.bdi.set_belief(MY_BACKUPS, tuple(result))
else:
self.agent.bdi.set_belief(MY_BACKUPS, tuple())
self.agent.soldiers_count = 0
t = Template()
t.set_metadata(PERFORMATIVE, PERFORMATIVE_CFB)
b = GetBackupBehaviour()
self.add_behaviour(b, t)
yield
async def setup(self):
# print("<Chord> {}".format(str(self.jid).split("@")[0]))
self.set("inversion", None)
inversion_template = Template()
inversion_template.set_metadata("performative", "inversion")
self.add_behaviour(self.receiveInversion(), inversion_template)
self.add_behaviour(self.sendChord())
async def setup(self):
util.mas_print_info("[MISSILE] ({}) starting...".format(self.aid))
b = RecvBehav(self.aid)
template = Template()
template.set_metadata("performative", "inform")
self.add_behaviour(b, template)
def _get_service(agent, term, intention):
"""Request for troop agents that offer the service specified by
<service>. This action sends a FIPA REQUEST
message to the service agent asking for those who offer the
<service> service.
:param service: service requested
:type service: str
"""
args = asp.grounded(term.args, intention.scope)
service = str(args[0])
class GetServiceBehaviour(OneShotBehaviour):
async def run(self):
msg = Message()
msg.set_metadata(PERFORMATIVE, PERFORMATIVE_GET)
msg.to = self.agent.service_jid
msg.body = json.dumps({NAME: service, TEAM: self.agent.team})
await self.send(msg)
result = await self.receive(timeout=LONG_RECEIVE_WAIT)
if result:
result = json.loads(result.body)
logger.info("{} got {} troops that offer {} service: {}".format(self.agent.name, len(result), service, result))
self.agent.bdi.set_belief(service, tuple(result))
else:
self.agent.bdi.set_belief(service, tuple())
t = Template()
t.set_metadata(PERFORMATIVE, service)
b = GetServiceBehaviour()
self.add_behaviour(b, t)
yield
def Launch_DataFromTroop_ListenerBehaviour(self):
class CyclicBehaviourDFT(Behaviour):
async def run(self):
msg = await self.receive(timeout=100000)
if msg:
s_content = msg.body
s_content = s_content.split()
id_agent = int(s_content[1])
self.agent.m_AgentList[id_agent].m_Locate.m_Position.x = float(s_content[3])
self.agent.m_AgentList[id_agent].m_Locate.m_Position.y = float(s_content[5])
self.agent.m_AgentList[id_agent].m_Locate.m_Position.z = float(s_content[7])
self.agent.m_AgentList[id_agent].m_Locate.m_Velocity.x = float(s_content[10])
self.agent.m_AgentList[id_agent].m_Locate.m_Velocity.y = float(s_content[12])
self.agent.m_AgentList[id_agent].m_Locate.m_Velocity.z = float(s_content[14])
self.agent.m_AgentList[id_agent].m_Locate.m_Heading.x = float(s_content[17])
self.agent.m_AgentList[id_agent].m_Locate.m_Heading.y = float(s_content[19])
self.agent.m_AgentList[id_agent].m_Locate.m_Heading.z = float(s_content[21])
self.agent.m_AgentList[id_agent].m_iHealth = int(s_content[24])
self.agent.m_AgentList[id_agent].m_iAmmo = int(s_content[26])
self.agent.CheckObjectsAtStep(id_agent)
if self.agent.CheckGameFinished(id_agent):
self.agent.InformGameFinished("ALLIED", self)
print("\n\nManager: GAME FINISHED!! Winner Team: ALLIED! (Target Returned)\n")
template = Template()
template.set_metadata("performative", "data")
self.add_behaviour(CyclicBehaviourDFT(), template)
def setup(self):
print("Receiver agent started")
self.add_behaviour(self.Behav1())
b = self.ReceiveBehaviour()
template = Template()
template.set_metadata("performative", "cfp")
self.add_behaviour(b, template)
async def setup(self):
print("Player started")
b = self.WaitTurn()
template = Template()
template.set_metadata("ludoMETA", "getIndex")
self.add_behaviour(b, template)
async def setup(self):
print("DQNAgent started")
start_at = datetime.datetime.now() + datetime.timedelta(seconds=5)
b = self.DQNBehav(period=2, start_at=start_at, config=self.config)
template = Template()
template.set_metadata("performative", "inform")
self.add_behaviour(b)
async def setup(self):
containers_deallocation_mt = Template()
containers_deallocation_mt.set_metadata('protocol', 'Request')
containers_deallocation_mt.set_metadata(
'action', ContainersDeallocationRequest.__key__)
self.add_behaviour(ContainersDeallocationResponder(),
containers_deallocation_mt)
async def setup(self):
self.total_busy_time = 0.0
logger.info("Station agent {} running".format(self.name))
self.set_type("station")
self.set_status()
try:
template = Template()
template.set_metadata("protocol", REGISTER_PROTOCOL)
register_behaviour = RegistrationBehaviour()
self.add_behaviour(register_behaviour, template)
while not self.has_behaviour(register_behaviour):
logger.warning(
"Station {} could not create RegisterBehaviour. Retrying..."
.format(self.agent_id))
self.add_behaviour(register_behaviour, template)
except Exception as e:
logger.error(
"EXCEPTION creating RegisterBehaviour in Station {}: {}".
format(self.agent_id, e))
try:
template = Template()
template.set_metadata("protocol", TRAVEL_PROTOCOL)
travel_behaviour = TravelBehaviour()
self.add_behaviour(travel_behaviour, template)
while not self.has_behaviour(travel_behaviour):
logger.warning(
"Customer {} could not create TravelBehaviour. Retrying..."
.format(self.agent_id))
self.add_behaviour(travel_behaviour, template)
except Exception as e:
logger.error(
"EXCEPTION creating TravelBehaviour in Station {}: {}".format(
self.agent_id, e))
self.ready = True
async def setup(self):
log.info(f"[{self.name}] Avatar running")
self.add_behaviour(self.PresenceSetup())
message_template = Template()
message_template.set_metadata('action', 'send_message')
self.add_behaviour(ReceiveMessage(), message_template)
self.add_behaviour(self.Chat())
async def _reallocate_container(self, container_jid: str):
reallocate_behaviour = ReallocationInitiator(container_jid)
reallocation_mt = Template()
reallocation_mt.set_metadata('protocol', 'Request')
reallocation_mt.set_metadata('action', ReallocationRequest.__key__)
self.agent.add_behaviour(reallocate_behaviour, reallocation_mt)
await reallocate_behaviour.join()
def get_template(agent: AgentType):
temp = Template()
to = agent.value
if to in users:
to = users[to]
temp.to = get_xmpp_username(to['username'])
temp.set_metadata("stream", agent.value)
return temp
async def setup(self):
util.mas_print_info("[HQ] {} starting...".format(self.aid))
b = RecvBehav(self.locations)
template = Template()
template.set_metadata("performative", "inform")
self.add_behaviour(b, template)
self.presence.set_available(show=aioxmpp.PresenceShow.CHAT)
async def setup(self):
if runtime_switches.log_level >= 0:
print("Thermometer setup")
template = Template()
template.set_metadata('performative', 'request')
template.set_metadata('type', 'outdoor_temperature_request')
b = self.SendTemperature()
self.add_behaviour(b)
async def setup(self):
self.classifierJID = list()
self.clusteringJID = list()
newConnection = Template()
newConnection.set_metadata("performative", "new_connection")
askTemplate = Template()
askTemplate.set_metadata("performative", "ask")
self.add_behaviour(self.NewConnection(), newConnection)
self.add_behaviour(self.RespondBehaviour(), askTemplate)
def run_strategy(self):
"""
Runs the strategy for the transport agent.
"""
if not self.running_strategy:
template = Template()
template.set_metadata("protocol", REQUEST_PROTOCOL)
self.add_behaviour(self.strategy(), template)
self.running_strategy = True
async def setup(self):
print(Fore.CYAN+Style.BRIGHT+f"[{self.jid}]",
Style.NORMAL+" AGENTE REGLAS STARTED"+Fore.RESET+Style.RESET_ALL)
b = self.ReglasBehaviour()
# Creamos una template con la que solo podremos recibir mensaje de con performativa inform
template = Template()
template.set_metadata("performative", "inform")
# Añadimos comportamiento
self.add_behaviour(b, template)
async def setup(self):
webAppAPI.log(f"Registered agent: {agentData}")
print(f"Registered agent: {agentData}")
checkFromDeviceTemplate = Template()
checkFromDeviceTemplate.set_metadata("performative", "verification")
checkFromDeviceTemplate.set_metadata("ontology", "device")
self.add_behaviour(self.MessageListeningBehaviour(),
template=checkFromDeviceTemplate)
self.add_behaviour(self.LogValuesToLocalDatabaseBehaviour())
def launch_pack_management_responder_behaviour(self):
class PackManagementResponderBehaviour(CyclicBehaviour):
async def run(self):
msg = await self.receive(LONG_RECEIVE_WAIT)
if msg:
content = json.loads(msg.body)
id_ = content[NAME]
action = content[ACTION]
if action == DESTROY:
self.agent.game_statistic.pack_destroyed(
self.agent.din_objects[id_])
try:
del self.agent.din_objects[id_]
logger.info("Pack removed")
except KeyError:
logger.info("Pack {} cannot be erased".format(id_))
return
if action == CREATE:
type_ = int(content[TYPE])
team = int(content[TEAM])
x = float(content[X])
y = float(content[Y])
z = float(content[Z])
din_object = DinObject()
din_object.jid = msg.sender
din_object.type = type_
if din_object.type == PACK_OBJPACK:
din_object.render_id = 1
else:
din_object.render_id = abs(hash(
din_object.jid)) % 1024
din_object.team = team
din_object.position.x = x
din_object.position.y = y
din_object.position.z = z
self.agent.din_objects[din_object.jid] = din_object
logger.info("Added DinObject {}".format(din_object))
self.agent.game_statistic.pack_created(
din_object, team)
else:
logger.warning(
"Action not identified: {}".format(action))
return
template = Template()
template.set_metadata(PERFORMATIVE, PERFORMATIVE_PACK)
self.add_behaviour(PackManagementResponderBehaviour(), template)
async def setup(self):
self.type = PACK_OBJPACK
self.origin.x = self.position.x
self.origin.y = self.position.y
self.origin.z = self.position.z
t = Template()
t.set_metadata(PERFORMATIVE, PERFORMATIVE_PACK_LOST)
self.add_behaviour(self.PackLostResponderBehaviour(), t)
await super().setup()
def prepare_heartbeat(self):
if self.successors:
self.add_behaviour(Heartbeat(self.successors))
predecessors_wo_storage = {v for v in self.predecessors if v != self.storage_username}
if predecessors_wo_storage:
template = Template()
template.set_metadata("performative", Heartbeat.performative)
heartbeat_verificator = HeartbeatVerificator(predecessors_wo_storage, agent_factory=self.factory_creator, owning_agent=self.name)
self.add_behaviour(heartbeat_verificator, template)
async def setup(self):
fsm = DeviceBehaviour()
fsm.add_state(name=S_RECEIVING, state=StateOne(), initial=True)
fsm.add_state(name=S_SENDING, state=StateTwo())
fsm.add_transition(source=S_RECEIVING, dest=S_SENDING)
fsm.add_transition(source=S_RECEIVING, dest=S_RECEIVING)
fsm.add_transition(source=S_SENDING, dest=S_RECEIVING)
sndTemplate = Template()
sndTemplate.set_metadata("msg", "snd")
self.add_behaviour(fsm, sndTemplate)
def add_strategy(self, strategy_class):
"""
Sets the strategy for the taxi agent.
Args:
strategy_class (``TaxiStrategyBehaviour``): The class to be used. Must inherit from ``TaxiStrategyBehaviour``
"""
template = Template()
template.set_metadata("protocol", REQUEST_PROTOCOL)
self.add_behaviour(strategy_class(), template)
def setup(self):
tmp = Template()
tmp.set_metadata("stream", "ta_result")
ba = DecisionAgentBehaviour()
self.add_behaviour(ba, template=tmp)
tmp = Template()
tmp.set_metadata("stream", "high_alert_result")
ba = HighAlertNewsRecBehaviour()
self.add_behaviour(ba, template=tmp)
def test_multiple_templates():
class Template1Behaviour(OneShotBehaviour):
async def run(self):
self.agent.msg1 = await self.receive(timeout=2)
class Template2Behaviour(OneShotBehaviour):
async def run(self):
self.agent.msg2 = await self.receive(timeout=2)
class Template3Behaviour(OneShotBehaviour):
async def run(self):
self.agent.msg3 = await self.receive(timeout=2)
self.kill()
agent = make_connected_agent()
template1 = Template()
template1.set_metadata("performative", "template1")
agent.add_behaviour(Template1Behaviour(), template1)
template2 = Template()
template2.set_metadata("performative", "template2")
agent.add_behaviour(Template2Behaviour(), template2)
template3 = Template()
template3.set_metadata("performative", "template3")
behaviour = Template3Behaviour()
agent.add_behaviour(behaviour, template3)
msg1 = Message(metadata={"performative": "template1"}).prepare()
msg2 = Message(metadata={"performative": "template2"}).prepare()
msg3 = Message(metadata={"performative": "template3"}).prepare()
future = agent.start(auto_register=False)
future.result()
agent._message_received(msg1)
agent._message_received(msg2)
agent._message_received(msg3)
behaviour.join()
assert agent.msg1.get_metadata("performative") == "template1"
assert agent.msg2.get_metadata("performative") == "template2"
assert agent.msg3.get_metadata("performative") == "template3"
agent.stop()
async def setup(self):
print("ReceiverAgent started")
b = self.RecvBehav()
template = Template()
template.set_metadata("performative", "inform")
self.add_behaviour(b, template)