コード例 #1
0
    def log_situation(self, step):
        self._consistent = False
        agents = self.get_agents(addr=False)
        self._consistent = False

        for agent in agents:
            aiomas.run(until=agent.log_situation())
コード例 #2
0
ファイル: cluster.py プロジェクト: afcarl/system_designer
 def shutdown(self):
     """shutdown the cluster"""
     tasks = [
         asyncio.ensure_future(manager.stop()) for manager in self._managers
     ]
     aiomas.run(asyncio.gather(*tasks))
     self._container.shutdown()
コード例 #3
0
    def vote_and_save_info(self, age):
        # self.age = age
        # self._candidates = aiomas.run(until=self.gather_candidates())
        # self.suggested_cand.append(len(self.candidates))
        # self.validate_candidates()
        # self.valid_cand.append(len(self.candidates))
        # artifacts = self.perform_voting(method=self.voting_method)
        # threshold = 0.0
        #
        # for a, v in artifacts:
        #     accepted = True if v >= threshold else False
        #     a.accepted = accepted
        #     self.add_artifact(a)
        #     tasks = []
        #     for addr in self._manager_addrs:
        #         tasks.append(asyncio.ensure_future(self._add_domain_artifact(addr, a)))
        #     aiomas.run(until=asyncio.gather(*tasks))
        #
        # self.clear_candidates()
        # self.valid_candidates = []

        super().vote_and_save_info(age)

        agents = self.get_agents(addr=False)
        self._consistent = False
        for agent in agents:
            aiomas.run(until=agent.process_rewards())
コード例 #4
0
def main(addr, start_date, log_level):
    logging.basicConfig(level=getattr(logging, log_level.upper()))
    try:
        container_kwargs = util.get_container_kwargs(start_date)
        aiomas.run(aiomas.subproc.start(addr, **container_kwargs))
    finally:
        asyncio.get_event_loop().close()
コード例 #5
0
ファイル: cli.py プロジェクト: frnsys/brood
def start_node(port):
    """start a node"""
    task = Node.start(('0.0.0.0', port),
                      codec=aiomas.codecs.MsgPackBlosc,
                      extra_serializers=[serializers.get_np_serializer])

    # terminates when the node's manager is given the 'stop' command
    aiomas.run(until=task)
コード例 #6
0
    def set_agent_acquaintances(self):
        agents = self.get_agents(addr=False)
        self._consistent = False

        addresses = self.get_agents(addr=True)
        self._consistent = False

        for agent in agents:
            aiomas.run(until=agent.set_acquaintances(addresses))
コード例 #7
0
def main(addr, log_level):
    """Run the multi-agent system."""
    logging.basicConfig(level=getattr(logging, log_level.upper()))
    try:
        # Run the "run()" coroutine which starts the RPC server for mosaik:
        aiomas.run(until=run(addr, log_level))
    finally:
        # Make sure the event loop is closed so that everything is properly
        # cleaned up and we don't get nasty log messages at the end:
        asyncio.get_event_loop().close()
コード例 #8
0
def main(addr, log_level, log_file):
    """Open VPP multi-agent system."""
    try:
        # change event loop in case the platform is windows
        if sys.platform == 'win64' or sys.platform == 'win32':
            loop = asyncio.ProactorEventLoop()
            asyncio.set_event_loop(loop)
        initialize_logger(log_level, log_file)
        aiomas.run(until=run(addr, log_level, log_file))
    finally:
        asyncio.get_event_loop().close()
コード例 #9
0
    def test_behaviors_called(self):
        class NewAgent(syd.Agent):
            state_vars = ['cash']
            behaviors = [behavior]

        agent = NewAgent(self.node, {'cash': 100})
        self.assertEquals(agent.state.cash, 100)

        aiomas.run(agent.decide())
        agent.apply_updates()
        self.assertEquals(agent.state.cash, 10)
コード例 #10
0
ファイル: test_agent.py プロジェクト: frnsys/brood
    def test_behaviors_with_param_called(self):
        class NewAgent(syd.Agent):
            state_vars = ['cash']
            behaviors = [partial(behavior_with_params, param=2)]

        agent = NewAgent(self.node, {'cash': 100})
        self.assertEquals(agent.state.cash, 100)

        aiomas.run(agent.decide())
        agent.apply_updates()
        self.assertEquals(agent.state.cash, 200)
