def test_cannot_start_in_midworkflow(sample_data1):
"""Ensures that intermediate fates do not create labors when no labor
exists.
Given a Fate C -> D, and intermediate Fate D -> E,
Throw event D and ensure Labor D is not created since Labor C does not exist.
"""
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
event_type_d = sample_data1.query(EventType).get(4)
host = sample_data1.query(Host).get(1)
Event.create(sample_data1, host, "system", event_type_d)
event = (
sample_data1.query(Event)
.order_by(desc(Event.id)).first()
)
assert event.host == host
assert event.event_type == event_type_d
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 0
def test_get_labors(sample_data1):
host = Host.get_host(sample_data1, "example.dropbox.com")
assert host.id == 1
assert len(host.labors) == 0
event_type1 = sample_data1.query(EventType).get(1)
event_type3 = sample_data1.query(EventType).get(3)
event_type4 = sample_data1.query(EventType).get(4)
print "Creating event1"
Event.create(sample_data1, host, "testman", event_type1)
print "Creating event2"
Event.create(sample_data1, host, "testman", event_type3)
print "Creating event3"
closing_event = Event.create(sample_data1, host, "testman", event_type4)
print "Get labor info"
all_labors = host.get_labors().all()
open_labors = host.get_open_labors().all()
assert len(all_labors) == 3
assert len(host.labors) == 3
assert len(open_labors) == 1
assert all_labors[0].completion_time is None
assert all_labors[0].completion_event is None
assert all_labors[1].completion_time is not None
assert all_labors[1].completion_event == closing_event
assert all_labors[0].creation_event == closing_event
def test_lifecycle_simple2(sample_data1):
"""Test another simple lifecycle
Throw event A, and see that it creates Labor A.
Throw event D, and see that it closes Labor A and creates no new labors.
"""
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
host = sample_data1.query(Host).first()
assert len(host.labors) == 0
event_a = sample_data1.query(EventType).get(1)
event_d = sample_data1.query(EventType).get(4)
# Throw event A
Event.create(sample_data1, host, "system", event_a)
event = (
sample_data1.query(Event)
.order_by(desc(Event.id)).first()
)
assert event.host == host
assert event.event_type == event_a
labors = sample_data1.query(Labor).all()
assert len(labors) == 1
assert labors[0].completion_time is None
assert labors[0].completion_event is None
assert labors[0].creation_event == event
assert labors[0].for_creator is False
assert len(host.labors) == 1
assert len(event.created_labors) == 1
assert len(event.completed_labors) == 0
# Throw event D
Event.create(
sample_data1, host, "system", event_d
)
event = (
sample_data1.query(Event)
.order_by(desc(Event.id)).first()
)
assert event.host == host
assert event.event_type == event_d
labors = sample_data1.query(Labor).all()
assert len(labors) == 1
assert labors[0].completion_time is not None
assert labors[0].completion_event == event
assert labors[0].for_creator is False
assert len(event.created_labors) == 0
assert len(event.completed_labors) == 1
assert len(host.labors) == 1
def test_quest_preservation(sample_data1):
"""When a quest has labors that chain together, make sure they stay
attached to the quest.
"""
hosts = [
sample_data1.query(Host).filter(
Host.hostname == 'example.dropbox.com'
).one(),
sample_data1.query(Host).filter(
Host.hostname == 'test.dropbox.com'
).one(),
]
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
creation_event_type = (
sample_data1.query(EventType)
.filter(EventType.id == 3).first()
)
target_time = datetime.now() + timedelta(days=2)
Quest.create(
sample_data1, "testman", hosts, creation_event_type, target_time,
description="Embark on the long road of maintenance"
)
quests = sample_data1.query(Quest).all()
assert len(quests) == 1
assert quests[0].embark_time is not None
assert quests[0].completion_time is None
assert quests[0].description == "Embark on the long road of maintenance"
assert quests[0].creator == "testman"
assert len(quests[0].labors) == 2
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 2
# now we want to throw events that create the subsequent labors
found_hosts = sample_data1.query(Host).filter(
Host.hostname.in_(["example.dropbox.com", "test.dropbox.com"])
).all()
assert len(found_hosts) == 2
completion_event_type1 = sample_data1.query(EventType).get(4)
Event.create(
sample_data1, found_hosts[0], "testdude", completion_event_type1
)
Event.create(
sample_data1, found_hosts[1], "testdude", completion_event_type1
)
assert len(quests[0].labors) == 4
assert len(quests[0].get_open_labors().all()) == 2
def test_lifecycle1(sample_data1):
"""Test the automatic creation and closing of labors based on Events and Fates
Throw event A, and see that it creates Labor A.
Throw event B, and see that it closes Labor A and creates no new Labors.
"""
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
event_type_a = sample_data1.query(EventType).get(1)
event_type_b = sample_data1.query(EventType).get(2)
host = sample_data1.query(Host).first()
assert len(host.labors) == 0
# Throw event A
Event.create(sample_data1, host, "system", event_type_a)
event = (
sample_data1.query(Event)
.order_by(desc(Event.id)).first()
)
assert event.host == host
assert event.event_type == event_type_a
labors = sample_data1.query(Labor).all()
assert len(labors) == 1
assert labors[0].completion_time is None
assert labors[0].completion_event is None
assert labors[0].creation_event == event
assert labors[0].for_creator is False
assert len(host.labors) == 1
assert len(event.created_labors) == 1
assert len(event.completed_labors) == 0
# Throw event B
Event.create(
sample_data1, host, "system", event_type_b
)
event = (
sample_data1.query(Event)
.order_by(desc(Event.id)).first()
)
assert event.host == host
assert event.event_type == event_type_b
labors = sample_data1.query(Labor).all()
assert len(labors) == 1
assert labors[0].completion_time is not None
assert labors[0].completion_event == event
assert labors[0].for_creator is False
assert len(event.created_labors) == 0
assert len(event.completed_labors) == 1
assert len(host.labors) == 1
def test_longer_chain(sample_data2):
"""Test chained labors A->B->C->D"""
labors = sample_data2.query(Labor).all()
assert len(labors) == 0
# system-maintenance audit
event_type_a = sample_data2.query(EventType).get(1)
# system-maintenance needed
event_type_b = sample_data2.query(EventType).get(2)
# system-maintenance ready
event_type_c = sample_data2.query(EventType).get(3)
# system-maintenance completed
event_type_d = sample_data2.query(EventType).get(4)
host = sample_data2.query(Host).get(1)
event_a = Event.create(sample_data2, host, "system", event_type_a)
# We will aggressively validate the events created only for event A
event = (
sample_data2.query(Event)
.order_by(desc(Event.id)).first()
)
assert event == event_a
assert event.host == host
assert event.event_type == event_type_a
labors = Labor.get_open_unacknowledged(sample_data2)
assert len(labors) == 1
assert len(host.labors) == 1
assert labors[0].starting_labor_id is None
assert labors[0].for_creator is False
starting_labor_id = labors[0].id
event_b = Event.create(sample_data2, host, "system", event_type_b)
labors = Labor.get_open_unacknowledged(sample_data2)
assert len(labors) == 1
assert len(host.labors) == 2
assert labors[0].starting_labor_id == starting_labor_id
assert labors[0].for_creator is False
event_c = Event.create(sample_data2, host, "system", event_type_c)
labors = Labor.get_open_unacknowledged(sample_data2)
assert len(labors) == 1
assert len(host.labors) == 3
assert labors[0].starting_labor_id == starting_labor_id
assert labors[0].for_creator is True
# This last event closes the final labor but does not create a new labor
event_d = Event.create(sample_data2, host, "system", event_type_d)
labors = Labor.get_open_unacknowledged(sample_data2)
assert len(labors) == 0
assert len(host.labors) == 3
def test_quest_preservation(sample_data1):
"""When a quest has labors that chain together, make sure they stay
attached to the quest.
"""
hosts = [
sample_data1.query(Host).filter(
Host.hostname == 'example.dropbox.com').one(),
sample_data1.query(Host).filter(
Host.hostname == 'test.dropbox.com').one(),
]
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
target_time = datetime.now() + timedelta(days=2)
fate = (sample_data1.query(Fate).get(4))
Quest.create(sample_data1,
"testman",
hosts,
target_time,
fate_id=fate.id,
description="Embark on the long road of maintenance")
quests = sample_data1.query(Quest).all()
assert len(quests) == 1
assert quests[0].embark_time is not None
assert quests[0].completion_time is None
assert quests[0].description == "Embark on the long road of maintenance"
assert quests[0].creator == "testman"
assert len(quests[0].labors) == 2
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 2
# now we want to throw events that create the subsequent labors
found_hosts = sample_data1.query(Host).filter(
Host.hostname.in_(["example.dropbox.com", "test.dropbox.com"])).all()
assert len(found_hosts) == 2
completion_event_type1 = sample_data1.query(EventType).get(4)
Event.create(sample_data1, found_hosts[0], "testdude",
completion_event_type1)
Event.create(sample_data1, found_hosts[1], "testdude",
completion_event_type1)
assert len(quests[0].labors) == 4
assert len(quests[0].get_open_labors().all()) == 2
def test_lifecycle_simple2(sample_data1):
"""Test another simple lifecycle
Throw event A, and see that it creates Labor A.
Throw event D, and see that it closes Labor A and creates no new labors.
"""
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
host = sample_data1.query(Host).first()
assert len(host.labors) == 0
event_a = sample_data1.query(EventType).get(1)
event_d = sample_data1.query(EventType).get(4)
# Throw event A
Event.create(sample_data1, host, "system", event_a)
event = (sample_data1.query(Event).order_by(desc(Event.id)).first())
assert event.host == host
assert event.event_type == event_a
labors = sample_data1.query(Labor).all()
assert len(labors) == 1
assert labors[0].completion_time is None
assert labors[0].completion_event is None
assert labors[0].creation_event == event
assert labors[0].for_creator is False
assert len(host.labors) == 1
assert len(event.created_labors) == 1
assert len(event.completed_labors) == 0
# Throw event D
Event.create(sample_data1, host, "system", event_d)
event = (sample_data1.query(Event).order_by(desc(Event.id)).first())
assert event.host == host
assert event.event_type == event_d
labors = sample_data1.query(Labor).all()
assert len(labors) == 1
assert labors[0].completion_time is not None
assert labors[0].completion_event == event
assert labors[0].for_creator is False
assert len(event.created_labors) == 0
assert len(event.completed_labors) == 1
assert len(host.labors) == 1
def test_longer_chain(sample_data2):
"""Test chained labors A->B->C->D"""
labors = sample_data2.query(Labor).all()
assert len(labors) == 0
# system-maintenance audit
event_type_a = sample_data2.query(EventType).get(1)
# system-maintenance needed
event_type_b = sample_data2.query(EventType).get(2)
# system-maintenance ready
event_type_c = sample_data2.query(EventType).get(3)
# system-maintenance completed
event_type_d = sample_data2.query(EventType).get(4)
host = sample_data2.query(Host).get(1)
event_a = Event.create(sample_data2, host, "system", event_type_a)
# We will aggressively validate the events created only for event A
event = (sample_data2.query(Event).order_by(desc(Event.id)).first())
assert event == event_a
assert event.host == host
assert event.event_type == event_type_a
labors = Labor.get_open_unacknowledged(sample_data2)
assert len(labors) == 1
assert len(host.labors) == 1
assert labors[0].starting_labor_id is None
assert labors[0].for_creator is False
starting_labor_id = labors[0].id
event_b = Event.create(sample_data2, host, "system", event_type_b)
labors = Labor.get_open_unacknowledged(sample_data2)
assert len(labors) == 1
assert len(host.labors) == 2
assert labors[0].starting_labor_id == starting_labor_id
assert labors[0].for_creator is False
event_c = Event.create(sample_data2, host, "system", event_type_c)
labors = Labor.get_open_unacknowledged(sample_data2)
assert len(labors) == 1
assert len(host.labors) == 3
assert labors[0].starting_labor_id == starting_labor_id
assert labors[0].for_creator is True
# This last event closes the final labor but does not create a new labor
event_d = Event.create(sample_data2, host, "system", event_type_d)
labors = Labor.get_open_unacknowledged(sample_data2)
assert len(labors) == 0
assert len(host.labors) == 3
def test_lifecycle1(sample_data1):
"""Test the automatic creation and closing of labors based on Events and Fates
Throw event A, and see that it creates Labor A.
Throw event B, and see that it closes Labor A and creates no new Labors.
"""
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
event_type_a = sample_data1.query(EventType).get(1)
event_type_b = sample_data1.query(EventType).get(2)
host = sample_data1.query(Host).first()
assert len(host.labors) == 0
# Throw event A
Event.create(sample_data1, host, "system", event_type_a)
event = (sample_data1.query(Event).order_by(desc(Event.id)).first())
assert event.host == host
assert event.event_type == event_type_a
labors = sample_data1.query(Labor).all()
assert len(labors) == 1
assert labors[0].completion_time is None
assert labors[0].completion_event is None
assert labors[0].creation_event == event
assert labors[0].for_creator is False
assert len(host.labors) == 1
assert len(event.created_labors) == 1
assert len(event.completed_labors) == 0
# Throw event B
Event.create(sample_data1, host, "system", event_type_b)
event = (sample_data1.query(Event).order_by(desc(Event.id)).first())
assert event.host == host
assert event.event_type == event_type_b
labors = sample_data1.query(Labor).all()
assert len(labors) == 1
assert labors[0].completion_time is not None
assert labors[0].completion_event == event
assert labors[0].for_creator is False
assert len(event.created_labors) == 0
assert len(event.completed_labors) == 1
assert len(host.labors) == 1
def test_acknowledge(sample_data1):
"""Test to ensure that acknowledgement correctly flags Labors as such"""
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
fate = sample_data1.query(Fate).get(1)
host = sample_data1.query(Host).get(1)
Event.create(sample_data1, host, "system", fate.creation_event_type)
event = (
sample_data1.query(Event)
.order_by(desc(Event.id)).first()
)
assert event.host == host
assert event.event_type == fate.creation_event_type
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 1
assert labors[0].completion_time is None
assert labors[0].completion_event is None
assert labors[0].ack_time is None
assert labors[0].ack_user is None
assert labors[0].creation_event == event
assert labors[0].for_creator is False
labors[0].acknowledge("testman")
labors = sample_data1.query(Labor).all()
assert len(labors) == 1
assert labors[0].completion_time is None
assert labors[0].completion_event is None
assert labors[0].ack_time is not None
assert labors[0].ack_user == "testman"
assert labors[0].creation_event == event
assert labors[0].for_creator is False
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 0
def test_acknowledge(sample_data1):
"""Test to ensure that acknowledgement correctly flags Labors as such"""
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
fate = sample_data1.query(Fate).get(1)
host = sample_data1.query(Host).get(1)
Event.create(sample_data1, host, "system", fate.creation_event_type)
event = (sample_data1.query(Event).order_by(desc(Event.id)).first())
assert event.host == host
assert event.event_type == fate.creation_event_type
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 1
assert labors[0].completion_time is None
assert labors[0].completion_event is None
assert labors[0].ack_time is None
assert labors[0].ack_user is None
assert labors[0].creation_event == event
assert labors[0].for_creator is False
labors[0].acknowledge("testman")
labors = sample_data1.query(Labor).all()
assert len(labors) == 1
assert labors[0].completion_time is None
assert labors[0].completion_event is None
assert labors[0].ack_time is not None
assert labors[0].ack_user == "testman"
assert labors[0].creation_event == event
assert labors[0].for_creator is False
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 0
def test_cannot_start_in_midworkflow(sample_data1):
"""Ensures that intermediate fates do not create labors when no labor
exists.
Given a Fate C -> D, and intermediate Fate D -> E,
Throw event D and ensure Labor D is not created since Labor C does not exist.
"""
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
event_type_d = sample_data1.query(EventType).get(4)
host = sample_data1.query(Host).get(1)
Event.create(sample_data1, host, "system", event_type_d)
event = (sample_data1.query(Event).order_by(desc(Event.id)).first())
assert event.host == host
assert event.event_type == event_type_d
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 0
def test_creation(sample_data1):
hosts = [
sample_data1.query(Host).filter(
Host.hostname == 'example.dropbox.com').one(),
sample_data1.query(Host).filter(
Host.hostname == 'test.dropbox.com').one(),
]
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
fate = (sample_data1.query(Fate).get(1))
target_time = datetime.now() + timedelta(days=2)
Quest.create(sample_data1,
"testman",
hosts,
target_time,
fate_id=fate.id,
description="Embark on the long road of maintenance")
quests = sample_data1.query(Quest).all()
assert len(quests) == 1
assert quests[0].embark_time is not None
assert quests[0].completion_time is None
assert quests[0].description == "Embark on the long road of maintenance"
assert quests[0].creator == "testman"
assert quests[0].target_time == target_time
assert len(quests[0].labors) == 2
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 2
# now we want to test the closing of the quest by throwing events
# that fulfill the labors
found_hosts = sample_data1.query(Host).filter(
Host.hostname.in_(["example.dropbox.com", "test.dropbox.com"])).all()
assert len(found_hosts) == 2
completion_event_type = (sample_data1.query(EventType).filter(
EventType.id == 2).first())
Event.create(sample_data1, found_hosts[0], "testdude",
completion_event_type)
Event.create(sample_data1, found_hosts[1], "testdude",
completion_event_type)
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 0
quests = sample_data1.query(Quest).all()
assert len(quests) == 1
assert quests[0].embark_time is not None
assert quests[0].completion_time is not None
assert quests[0].description == "Embark on the long road of maintenance"
assert quests[0].creator == "testman"
assert len(quests[0].labors) == 2
def test_lifecycle_complex2(sample_data1):
"""Test the automatic creation and closing of labors based on Events and Fates.
This version is a bit more complex in that we make sure unaffiliated labors
are left untouched.
Throw event A, creates Labor A.
Throw event C, creates Labor C.
Throw event B, closes Labor A, but does nothing to Labor C.
"""
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
fates = sample_data1.query(Fate).all()
fate1 = fates[0]
fate2 = fates[1]
fate4 = fates[3]
hosts = sample_data1.query(Host).all()
host1 = hosts[0]
host2 = hosts[1]
# Throw event A and C
Event.create(sample_data1, host1, "system", fate1.creation_event_type)
Event.create(sample_data1, host2, "system", fate4.creation_event_type)
event = (
sample_data1.query(Event)
.order_by(desc(Event.id)).first()
)
assert event.host == host2
assert event.event_type == fate4.creation_event_type
labors = sample_data1.query(Labor).all()
assert len(labors) == 2
assert labors[0].completion_time is None
assert labors[0].completion_event is None
assert labors[0].for_creator is False
assert labors[1].completion_time is None
assert labors[1].completion_event is None
assert labors[1].for_creator is False
# Throw event B
Event.create(
sample_data1, host1, "system", fate2.creation_event_type
)
event = (
sample_data1.query(Event)
.order_by(desc(Event.id)).first()
)
assert event.host == host1
assert event.event_type == fate2.creation_event_type
labors = sample_data1.query(Labor).all()
assert len(labors) == 2
assert labors[0].completion_time is not None
assert labors[0].completion_event is not None
assert labors[0].for_creator is False
assert labors[1].completion_time is None
assert labors[1].completion_event is None
assert labors[1].for_creator is False
labors = Labor.get_open_labors(sample_data1).all()
assert len(labors) == 1
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 1
def test_lifecycle_complex2(sample_data1):
"""Test the automatic creation and closing of labors based on Events and Fates.
This version is a bit more complex in that we make sure unaffiliated labors
are left untouched.
Throw event A, creates Labor A.
Throw event C, creates Labor C.
Throw event B, closes Labor A, but does nothing to Labor C.
"""
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
fates = sample_data1.query(Fate).all()
fate1 = fates[0]
fate2 = fates[1]
fate4 = fates[3]
hosts = sample_data1.query(Host).all()
host1 = hosts[0]
host2 = hosts[1]
# Throw event A and C
Event.create(sample_data1, host1, "system", fate1.creation_event_type)
Event.create(sample_data1, host2, "system", fate4.creation_event_type)
event = (sample_data1.query(Event).order_by(desc(Event.id)).first())
assert event.host == host2
assert event.event_type == fate4.creation_event_type
labors = sample_data1.query(Labor).all()
assert len(labors) == 2
assert labors[0].completion_time is None
assert labors[0].completion_event is None
assert labors[0].for_creator is False
assert labors[1].completion_time is None
assert labors[1].completion_event is None
assert labors[1].for_creator is False
# Throw event B
Event.create(sample_data1, host1, "system", fate2.creation_event_type)
event = (sample_data1.query(Event).order_by(desc(Event.id)).first())
assert event.host == host1
assert event.event_type == fate2.creation_event_type
labors = sample_data1.query(Labor).all()
assert len(labors) == 2
assert labors[0].completion_time is not None
assert labors[0].completion_event is not None
assert labors[0].for_creator is False
assert labors[1].completion_time is None
assert labors[1].completion_event is None
assert labors[1].for_creator is False
labors = Labor.get_open_labors(sample_data1).all()
assert len(labors) == 1
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 1
def test_explicit_chain(sample_data2):
"""This test works on testing some complex chaining of fates:
ET: sys-audit, sys-needed, sys-ready, sys-complete, reboot-needed,
reboot-complete, puppet-restart
Fates:
1: system-maintenance-audit => system-maintenance-needed
=> system-maintenance-ready => system-maintenance-completed
9: system-maintenance-audit => system-reboot-completed
Quests:
Bravo: fate chain 1
Charlie: fate chain 9
"""
event_types = sample_data2.query(EventType).all()
assert len(event_types) == 7
fates = sample_data2.query(Fate).all()
assert len(fates) == 10
hosts = [sample_data2.query(Host).get(1), sample_data2.query(Host).get(2)]
target_time1 = datetime.now() + timedelta(days=2)
target_time2 = datetime.now() + timedelta(days=7)
print "\nbravo quest"
bravo_quest = Quest.create(
sample_data2, "testman", [hosts[0]],
target_time1,
fate_id=1,
description="System maintenance is needed"
)
print "\ncharlie quest"
charlie_quest = Quest.create(
sample_data2, "testman", [hosts[1]],
target_time2,
fate_id=9,
description="Systems maintenance is needed"
)
assert bravo_quest
assert charlie_quest
assert len(bravo_quest.labors) == 1
assert bravo_quest.get_open_labors().all()[0].for_owner is True
assert bravo_quest.get_open_labors().all()[0].for_creator is False
assert len(charlie_quest.labors) == 1
assert bravo_quest.completion_time is None
assert charlie_quest.completion_time is None
assert len(hosts[0].events) == 1
assert len(hosts[1].events) == 1
# Now let's look at the fate ID of the labors and make sure they are correct
assert bravo_quest.get_open_labors().all()[0].fate_id == 1
assert charlie_quest.get_open_labors().all()[0].fate_id == 9
# Now progress the bravo quest by throwing the sys-maint needed event
# and ensure charlie quest didn't move
print "\nevent 1"
event1a = Event.create(
sample_data2, hosts[0], "system",
EventType.get_event_type(sample_data2, "system-maintenance", "needed")
)
event1b = Event.create(
sample_data2, hosts[1], "system",
EventType.get_event_type(sample_data2, "system-maintenance", "needed")
)
assert bravo_quest.get_open_labors().all()[0].creation_event == event1a
assert bravo_quest.get_open_labors().all()[0].starting_labor_id == hosts[0].events[0].id
assert bravo_quest.get_open_labors().all()[0].for_owner is True
assert bravo_quest.get_open_labors().all()[0].for_creator is False
assert bravo_quest.completion_time is None
assert len(bravo_quest.labors) == 2
assert charlie_quest.completion_time is None
assert len(charlie_quest.labors) == 1
# Throw system-reboot completed event for both hosts and ensure it closes
# charlie quest but does nothing to bravo quest
print "\nevent 1"
event2a = Event.create(
sample_data2, hosts[0], "system",
EventType.get_event_type(sample_data2, "puppet", "restart")
)
event2b = Event.create(
sample_data2, hosts[1], "system",
EventType.get_event_type(sample_data2, "puppet", "restart")
)
assert bravo_quest.get_open_labors().all()[0].creation_event == event1a
assert bravo_quest.get_open_labors().all()[0].starting_labor_id == hosts[0].events[0].id
assert bravo_quest.get_open_labors().all()[0].for_owner is True
assert bravo_quest.get_open_labors().all()[0].for_creator is False
assert bravo_quest.completion_time is None
assert len(bravo_quest.labors) == 2
assert charlie_quest.completion_time is not None
assert len(charlie_quest.labors) == 1
def test_get_latest_events(session):
event_type1 = EventType.create(session, "foo", "bar", "test type 1")
event_type2 = EventType.create(session, "foo", "baz", "test type 2")
host1 = Host.create(session, "server1")
host2 = Host.create(session, "server2")
Event.create(session, host1, "testman", event_type1)
Event.create(session, host1, "testman", event_type2)
Event.create(session, host2, "testman", event_type1)
Event.create(session, host1, "testman", event_type1)
Event.create(session, host1, "testman", event_type2)
last_type2 = Event.create(session, host2, "testman", event_type2)
last_type1 = Event.create(session, host2, "testman", event_type1)
events1 = event_type1.get_latest_events().all()
events2 = event_type2.get_latest_events().all()
assert len(events1) == 4
assert len(events2) == 3
assert events1[0] == last_type1
assert events2[0] == last_type2
def test_creation(sample_data1):
hosts = [
sample_data1.query(Host).filter(
Host.hostname == 'example.dropbox.com'
).one(),
sample_data1.query(Host).filter(
Host.hostname == 'test.dropbox.com'
).one(),
]
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
creation_event_type = (
sample_data1.query(EventType)
.filter(EventType.id == 1).first()
)
target_time = datetime.now() + timedelta(days=2)
Quest.create(
sample_data1, "testman", hosts, creation_event_type, target_time,
description="Embark on the long road of maintenance"
)
quests = sample_data1.query(Quest).all()
assert len(quests) == 1
assert quests[0].embark_time is not None
assert quests[0].completion_time is None
assert quests[0].description == "Embark on the long road of maintenance"
assert quests[0].creator == "testman"
assert quests[0].target_time == target_time
assert len(quests[0].labors) == 2
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 2
# now we want to test the closing of the quest by throwing events
# that fulfill the labors
found_hosts = sample_data1.query(Host).filter(
Host.hostname.in_(["example.dropbox.com", "test.dropbox.com"])
).all()
assert len(found_hosts) == 2
completion_event_type = (
sample_data1.query(EventType)
.filter(EventType.id == 2).first()
)
Event.create(
sample_data1, found_hosts[0], "testdude", completion_event_type
)
Event.create(
sample_data1, found_hosts[1], "testdude", completion_event_type
)
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 0
quests = sample_data1.query(Quest).all()
assert len(quests) == 1
assert quests[0].embark_time is not None
assert quests[0].completion_time is not None
assert quests[0].description == "Embark on the long road of maintenance"
assert quests[0].creator == "testman"
assert len(quests[0].labors) == 2
def test_complex_chaining1(sample_data2):
"""This test works on testing some complex chainging fates:
ET: sys-audit, sys-needed, sys-ready, sys-complete, reboot-needed, reboot-complete, puppet-restart
Fates:
sys-audit => sys-needed
sys-needed => sys-ready
sys-ready => sys-complete
sys-needed => reboot-complete
reboot-needed => reboot-complete
reboot-complete => puppet-restart
Quests:
Alpha: servers need sys-audit; on sys-needed event, add only 1 labor for sys-needed and add to quest
"""
event_types = sample_data2.query(EventType).all()
assert len(event_types) == 7
fates = sample_data2.query(Fate).all()
assert len(fates) == 10
hosts = [
sample_data2.query(Host).filter(
Host.hostname == 'example.dropbox.com').one(),
sample_data2.query(Host).filter(
Host.hostname == 'test.dropbox.com').one(),
]
target_time = datetime.now() + timedelta(days=2)
quest = Quest.create(sample_data2,
"testman",
hosts,
target_time,
fate_id=1,
description="Servers need audit")
assert quest
assert len(quest.get_open_labors().all()) == 2
# now we fire the system-maintenance needed event
found_hosts = sample_data2.query(Host).filter(
Host.hostname.in_(["example.dropbox.com", "test.dropbox.com"])).all()
assert len(found_hosts) == 2
event1 = Event.create(
sample_data2, found_hosts[0], "system",
EventType.get_event_type(sample_data2, "system-maintenance", "needed"))
event2 = Event.create(
sample_data2, found_hosts[1], "system",
EventType.get_event_type(sample_data2, "system-maintenance", "needed"))
assert len(quest.labors) == 4
assert len(quest.get_open_labors().all()) == 2
assert quest.completion_time is None
labor1 = quest.get_open_labors().all()[0]
labor2 = quest.get_open_labors().all()[1]
assert labor1.host == hosts[0]
assert labor2.host == hosts[1]
assert labor1.for_owner is True
assert labor1.for_creator is False
assert labor2.for_owner is True
assert labor2.for_creator is False
assert labor1.creation_event == event1
assert labor2.creation_event == event2
def test_get_latest_events(session):
event_type1 = EventType.create(session, "foo", "bar", "test type 1")
event_type2 = EventType.create(session, "foo", "baz", "test type 2")
host1 = Host.create(session, "server1")
host2 = Host.create(session, "server2")
Event.create(session, host1, "testman", event_type1)
Event.create(session, host1, "testman", event_type2)
Event.create(session, host2, "testman", event_type1)
Event.create(session, host1, "testman", event_type1)
Event.create(session, host1, "testman", event_type2)
last_type2 = Event.create(session, host2, "testman", event_type2)
last_type1 = Event.create(session, host2, "testman", event_type1)
events1 = event_type1.get_latest_events().all()
events2 = event_type2.get_latest_events().all()
assert len(events1) == 4
assert len(events2) == 3
assert events1[0] == last_type1
assert events2[0] == last_type2
def test_complex_chaining3(sample_data2):
"""This test works on testing some complex chaining of fates:
ET: sys-audit, sys-needed, sys-ready, sys-complete, reboot-needed,
reboot-complete, puppet-restart
Fates:
system-maintenance-audit => system-maintenance-needed
=> system-maintenance-ready => system-maintenance-completed
system-maintenance-audit => system-maintenance-needed
=> system-reboot-completed
system-reboot-needed => system-reboot-completed => puppet-restart
Quests:
Bravo: servers need sys-needed
Charlie: servers need reboot-needed
"""
event_types = sample_data2.query(EventType).all()
assert len(event_types) == 7
fates = sample_data2.query(Fate).all()
assert len(fates) == 10
hosts = [sample_data2.query(Host).get(1)]
target_time1 = datetime.now() + timedelta(days=2)
target_time2 = datetime.now() + timedelta(days=7)
print "\nbravo quest"
bravo_quest = Quest.create(sample_data2,
"testman",
hosts,
target_time1,
fate_id=1,
description="System maintenance is needed")
print "\ncharlie quest"
charlie_quest = Quest.create(sample_data2,
"testman",
hosts,
target_time2,
fate_id=6,
description="Systems need a reboot")
assert bravo_quest
assert charlie_quest
assert len(bravo_quest.labors) == 1
assert bravo_quest.get_open_labors().all()[0].for_owner is True
assert bravo_quest.get_open_labors().all()[0].for_creator is False
assert len(charlie_quest.labors) == 1
assert bravo_quest.completion_time is None
assert charlie_quest.completion_time is None
assert len(hosts[0].events) == 2
# Now we want to progress the bravo quest by throwing the sys-maint needed event
print "\nevent 1"
event1 = Event.create(
sample_data2, hosts[0], "system",
EventType.get_event_type(sample_data2, "system-maintenance", "needed"))
assert bravo_quest.get_open_labors().all()[0].creation_event == event1
assert bravo_quest.get_open_labors().all(
)[0].starting_labor_id == hosts[0].events[0].id
assert bravo_quest.get_open_labors().all()[0].for_owner is True
assert bravo_quest.get_open_labors().all()[0].for_creator is False
assert len(bravo_quest.labors) == 2
# Now we progress the bravo quest again by throwing sys-maint-ready
print "\nevent 1b"
event1b = Event.create(
sample_data2, hosts[0], "system",
EventType.get_event_type(sample_data2, "system-maintenance", "ready"))
assert bravo_quest.get_open_labors().all()[0].creation_event == event1b
assert bravo_quest.get_open_labors().all(
)[0].starting_labor_id == hosts[0].events[0].id
assert bravo_quest.get_open_labors().all()[0].for_owner is False
assert bravo_quest.get_open_labors().all()[0].for_creator is True
assert len(bravo_quest.labors) == 3
# Now we progress the charlie quest with the system-reboot-completed event
# but bravo quest stays put
print "\nevent 2"
event2 = Event.create(
sample_data2, hosts[0], "system",
EventType.get_event_type(sample_data2, "system-reboot", "completed"))
assert bravo_quest.completion_time is None
assert len(bravo_quest.labors) == 3
assert charlie_quest.get_open_labors().all()[0].creation_event == event2
assert charlie_quest.get_open_labors().all(
)[0].starting_labor_id == hosts[0].events[1].id
assert charlie_quest.completion_time is None
assert len(charlie_quest.labors) == 2
# since the previous event progressed the workflow, this one below
# shouldn't create a labor since system-reboot-completed labors are
# intermediates
print "\nevent 3"
event3 = Event.create(
sample_data2, hosts[0], "system",
EventType.get_event_type(sample_data2, "system-reboot", "completed"))
# we will have a 6th event here due to event3
assert len(hosts[0].events) == 6
assert len(charlie_quest.labors) == 2
assert len(charlie_quest.get_open_labors().all()) == 1
assert charlie_quest.get_open_labors().all()[0].creation_event == event2
assert charlie_quest.get_open_labors().all()[0].quest == charlie_quest
assert len(sample_data2.query(Labor).all()) == 5
def test_complex_chaining1(sample_data2):
"""This test works on testing some complex chainging fates:
ET: sys-audit, sys-needed, sys-ready, sys-complete, reboot-needed, reboot-complete, puppet-restart
Fates:
sys-audit => sys-needed
sys-needed => sys-ready
sys-ready => sys-complete
sys-needed => reboot-complete
reboot-needed => reboot-complete
reboot-complete => puppet-restart
Quests:
Alpha: servers need sys-audit; on sys-needed event, add only 1 labor for sys-needed and add to quest
"""
event_types = sample_data2.query(EventType).all()
assert len(event_types) == 7
fates = sample_data2.query(Fate).all()
assert len(fates) == 6
hosts = [
sample_data2.query(Host).filter(
Host.hostname == 'example.dropbox.com'
).one(),
sample_data2.query(Host).filter(
Host.hostname == 'test.dropbox.com'
).one(),
]
target_time = datetime.now() + timedelta(days=2)
quest = Quest.create(
sample_data2, "testman", hosts,
EventType.get_event_type(sample_data2, "system-maintenance", "audit"),
target_time,
description="Servers need audit"
)
assert quest
assert len(quest.get_open_labors().all()) == 2
# now we fire the system-maintenance needed event
found_hosts = sample_data2.query(Host).filter(
Host.hostname.in_(["example.dropbox.com", "test.dropbox.com"])
).all()
assert len(found_hosts) == 2
event1 = Event.create(
sample_data2, found_hosts[0], "system",
EventType.get_event_type(sample_data2, "system-maintenance", "needed")
)
event2 = Event.create(
sample_data2, found_hosts[1], "system",
EventType.get_event_type(sample_data2, "system-maintenance", "needed")
)
assert len(quest.labors) == 4
assert len(quest.get_open_labors().all()) == 2
assert quest.completion_time is None
labor1 = quest.get_open_labors().all()[0]
labor2 = quest.get_open_labors().all()[1]
assert labor1.host == hosts[0]
assert labor2.host == hosts[1]
assert labor1.creation_event == event1
assert labor2.creation_event == event2
def test_explicit_chain(sample_data2):
"""This test works on testing some complex chaining of fates:
ET: sys-audit, sys-needed, sys-ready, sys-complete, reboot-needed,
reboot-complete, puppet-restart
Fates:
1: system-maintenance-audit => system-maintenance-needed
=> system-maintenance-ready => system-maintenance-completed
9: system-maintenance-audit => system-reboot-completed
Quests:
Bravo: fate chain 1
Charlie: fate chain 9
"""
event_types = sample_data2.query(EventType).all()
assert len(event_types) == 7
fates = sample_data2.query(Fate).all()
assert len(fates) == 10
hosts = [sample_data2.query(Host).get(1), sample_data2.query(Host).get(2)]
target_time1 = datetime.now() + timedelta(days=2)
target_time2 = datetime.now() + timedelta(days=7)
print "\nbravo quest"
bravo_quest = Quest.create(sample_data2,
"testman", [hosts[0]],
target_time1,
fate_id=1,
description="System maintenance is needed")
print "\ncharlie quest"
charlie_quest = Quest.create(sample_data2,
"testman", [hosts[1]],
target_time2,
fate_id=9,
description="Systems maintenance is needed")
assert bravo_quest
assert charlie_quest
assert len(bravo_quest.labors) == 1
assert bravo_quest.get_open_labors().all()[0].for_owner is True
assert bravo_quest.get_open_labors().all()[0].for_creator is False
assert len(charlie_quest.labors) == 1
assert bravo_quest.completion_time is None
assert charlie_quest.completion_time is None
assert len(hosts[0].events) == 1
assert len(hosts[1].events) == 1
# Now let's look at the fate ID of the labors and make sure they are correct
assert bravo_quest.get_open_labors().all()[0].fate_id == 1
assert charlie_quest.get_open_labors().all()[0].fate_id == 9
# Now progress the bravo quest by throwing the sys-maint needed event
# and ensure charlie quest didn't move
print "\nevent 1"
event1a = Event.create(
sample_data2, hosts[0], "system",
EventType.get_event_type(sample_data2, "system-maintenance", "needed"))
event1b = Event.create(
sample_data2, hosts[1], "system",
EventType.get_event_type(sample_data2, "system-maintenance", "needed"))
assert bravo_quest.get_open_labors().all()[0].creation_event == event1a
assert bravo_quest.get_open_labors().all(
)[0].starting_labor_id == hosts[0].events[0].id
assert bravo_quest.get_open_labors().all()[0].for_owner is True
assert bravo_quest.get_open_labors().all()[0].for_creator is False
assert bravo_quest.completion_time is None
assert len(bravo_quest.labors) == 2
assert charlie_quest.completion_time is None
assert len(charlie_quest.labors) == 1
# Throw system-reboot completed event for both hosts and ensure it closes
# charlie quest but does nothing to bravo quest
print "\nevent 1"
event2a = Event.create(
sample_data2, hosts[0], "system",
EventType.get_event_type(sample_data2, "puppet", "restart"))
event2b = Event.create(
sample_data2, hosts[1], "system",
EventType.get_event_type(sample_data2, "puppet", "restart"))
assert bravo_quest.get_open_labors().all()[0].creation_event == event1a
assert bravo_quest.get_open_labors().all(
)[0].starting_labor_id == hosts[0].events[0].id
assert bravo_quest.get_open_labors().all()[0].for_owner is True
assert bravo_quest.get_open_labors().all()[0].for_creator is False
assert bravo_quest.completion_time is None
assert len(bravo_quest.labors) == 2
assert charlie_quest.completion_time is not None
assert len(charlie_quest.labors) == 1
def test_complex_chaining3(sample_data2):
"""This test works on testing some complex chaining of fates:
ET: sys-audit, sys-needed, sys-ready, sys-complete, reboot-needed,
reboot-complete, puppet-restart
Fates:
system-maintenance-audit => system-maintenance-needed
=> system-maintenance-ready => system-maintenance-completed
system-maintenance-audit => system-maintenance-needed
=> system-reboot-completed
system-reboot-needed => system-reboot-completed => puppet-restart
Quests:
Bravo: servers need sys-needed
Charlie: servers need reboot-needed
"""
event_types = sample_data2.query(EventType).all()
assert len(event_types) == 7
fates = sample_data2.query(Fate).all()
assert len(fates) == 6
hosts = [sample_data2.query(Host).get(1)]
target_time1 = datetime.now() + timedelta(days=2)
target_time2 = datetime.now() + timedelta(days=7)
print "\nbravo quest"
bravo_quest = Quest.create(
sample_data2, "testman", hosts,
EventType.get_event_type(sample_data2, "system-maintenance", "audit"),
target_time1,
description="System maintenance is needed"
)
print "\ncharlie quest"
charlie_quest = Quest.create(
sample_data2, "testman", hosts,
EventType.get_event_type(sample_data2, "system-reboot", "needed"),
target_time2,
description="Systems need a reboot"
)
assert bravo_quest
assert charlie_quest
assert len(bravo_quest.labors) == 1
assert len(charlie_quest.labors) == 1
assert bravo_quest.completion_time is None
assert charlie_quest.completion_time is None
assert len(hosts[0].events) == 2
# Now we want to progress the bravo quest by throwing the sys-maint needed event
print "\nevent 1"
event1 = Event.create(
sample_data2, hosts[0], "system",
EventType.get_event_type(sample_data2, "system-maintenance", "needed")
)
assert bravo_quest.get_open_labors().all()[0].creation_event == event1
assert bravo_quest.get_open_labors().all()[0].starting_labor_id == hosts[0].events[0].id
assert len(bravo_quest.labors) == 2
# Now we progress the bravo quest again by throwing sys-maint-ready
print "\nevent 1b"
event1b = Event.create(
sample_data2, hosts[0], "system",
EventType.get_event_type(sample_data2, "system-maintenance", "ready")
)
assert bravo_quest.get_open_labors().all()[0].creation_event == event1b
assert bravo_quest.get_open_labors().all()[0].starting_labor_id == hosts[0].events[0].id
assert len(bravo_quest.labors) == 3
# Now we progress the charlie quest with the system-reboot-completed event
# but bravo quest stays put
print "\nevent 2"
event2 = Event.create(
sample_data2, hosts[0], "system",
EventType.get_event_type(sample_data2, "system-reboot", "completed")
)
assert bravo_quest.completion_time is None
assert len(bravo_quest.labors) == 3
assert charlie_quest.get_open_labors().all()[0].creation_event == event2
assert charlie_quest.get_open_labors().all()[0].starting_labor_id == hosts[0].events[1].id
assert charlie_quest.completion_time is None
assert len(charlie_quest.labors) == 2
# since the previous event progressed the workflow, this one below
# shouldn't create a labor since system-reboot-completed labors are
# intermediates
print "\nevent 3"
event3 = Event.create(
sample_data2, hosts[0], "system",
EventType.get_event_type(sample_data2, "system-reboot", "completed")
)
# we will have a 6th event here due to event3
assert len(hosts[0].events) == 6
assert len(charlie_quest.labors) == 2
assert len(charlie_quest.get_open_labors().all()) == 1
assert charlie_quest.get_open_labors().all()[0].creation_event == event2
assert charlie_quest.get_open_labors().all()[0].quest == charlie_quest
assert len(sample_data2.query(Labor).all()) == 5
def test_mass_creation(sample_data1):
hosts = [
sample_data1.query(Host).filter(
Host.hostname == 'example.dropbox.com'
).one(),
sample_data1.query(Host).filter(
Host.hostname == 'test.dropbox.com'
).one(),
]
labors = sample_data1.query(Labor).all()
assert len(labors) == 0
fate = (
sample_data1.query(Fate).get(1)
)
creation_event_type1 = fate.creation_event_type
target_time1 = datetime.now() + timedelta(days=7)
target_time2 = datetime.now() + timedelta(days=10)
target_time3 = datetime.now() + timedelta(days=14)
Quest.create(
sample_data1, "testman", hosts, target_time1, fate_id=fate.id,
description="Embark on the long road of maintenance"
)
Quest.create(
sample_data1, "testman", hosts, target_time2, fate_id=fate.id,
description="Embark on the longer road of maintenance"
)
Quest.create(
sample_data1, "testman", hosts, target_time3, fate_id=fate.id,
description="WHEN WILL IT END!!"
)
quests = sample_data1.query(Quest).all()
assert len(quests) == 3
assert quests[0].embark_time is not None
assert quests[0].completion_time is None
assert quests[0].description == "Embark on the long road of maintenance"
assert quests[0].creator == "testman"
assert quests[1].embark_time is not None
assert quests[1].completion_time is None
assert quests[2].embark_time is not None
assert quests[2].completion_time is None
assert len(quests[0].labors) == 2
assert len(quests[1].labors) == 2
assert len(quests[2].labors) == 2
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 6
# now we want to test the closing of the quest by throwing events
# that fulfill the labors
found_hosts = sample_data1.query(Host).filter(
Host.hostname.in_(["example.dropbox.com", "test.dropbox.com"])
).all()
assert len(found_hosts) == 2
completion_event_type1 = (
sample_data1.query(EventType)
.filter(EventType.id == 2).first()
)
Event.create(
sample_data1, found_hosts[0], "testdude", completion_event_type1
)
Event.create(
sample_data1, found_hosts[1], "testdude", completion_event_type1
)
labors = Labor.get_open_unacknowledged(sample_data1)
assert len(labors) == 0
quests = sample_data1.query(Quest).all()
assert len(quests) == 3
assert quests[0].embark_time is not None
assert quests[0].completion_time is not None
assert quests[1].embark_time is not None
assert quests[1].completion_time is not None
assert quests[2].embark_time is not None
assert quests[2].completion_time is not None
assert quests[0].description == "Embark on the long road of maintenance"
assert quests[0].creator == "testman"
assert len(quests[0].labors) == 2
