def test_agent_process(data_module):
project = data.Project(name="test")
yield project.insert()
env = data.Environment(name="dev",
project=project.id,
repo_url="",
repo_branch="")
yield env.insert()
agent_proc = data.AgentProcess(hostname="testhost",
environment=env.id,
first_seen=datetime.datetime.now(),
last_seen=datetime.datetime.now(),
sid=uuid.uuid4())
yield agent_proc.insert()
agi1 = data.AgentInstance(process=agent_proc.id, name="agi1", tid=env.id)
yield agi1.insert()
agi2 = data.AgentInstance(process=agent_proc.id, name="agi2", tid=env.id)
yield agi2.insert()
agent = data.Agent(environment=env.id,
name="agi1",
last_failover=datetime.datetime.now(),
paused=False,
primary=agi1.id)
agent = yield agent.insert()
agents = yield data.Agent.get_list()
assert len(agents) == 1
agent = agents[0]
primary_instance = yield data.AgentInstance.get_by_id(agent.primary)
primary_process = yield data.AgentProcess.get_by_id(
primary_instance.process)
assert primary_process.id == agent_proc.id
def test_primary_selection(motor):
data.use_motor(motor)
env = data.Environment(name="testenv", project=uuid4())
yield env.insert()
yield data.Agent(environment=env.id, name="agent1", paused=True).insert()
yield data.Agent(environment=env.id, name="agent2", paused=False).insert()
yield data.Agent(environment=env.id, name="agent3", paused=False).insert()
server = Mock()
futures = Collector()
server.add_future.side_effect = futures
am = AgentManager(server, False)
@gen.coroutine
def assert_agent(name: str, state: str, sid: UUID):
agent = yield data.Agent.get(env.id, name)
assert agent.get_status() == state
if state == "paused":
assert agent.primary is None
assert agent.paused
elif state == "down":
assert agent.primary is None
assert not agent.paused
elif state == "up":
assert agent.primary is not None
agent_instance = yield data.AgentInstance.get_by_id(agent.primary)
agent_proc = yield data.AgentProcess.get_by_id(
agent_instance.process)
assert agent_proc.sid == sid
assert agent.get_status() == "up"
@gen.coroutine
def assert_agents(s1, s2, s3, sid1=None, sid2=None, sid3=None):
yield assert_agent("agent1", s1, sid1)
yield assert_agent("agent2", s2, sid2)
yield assert_agent("agent3", s3, sid3)
# one session
ts1 = MockSession(uuid4(), env.id, ["agent1", "agent2"], "ts1")
am.new_session(ts1)
yield futures.proccess()
assert len(am.sessions) == 1
ts1.get_client().set_state.assert_called_with("agent2", True)
ts1.get_client().reset_mock()
yield assert_agents("paused", "up", "down", sid2=ts1.id)
# alive
am.seen(ts1, ["agent1", "agent2"])
yield futures.proccess()
assert len(am.sessions) == 1
yield assert_agents("paused", "up", "down", sid2=ts1.id)
# second session
ts2 = MockSession(uuid4(), env.id, ["agent3", "agent2"], "ts2")
am.new_session(ts2)
yield futures.proccess()
assert len(am.sessions) == 2
ts2.get_client().set_state.assert_called_with("agent3", True)
ts2.get_client().reset_mock()
yield assert_agents("paused", "up", "up", sid2=ts1.id, sid3=ts2.id)
# expire first
am.expire(ts1)
yield futures.proccess()
assert len(am.sessions) == 1
ts2.get_client().set_state.assert_called_with("agent2", True)
ts2.get_client().reset_mock()
yield assert_agents("paused", "up", "up", sid2=ts2.id, sid3=ts2.id)
# expire second
am.expire(ts2)
yield futures.proccess()
assert len(am.sessions) == 0
yield assert_agents("paused", "down", "down")
def test_api(motor):
data.use_motor(motor)
env = data.Environment(name="testenv", project=uuid4())
yield env.insert()
env2 = data.Environment(name="testenv2", project=uuid4())
yield env2.insert()
yield data.Agent(environment=env.id, name="agent1", paused=True).insert()
yield data.Agent(environment=env.id, name="agent2", paused=False).insert()
yield data.Agent(environment=env.id, name="agent3", paused=False).insert()
yield data.Agent(environment=env2.id, name="agent4", paused=False).insert()
server = Mock()
futures = Collector()
server.add_future.side_effect = futures
am = AgentManager(server, False)
# one session
ts1 = MockSession(uuid4(), env.id, ["agent1", "agent2"], "ts1")
am.new_session(ts1)
# second session
ts2 = MockSession(uuid4(), env.id, ["agent3", "agent2"], "ts2")
am.new_session(ts2)
# third session
env3 = uuid4()
ts3 = MockSession(uuid4(), env3, ["agentx"], "ts3")
am.new_session(ts3)
yield futures.proccess()
assert len(am.sessions) == 3
code, all_agents = yield am.list_agent_processes(None, None)
assert code == 200
shouldbe = {
'processes': [{
'id':
UNKWN,
'first_seen':
UNKWN,
'expired':
None,
'hostname':
'ts1',
'last_seen':
UNKWN,
'endpoints': [{
'id': UNKWN,
'name': 'agent1',
'process': UNKWN
}, {
'id': UNKWN,
'name': 'agent2',
'process': UNKWN
}],
'environment':
env.id
}, {
'id':
UNKWN,
'first_seen':
UNKWN,
'expired':
None,
'hostname':
'ts2',
'last_seen':
UNKWN,
'endpoints': [{
'id': UNKWN,
'name': 'agent2',
'process': UNKWN
}, {
'id': UNKWN,
'name': 'agent3',
'process': UNKWN
}],
'environment':
env.id
}, {
'id':
UNKWN,
'first_seen':
UNKWN,
'expired':
None,
'hostname':
'ts3',
'last_seen':
UNKWN,
'endpoints': [{
'id': UNKWN,
'name': 'agentx',
'process': UNKWN
}],
'environment':
env3
}]
}
assert_equal_ish(shouldbe, all_agents, ['hostname', 'name'])
agentid = all_agents['processes'][0]['id']
code, all_agents = yield am.list_agent_processes(env.id, None)
assert code == 200
shouldbe = {
'processes': [{
'id':
UNKWN,
'first_seen':
UNKWN,
'expired':
None,
'hostname':
'ts1',
'last_seen':
UNKWN,
'endpoints': [{
'id': UNKWN,
'name': 'agent1',
'process': UNKWN
}, {
'id': UNKWN,
'name': 'agent2',
'process': UNKWN
}],
'environment':
env.id
}, {
'id':
UNKWN,
'first_seen':
UNKWN,
'expired':
None,
'hostname':
'ts2',
'last_seen':
UNKWN,
'endpoints': [{
'id': UNKWN,
'name': 'agent3',
'process': UNKWN
}, {
'id': UNKWN,
'name': 'agent2',
'process': UNKWN
}],
'environment':
env.id
}]
}
assert_equal_ish(shouldbe, all_agents)
code, all_agents = yield am.list_agent_processes(env2.id, None)
assert code == 200
shouldbe = {'processes': []}
assert_equal_ish(shouldbe, all_agents)
@gen.coroutine
def dummy_status():
return Result(False, 200, "X")
ts1.get_client().get_status.side_effect = dummy_status
report = yield am.get_agent_process_report(agentid)
assert (200, "X") == report
report = yield am.get_agent_process_report(uuid4())
assert 404 == report[0]
code, all_agents = yield am.list_agents(None)
assert code == 200
shouldbe = {
'agents': [{
'name': 'agent1',
'paused': True,
'last_failover': '',
'primary': '',
'environment': env.id,
"state": "paused"
}, {
'name': 'agent2',
'paused': False,
'last_failover': UNKWN,
'primary': UNKWN,
'environment': env.id,
"state": "up"
}, {
'name': 'agent3',
'paused': False,
'last_failover': UNKWN,
'primary': UNKWN,
'environment': env.id,
"state": "up"
}, {
'name': 'agent4',
'paused': False,
'last_failover': '',
'primary': '',
'environment': env2.id,
"state": "down"
}]
}
assert_equal_ish(shouldbe, all_agents, ['name'])
code, all_agents = yield am.list_agents(env2.id)
assert code == 200
shouldbe = {
'agents': [{
'name': 'agent4',
'paused': False,
'last_failover': '',
'primary': '',
'environment': env2.id,
"state": "down"
}]
}
assert_equal_ish(shouldbe, all_agents)
def create_default_agent(self, env: data.Environment, nodename: str):
saved = data.Agent(environment=env.id, name=nodename, paused=False)
yield saved.insert()
yield self.verify_reschedule(env, [nodename])
return saved