コード例 #11
0
    def get_dictionary(self, func_name):
        agents = self.get_agents(addr=False)

        dict = {}

        for agent in agents:
            name = aiomas.run(until=agent.get_name())
            func = getattr(agent, func_name)
            dict[name] = aiomas.run(until=func())

        return dict
コード例 #12
0
    def test_behaviors_with_param_called(self):
        class NewAgent(syd.Agent):
            state_vars = ['cash']
            behaviors = [partial(behavior_with_params, param=2)]

        agent = NewAgent(self.node, {'cash': 100})
        self.assertEquals(agent.state.cash, 100)

        aiomas.run(agent.decide())
        agent.apply_updates()
        self.assertEquals(agent.state.cash, 200)
コード例 #13
0
ファイル: test_agent.py プロジェクト: frnsys/brood
    def test_behaviors_called(self):
        class NewAgent(syd.Agent):
            state_vars = ['cash']
            behaviors = [behavior]

        agent = NewAgent(self.node, {'cash': 100})
        self.assertEquals(agent.state.cash, 100)

        aiomas.run(agent.decide())
        agent.apply_updates()
        self.assertEquals(agent.state.cash, 10)
コード例 #14
0
 def destroy(self, folder=None):
     '''Destroy the environment and the subprocesses.
     '''
     ameans = [(0, 0, 0) for _ in range(3)]
     #ret = [self.save_info(folder, ameans)]
     aiomas.run(until=self.stop_slaves(folder))
     # Close and join the process pool nicely.
     self._pool.close()
     self._pool.terminate()
     self._pool.join()
     self._env.shutdown()
     return None
コード例 #15
0
ファイル: simulation.py プロジェクト: assamite/creamas
 def async_step(self):
     '''Progress simulation by running all agents once asynchronously.
     '''
     assert len(self._agents_to_act) == 0
     self._init_step()
     t = time.time()
     tasks = [asyncio.ensure_future(self.env.trigger_act(addr)) for
              addr in self._agents_to_act]
     aiomas.run(until=asyncio.gather(*tasks))
     self._agents_to_act = []
     self._step_processing_time = time.time() - t
     self._finalize_step()
コード例 #16
0
def runContainer():
    # Creating container contains the home agents
    # and prediction agents
    RC = aiomas.Container.create(('localhost', 5555))

    # Create the DB engine
    # db_engine = create_engine("mysql+pymysql://{}@{}/{}".format(CF.DB_USER, CF.DB_HOST, CF.DB_NAME))
    db_engine = CF.get_db_engine()

    # Initiate the blockchain agent
    blockChainAgent = BlockchainAgent(container=RC, )

    # Dump the blockchain agent address
    logger.info("Blcokchain agent initiated at {}".format(
        blockChainAgent.addr))

    # Record this agent to DB
    status = recordAgent(agent_addr=blockChainAgent.addr,
                         agent_type='blockchain',
                         db_engine=db_engine)

    # Run the event loop
    try:
        logger.info(
            "Running the event loop. The blockchain agent is open to be connected!"
        )
        aiomas.run()

    except KeyboardInterrupt:
        logging.info("Keyboard Interrupted")

    except Exception as e:
        traceback.print_exc(file=sys.stdout)
    # Shutting donw the controller and thereby cleaning
    # all agents
    try:
        logger.info("Shutting down the root container...")
        RC.shutdown()
        logger.info("Done.")

        logger.info("Killing Blockchain agent")
        status = killAgent(agent_addr=blockChainAgent.addr,
                           agent_type='blockchain',
                           db_engine=db_engine)

        if status:
            logger.info("Done.")
        else:
            logger.info("Couldnot kill the agent!")

    except Exception as e:
        logger.info("Failed to shutdown the root container")
        traceback.print_exc(file=sys.stdout)
コード例 #17
0
def main(addr, start_date, log_level, log_file):
    """

    :param addr: address
    :param start_date: start date
    :param log_level: log_level (string, possibly lower case)
    :param log_file: log file (debug messages will be stored in that file)
    :return:
    """
    initialize_logger(log_level, log_file)
    container_kwargs = util.get_container_kwargs(start_date)
    try:
        aiomas.run(aiomas.subproc.start(addr, **container_kwargs))
    finally:
        asyncio.get_event_loop().close()
