def setup_class(cls):
"""Test that if the controller agent does not receive enough registrations, it stops."""
tac_parameters = TACParameters(min_nb_agents=2,
start_time=datetime.datetime.now(),
registration_timeout=5)
cls.controller_agent = ControllerAgent('controller', '127.0.0.1',
10000, tac_parameters,
NullMonitor())
cls.controller_agent.mailbox.connect()
job = Thread(target=cls.controller_agent.start)
job.start()
cls.crypto = Crypto()
cls.agent1 = TOEFAgent(cls.crypto.public_key,
oef_addr='127.0.0.1',
oef_port=10000)
cls.agent1.connect()
tac_msg = TACMessage(tac_type=TACMessage.Type.REGISTER,
agent_name='agent_name')
tac_bytes = TACSerializer().encode(tac_msg)
cls.agent1.outbox.put_message(
to=cls.controller_agent.crypto.public_key,
sender=cls.crypto.public_key,
protocol_id=TACMessage.protocol_id,
message=tac_bytes)
job.join()
def setup_class(cls):
"""Test that if the controller agent does not receive enough registrations, it stops."""
tac_parameters = TACParameters(min_nb_agents=2,
start_time=datetime.datetime.now(),
registration_timeout=5)
cls.controller_agent = ControllerAgent('controller', '127.0.0.1',
10000, tac_parameters,
NullMonitor())
def __init__(
self,
oef_addr: str = "localhost",
oef_port: int = 10000,
nb_baseline_agents: int = 10,
register_as: RegisterAs = RegisterAs.BOTH,
search_for: SearchFor = SearchFor.BOTH,
services_interval: int = 1,
pending_transaction_timeout: int = 120,
verbose: bool = False,
dashboard: bool = False,
visdom_addr: str = "localhost",
visdom_port: int = 8097,
data_output_dir: Optional[str] = "data",
version_id: str = str(random.randint(0, 10000)),
seed: int = 42,
nb_baseline_agents_world_modeling: int = 0,
tac_parameters: Optional[TACParameters] = None,
):
"""
Initialize a SimulationParams class.
:param oef_addr: the IP address of the OEF.
:param oef_port: the port of the OEF.
:param nb_baseline_agents: the number of baseline agents to spawn.
:param register_as: the registration policy the agents will follow.
:param search_for: the search policy the agents will follow.
:param services_interval: The amount of time (in seconds) the baseline agents wait until it updates services again.
:param pending_transaction_timeout: The amount of time (in seconds) the baseline agents wait until the transaction confirmation.
:param verbose: control the verbosity of the simulation.
:param dashboard: enable the Visdom visualization.
:param visdom_addr: the IP address of the Visdom server
:param visdom_port: the port of the Visdom server.
:param data_output_dir: the path to the output directory.
:param version_id: the name of the experiment.
:param seed: the random seed.
:param nb_baseline_agents_world_modeling: the number of world modelling baseline agents.
:param tac_parameters: the parameters for the TAC.
"""
self.tac_parameters = (tac_parameters if tac_parameters is not None
else TACParameters())
self.oef_addr = oef_addr
self.oef_port = oef_port
self.nb_baseline_agents = nb_baseline_agents
self.register_as = register_as
self.search_for = search_for
self.services_interval = services_interval
self.pending_transaction_timeout = pending_transaction_timeout
self.verbose = verbose
self.dashboard = dashboard
self.visdom_addr = visdom_addr
self.visdom_port = visdom_port
self.data_output_dir = data_output_dir
self.version_id = version_id
self.seed = seed
self.nb_baseline_agents_world_modeling = nb_baseline_agents_world_modeling
def setup_class(cls):
"""Class setup."""
cls.tac_version_id = "1"
cls.agent_version = "v1"
cls.baseline_agents = _init_baseline_agents(5, cls.agent_version,
"127.0.0.1", 10000,
cls.tac_version_id)
cls.tac_parameters = TACParameters(
min_nb_agents=5,
money_endowment=200,
nb_goods=5,
tx_fee=1.0,
base_good_endowment=2,
lower_bound_factor=0,
upper_bound_factor=0,
start_time=datetime.datetime.now() + datetime.timedelta(0, 2),
registration_timeout=8,
competition_timeout=20,
inactivity_timeout=15,
version_id=cls.tac_version_id,
)
cls.tac_controller = ControllerAgent("controller", "127.0.0.1", 10000,
cls.tac_parameters, NullMonitor())
# run the simulation
try:
controller_thread = Thread(target=cls.tac_controller.start)
baseline_threads = [
Thread(target=_run_baseline_agent, args=[baseline_agent, "v1"])
for baseline_agent in cls.baseline_agents
]
# launch all thread.
all_threads = [controller_thread] + baseline_threads
for thread in all_threads:
thread.start()
# wait for every thread. This part is blocking.
for thread in all_threads:
thread.join()
except Exception as e:
pytest.fail("Got exception: {}".format(e))
def build_simulation_parameters(
arguments: argparse.Namespace) -> SimulationParams:
"""
From argparse output, build an instance of SimulationParams.
:param arguments: the arguments
:return: the simulation parameters
"""
tac_parameters = TACParameters(
min_nb_agents=arguments.nb_agents,
money_endowment=arguments.money_endowment,
nb_goods=arguments.nb_goods,
tx_fee=arguments.tx_fee,
base_good_endowment=arguments.base_good_endowment,
lower_bound_factor=arguments.lower_bound_factor,
upper_bound_factor=arguments.upper_bound_factor,
start_time=dateutil.parser.parse(arguments.start_time),
registration_timeout=arguments.registration_timeout,
competition_timeout=arguments.competition_timeout,
inactivity_timeout=arguments.inactivity_timeout,
whitelist=arguments.whitelist_file,
data_output_dir=arguments.data_output_dir,
version_id=arguments.version_id,
)
simulation_params = SimulationParams(
oef_addr=arguments.oef_addr,
oef_port=arguments.oef_port,
nb_baseline_agents=arguments.nb_baseline_agents,
dashboard=arguments.dashboard,
visdom_addr=arguments.visdom_addr,
visdom_port=arguments.visdom_port,
data_output_dir=arguments.data_output_dir,
version_id=arguments.version_id,
seed=arguments.seed,
nb_baseline_agents_world_modeling=round(
arguments.nb_baseline_agents * arguments.fraction_world_modeling),
tac_parameters=tac_parameters,
)
return simulation_params
def main(name: str = "controller",
nb_agents: int = 5,
nb_goods: int = 5,
money_endowment: int = 200,
base_good_endowment: int = 2,
lower_bound_factor: int = 0,
upper_bound_factor: int = 0,
tx_fee: float = 1.0,
oef_addr: str = "127.0.0.1",
oef_port: int = 10000,
start_time: str = str(datetime.datetime.now() +
datetime.timedelta(0, 10)),
registration_timeout: int = 10,
inactivity_timeout: int = 60,
competition_timeout: int = 240,
whitelist_file: Optional[str] = None,
verbose: bool = False,
dashboard: bool = False,
visdom_addr: str = "localhost",
visdom_port: int = 8097,
data_output_dir: str = "data",
version_id: str = str(random.randint(0, 10000)),
seed: int = 42,
**kwargs):
"""Run the controller script."""
agent = None # type: Optional[ControllerAgent]
random.seed(seed)
if verbose:
logger.setLevel(logging.DEBUG)
else:
logger.setLevel(logging.INFO)
try:
monitor = (VisdomMonitor(visdom_addr=visdom_addr,
visdom_port=visdom_port)
if dashboard else NullMonitor())
whitelist = (set(
open(whitelist_file).read().splitlines(
keepends=False)) if whitelist_file else None)
tac_parameters = TACParameters(
min_nb_agents=nb_agents,
money_endowment=money_endowment,
nb_goods=nb_goods,
tx_fee=tx_fee,
base_good_endowment=base_good_endowment,
lower_bound_factor=lower_bound_factor,
upper_bound_factor=upper_bound_factor,
start_time=dateutil.parser.parse(str(start_time)),
registration_timeout=registration_timeout,
competition_timeout=competition_timeout,
inactivity_timeout=inactivity_timeout,
whitelist=whitelist,
data_output_dir=data_output_dir,
version_id=version_id,
)
agent = ControllerAgent(
name=name,
oef_addr=oef_addr,
oef_port=oef_port,
tac_parameters=tac_parameters,
monitor=monitor,
)
agent.start()
except Exception as e:
logger.exception(e)
except KeyboardInterrupt:
logger.debug("Controller interrupted...")
finally:
if agent is not None:
agent.stop()
agent.teardown()