コード例 #18
0
ファイル: task_master.py プロジェクト: xiamr/pbs
def main():
    logging.basicConfig(level=logging.DEBUG,
                        format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                        datefmt='%H:%M:%S')
    parser = argparse.ArgumentParser(description="Master for cluster dispatch system")
    parser.add_argument("-s", "--master_ip", type=str, default="0.0.0.0", help="Ip address of master server")
    parser.add_argument("-p", "--master_port", type=check_no_negative_integer,
                        default=PORT,help="port of master service")
    args = parser.parse_args()
    master = Master()
    logging.info("start to listen %s:%s ..." % (args.master_ip, args.master_port))
    master = aiomas.run(aiomas.rpc.start_server((args.master_ip, args.master_port), master,
                                                master.client_connected, codec = aiomas.MsgPackBlosc,
                                                extra_serializers=EXTRA_SERIALIZERS))
    aiomas.run(master.wait_closed())
コード例 #19
0
ファイル: cluster.py プロジェクト: johndpope/brood
    def states(self):
        """iterate over all agent states across the cluster"""
        tasks = [asyncio.ensure_future(manager.states())
                 for manager in self._managers]

        for states in aiomas.run(asyncio.gather(*tasks)):
            yield from states
コード例 #20
0
ファイル: simulation.py プロジェクト: assamite/creamas
    def next(self):
        '''Trigger next agent to :py:meth:`~creamas.core.CreativeAgent.act` in
        the current step.
        '''
        # all agents acted, init next step
        t = time.time()
        if len(self._agents_to_act) == 0:
            self._init_step()

        agent = self._agents_to_act.pop(0)
        aiomas.run(until=self.env.trigger_act(agent))
        t2 = time.time()
        self._step_processing_time += t2 - t

        # all agents acted, finalize current step
        if len(self._agents_to_act) == 0:
            self._finalize_step()
コード例 #21
0
ファイル: cluster.py プロジェクト: afcarl/system_designer
    def states(self):
        """iterate over all agent states across the cluster"""
        tasks = [
            asyncio.ensure_future(manager.states())
            for manager in self._managers
        ]

        for states in aiomas.run(asyncio.gather(*tasks)):
            yield from states
コード例 #22
0
ファイル: conftest.py プロジェクト: zypher22/isaac
def ctrl_obs(containers):
    # ctrl = controller.ControllerAgent(containers[0])
    ctrl_kwargs = {}
    obs_kwargs = {}
    ctrl, obs  =  aiomas.run(controller.ControllerAgent.factory(
        containers[0], ctrl_kwargs, observer.ObserverAgent, obs_kwargs))
    # obs = observer.ObserverAgent(containers[0], ctrl.addr)
    yield (ctrl, obs)
    ctrl.stop()
    obs.stop()
コード例 #23
0
    def get_comparison_count(self):
        agents = self.get_agents(addr=False)
        self._consistent = False

        total_comparisons = 0

        for agent in agents:
            total_comparisons += aiomas.run(until=agent.get_comparison_count())

        return total_comparisons
コード例 #24
0
    def get_total_reward(self):
        agents = self.get_agents(addr=False)
        self._consistent = False

        total_reward = 0

        for agent in agents:
            total_reward += aiomas.run(until=agent.get_total_reward())

        return total_reward
コード例 #25
0
ファイル: cluster.py プロジェクト: johndpope/brood
 def __init__(self, port, hosts, distributor=RoundRobin, venv=None):
     """create a new cluster listening on `port`, managing `hosts`"""
     self.hosts = sum((self._start_node(host, user, start_port, venv)
                      for host, user, start_port in hosts), [])
     self._container = aiomas.Container.create(('localhost', port),
                                               codec=aiomas.codecs.MsgPackBlosc,
                                               extra_serializers=[get_np_serializer])
     self._container.has_manager = True
     self._managers = aiomas.run(self._connect_to_managers(self.hosts))
     self._distributor = distributor(self._managers)
コード例 #26
0
ファイル: cluster.py プロジェクト: afcarl/system_designer
 def __init__(self, port, hosts, distributor=RoundRobin, venv=None):
     """create a new cluster listening on `port`, managing `hosts`"""
     self.hosts = sum((self._start_node(host, user, start_port, venv)
                       for host, user, start_port in hosts), [])
     self._container = aiomas.Container.create(
         ('localhost', port),
         codec=aiomas.codecs.MsgPackBlosc,
         extra_serializers=[get_np_serializer])
     self._container.has_manager = True
     self._managers = aiomas.run(self._connect_to_managers(self.hosts))
     self._distributor = distributor(self._managers)
コード例 #27
0
ファイル: conftest.py プロジェクト: zypher22/isaac
def ua(containers, ctrl_mock, obs_mock, event_loop):
    ua = aiomas.run(unit.UnitAgent.factory(
        containers[0],
        ctrl_agent_addr=ctrl_mock.addr,
        obs_agent_addr=obs_mock.addr,
        unit_model=(__name__ + ':UnitModelMock', {}),
        unit_if=(__name__ + ':UnitIfMock', {}),
        planner=(__name__ + ':PlannerMock', {}),
        sleep_before_connect=False))
    yield ua
    ua.stop()
コード例 #28
0
def main():
    logging.basicConfig(level=logging.DEBUG,
                        format='%(asctime)s %(filename)s[line:%(lineno)d] %(levelname)s %(message)s',
                        datefmt='%H:%M:%S')
  #  logging.getLogger().addHandler(logging.handlers.SysLogHandler())
    parser = argparse.ArgumentParser(description="Slave for cluster dispatch system")
    parser.add_argument("-s","--master_ip", type=str,required=True,help="Ip address of master server")
    parser.add_argument("-p","--master_port",type=check_no_negative_integer,help="port of master service")
    parser.add_argument("-n","--name", type=str, default=platform.node(), help="slave name")
    parser.add_argument("-t","--total", type=check_no_negative_integer,
                        default=multiprocessing.cpu_count(),help="total cpu cores of this node")
    parser.add_argument("-q","--queue_name",type=str, default="main", help="Queue name")
    args = parser.parse_args()
    slave = Slave()
    slave.master_ip = args.master_ip
    slave.master_port = args.master_port
    slave.name = args.name
    slave.total_cores = args.total
    slave.queue_name = args.queue_name
    asyncio.ensure_future(slave.run())
    aiomas.run()
コード例 #29
0
    def vote_and_save_info(self, age):
        self.age = age
        self._candidates = aiomas.run(until=self.gather_candidates())
        self.suggested_cand.append(len(self.candidates))
        self.validate_candidates()
        self.valid_cand.append(len(self.candidates))
        artifacts = self.perform_voting(method=self.voting_method)
        threshold = 0.0

        for a, v in artifacts:
            accepted = True if v >= threshold else False
            a.accepted = accepted
            self.add_artifact(a)
            tasks = []
            for addr in self._manager_addrs:
                tasks.append(
                    asyncio.ensure_future(self._add_domain_artifact(addr, a)))
            aiomas.run(until=asyncio.gather(*tasks))

        self.clear_candidates()
        self.valid_candidates = []
コード例 #30
0
    def irun(self, steps, reports=None):
        """run the simulation lazily (as an iterator)"""
        # reports = {name: (fn, mod step)}
        aggs = defaultdict(dict)
        reports = reports or {}
        for name, (fn, mod_step) in reports.items():
            aggs[mod_step][name] = fn

        aiomas.run(self.container.setup_agents())

        for i in range(steps):
            aiomas.run(self._step())

            # TODO any way to make this more efficient?
            report = {}
            states = None
            for mod_step, agg_fns in aggs.items():
                if i % mod_step == 0:
                    for name, fn in agg_fns.items():
                        if states is None:
                            states = self.container.states()
                        report[name] = fn(states)
            yield report
コード例 #31
0
def main(session_id, agent_id, port):
	"""

	"""
	# DB engine
	db_engine = CF.get_db_engine()

	agent_addr = getAgentAddress(agent_id=int(agent_id), session_id=session_id, db_engine=db_engine)
	
	if agent_addr is None:
		logging.info("Agent address couldn't be retreived. Make sure to provide correct session ID.")
		return

	logging.info("Agent's address: {}".format(agent_addr))

	try:
		# Create the container the host trigger agent
		c = aiomas.Container.create(('localhost', int(port)))

		# Host the trigger agent
		trigger_agent = TriggerAgent(container=c)
		
		# Kick the home agent by trigger agent
		aiomas.run(until=trigger_agent.run(agent_addr))	
	except OSError:
		logger.info("Probably the provided port is already in use or the home agent is dead!")
		return
	except ConnectionResetError:
		logger.info("Probably the home agent died.")

	except Exception as e:
		logger.info("Failed to open/create container or run the triggering agent!")
		traceback.print_exc(file=sys.stdout)

	# Shutting down the container
	logger.info("Shutting down the triggering agents container.")	
	c.shutdown()
コード例 #32
0
    def _validate_candidates(self):
        '''Validate current candidates in the environment by pruning candidates
        that are not validated at least by one agent, i.e. they are vetoed.

        In larger societies this method might be costly, as it calls each
        spiro' ``validate_candidates``-method.
        '''

        valid_candidates = set(self.candidates)
        tasks = []
        for a in self._manager_addrs:
            tasks.append(self._validate_candidates(a))
        ret = aiomas.run(until=asyncio.gather(*tasks))

        for r in ret:
            result = aiomas.run(until=r)
            vc = set(result)
            valid_candidates = valid_candidates.intersection(vc)

        self._candidates = list(valid_candidates)
        self._log(
            logging.INFO,
            "{} valid candidates after get_agents used veto.".format(
                len(self.candidates)))
コード例 #33
0
 def spawn_creator(desired_novelty):
     ret = aiomas.run(
         until=menv.spawn('agents.maze.creator_agent:CreatorAgent',
                          log_folder=log_folder,
                          memsize=normal_memsize,
                          critic_threshold=critic_threshold,
                          veto_threshold=veto_threshold,
                          log_level=logging.DEBUG,
                          maze_shape=maze_shape,
                          search_width=normal_search_width,
                          ask_criticism=ask_criticism,
                          ask_random=ask_random,
                          choose_funcs=choose_funcs,
                          desired_novelty=desired_novelty,
                          hedonic_std=hedonic_std))
     print(ret)
コード例 #34
0
 def spawn_gatekeeper(desired_novelty):
     ret = aiomas.run(until=menv.spawn(
         'agents.maze.gatekeeper_agent:GatekeeperAgent',
         log_folder=log_folder,
         memsize=gatekeeper_memsize,
         critic_threshold=critic_threshold,
         veto_threshold=veto_threshold,
         log_level=logging.DEBUG,
         maze_shape=maze_shape,
         ask_criticism=ask_criticism,
         ask_random=ask_random,
         desired_novelty=desired_novelty,
         hedonic_std=hedonic_std))
     menv.gatekeepers.append(ret[0])
     gatekeeper_agents.append(run(ret[0].get_addr()))
     print(ret)
コード例 #35
0
ファイル: cluster.py プロジェクト: johndpope/brood
 def spawn(self, agent_cls, *args, **kwargs):
     """spawn an agent on the cluster"""
     manager = self._distributor.next(self._managers)
     qual_name = '{}:{}'.format(agent_cls.__module__, agent_cls.__name__)
     return aiomas.run(manager.spawn(qual_name, *args, **kwargs))
コード例 #36
0
ファイル: test_node.py プロジェクト: frnsys/brood
 def test_local_proxy(self):
     agent = self.agents[0]
     res = aiomas.run(agent.what())
     self.assertTrue(isinstance(agent, LocalProxy))
     self.assertEquals(res, agent.obj.what())
コード例 #37
0
ファイル: test_node.py プロジェクト: frnsys/brood
 def test_agent_update(self, mock_method):
     aiomas.run(self.node.update_agents())
     self.assertEquals(mock_method.call_count, 2)
コード例 #38
0
ファイル: test_node.py プロジェクト: frnsys/brood
 def test_bulk_get(self):
     results = aiomas.run(self.node.bulk_get([a.addr for a in self.agents], 'sup'))
     self.assertEqual(results, [10, 20])
コード例 #39
0
ファイル: test_node.py プロジェクト: frnsys/brood
 def test_gets_local_agent(self):
     addr = self.agents[0].addr
     agent_proxy = aiomas.run(self.node.connect(addr))
     self.assertTrue(isinstance(agent_proxy, LocalProxy))
コード例 #40
0
ファイル: test_simulation.py プロジェクト: johndpope/brood
 def test_run(self):
     n_steps = 4
     self.sim.run(n_steps)
     for agent in self.agents:
         count = aiomas.run(agent.counter())
         self.assertEquals(count, n_steps)
コード例 #41
0
        ret = run(menv.wait_slaves(30))
        ret = run(menv.set_host_managers())
        ret = run(menv.is_ready())

        # Create the agents

        critic_agents = []

        print('Critics:')
        for _ in range(num_of_critic_agents):
            ret = aiomas.run(
                until=menv.spawn('agents.maze.maze_agent:MazeAgent',
                                 log_folder=log_folder,
                                 memsize=critic_memsize,
                                 critic_threshold=critic_threshold,
                                 veto_threshold=veto_threshold,
                                 log_level=logging.DEBUG,
                                 choose_func=cell_choosing_func,
                                 maze_shape=maze_shape,
                                 search_width=critic_search_width,
                                 ask_criticism=ask_criticism,
                                 ask_random=ask_random))
            print(ret)
            critic_agents.append(run(ret[0].get_name(), loop))

        print('Normies:')
        for _ in range(num_of_normal_agents):
            ret = aiomas.run(
                until=menv.spawn('agents.maze.maze_agent:MazeAgent',
                                 log_folder=log_folder,
                                 memsize=normal_memsize,
                                 critic_threshold=critic_threshold,
コード例 #42
0
    loop = asyncio.get_event_loop()
    ret = loop.run_until_complete(env.set_host_managers())
    ret = loop.run_until_complete(env.wait_slaves(30))
    ret = loop.run_until_complete(env.is_ready())

    # art = SprAgent(env, ((120, 120))).create(50, 100)
    # scipy.misc.imsave('test.jpg', art)
    # art2 = SprAgent(env, ((120, 120))).create(50, -100)
    # scipy.misc.imsave('test2.jpg', art2)

    rand = False

    print(aiomas.run(until=env.spawn('spiro.spr_agent:SprAgent',
                                     states=((25, 25), (85, 85)),
                                     rand=rand,
                                     desired_novelty=0.001,
                                     log_folder=log_folder)))

    print(aiomas.run(until=env.spawn('spiro.spr_agent:SprAgent',
                                     states=((25, -25), (85, -85)),
                                     rand=rand,
                                     desired_novelty=10,
                                     log_folder=log_folder)))
    print(aiomas.run(until=env.spawn('spiro.spr_agent:SprAgent',
                                     states=((-25, 25), (-85, 85)),
                                     rand=rand,
                                     desired_novelty=10,
                                     log_folder=log_folder)))

    env.set_agent_acquaintances()
コード例 #43
0
ファイル: cluster.py プロジェクト: johndpope/brood
 def shutdown(self):
     """shutdown the cluster"""
     tasks = [asyncio.ensure_future(manager.stop())
              for manager in self._managers]
     aiomas.run(asyncio.gather(*tasks))
     self._container.shutdown()
コード例 #44
0
def runContainer():

    # Creating container contains the home agents
    # and prediction agents
    HC = aiomas.Container.create(('localhost', 5556), clock=CLOCK)
    # HC = aiomas.Container.create(('localhost', 5556), clock=CLOCK)

    # Set the clcok
    # t_clock_setter = asyncio.async(clock_setter())

    # List of Homes
    homes = [9019, 9981]  # 7881, 100237, 7850, 980, 9981,]

    # Create the DB engine
    # db_engine = create_engine("mysql+pymysql://{}@{}/{}".format(CF.DB_USER, CF.DB_HOST, CF.DB_NAME))
    db_engine = CF.get_db_engine()

    # Initiate the agents into HC
    homeAgents = [
        HomeAgent(
            container=HC,
            agent_id=home,
            db_engine=db_engine,
        ) for home in homes
    ]

    # Creating the session
    session_id = createSession(agents=homeAgents, db_engine=db_engine)

    # Address of the blockchain agent
    # Later, it will be retreived from the Agent Server
    bc_address = getActiveBlockchainAddress(db_engine=db_engine)

    if bc_address is None:
        logging.info("Blockchain is not initiated.")
    else:
        # Bind the blockchain with home agents
        for agent in homeAgents:
            agent.setBlockchainAddress(bc_address=bc_address)

    # Run the event loop
    try:
        logger.info(
            "Running the event loop. One of the home agents is trying to connect with BC agent!"
        )
        logger.info("Session ID:{}".format(session_id))

        # Run the even loop
        aiomas.run()
    except KeyboardInterrupt:
        logger.info("Stopping the event loop")
        # Try to stop the event loop

    except Exception as e:
        traceback.print_exc(file=sys.stdout)
    finally:
        # Killing the current session
        killSession(session_id=session_id, db_engine=db_engine)

    # Shutting donw the controller and thereby cleaning
    # all agents
    try:
        logger.info(
            "Shutting down the home container...and cancelling the clock")
        HC.shutdown()
        # t_clock_setter.cancel()
        logger.info("Done.")
    except Exception as e:
        logger.info("Failed to shutdown the home container")
        traceback.print_exc(file=sys.stdout)