2 |
30 |
--------------------------------------------------------------------------------
/db/bootstrap.sql:
--------------------------------------------------------------------------------
1 | # Dump of table event_types
2 | # ------------------------------------------------------------
3 |
4 | LOCK TABLES `event_types` WRITE;
5 |
6 | INSERT INTO `event_types` (`id`, `category`, `state`, `description`)
7 | VALUES
8 | (1,'system-reboot','required','This system requires a reboot.'),
9 | (2,'system-reboot','completed','This system rebooted.'),
10 | (3,'system-maintenance','required','This system requires maintenance.'),
11 | (4,'system-maintenance','ready','This system is ready for maintenance.'),
12 | (5,'system-maintenance','completed','System maintenance completed.');
13 |
14 | UNLOCK TABLES;
15 |
16 | # Dump of table fates
17 | # ------------------------------------------------------------
18 |
19 | LOCK TABLES `fates` WRITE;
20 |
21 | INSERT INTO `fates` (`id`, `creation_type_id`, `completion_type_id`, `follows_id`, `for_creator`, `for_owner`, `description`)
22 | VALUES
23 | (1, 1, 2, NULL, 0, 1, 'A system that needs a reboot can be cleared by rebooting the machine.'),
24 | (2, 3, 4, NULL, 0, 1, 'System must be released using \"cloudbox release\" so maintenance can be carried out.'),
25 | (3, 4, 5, 2, 1, 0, 'Maintenance must be performed on a system that is prepped.'),
26 | (4, 1, 4, NULL, 0, 1, 'A system that needs a reboot can also just be released.');
27 |
28 |
29 | UNLOCK TABLES;
30 |
--------------------------------------------------------------------------------
/hermes/webapp/src/js/directives/boxContinuation.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Directive for watching a div and adding a "box-continuation" class when a
3 | * particular height is reached. This is used when we have a max-height for a div
4 | * with a scroll and want to clue the user in to the fact that the box has additional
5 | * items in it.
6 | *
7 | * A "watch" attribute must be specified that let's us know what data
8 | * modifies the contents of the div (and therefore might alter the height).
9 | */
10 | (function() {
11 | function boxContinuation () {
12 | return {
13 | restrict: 'A',
14 | scope: {
15 | 'watch': '='
16 | },
17 | link: function ($scope, $ele, $attrs) {
18 | var triggerHeight = $attrs.triggerHeight || 200;
19 |
20 | $scope.$watch('watch',
21 | classAlteration, true);
22 |
23 | function classAlteration() {
24 | setTimeout(function() {
25 | if ($ele[0].clientHeight >= triggerHeight) {
26 | $ele[0].classList.add('box-continuation');
27 | } else {
28 | $ele[0].classList.remove('box-continuation');
29 | }
30 | }, 1);
31 | }
32 | }
33 | }
34 | }
35 |
36 | angular.module('hermesApp').directive('boxContinuation', boxContinuation);
37 | })();
--------------------------------------------------------------------------------
/hermes/webapp/src/js/hermesApp.js:
--------------------------------------------------------------------------------
1 | (function() {
2 |
3 | 'use strict';
4 |
5 | var app = angular.module('hermesApp',
6 | [
7 | 'ngAnimate',
8 | 'ngRoute',
9 | 'ngLocationUpdate',
10 | 'smoothScroll',
11 | 'ui.bootstrap',
12 | 'ngCookies',
13 | ]);
14 |
15 | app.config(['$routeProvider', '$locationProvider', function($routeProvider, $locationProvider) {
16 | $routeProvider.when('/v1/quests/:questId?', {
17 | templateUrl: '/templates/questStatus.html',
18 | reloadOnSearch: false
19 | }).when('/v1/quest/new', {
20 | templateUrl: '/templates/questCreation.html',
21 | reloadOnSearch: false
22 | }).when('/v1/quests/:questId/edit', {
23 | templateUrl: '/templates/questEdit.html',
24 | reloadOnSearch: false
25 | }).when('/v1/labors/:laborId?', {
26 | templateUrl: '/templates/laborList.html',
27 | reloadOnSearch: false
28 | }).when('/v1/fates', {
29 | templateUrl: '/templates/fateViewer.html',
30 | reloadOnSearch: false
31 | }).when('/home', {
32 | templateUrl: '/templates/userHome.html',
33 | reloadOnSearch: false
34 | }).otherwise({redirectTo: '/home/'});
35 |
36 | // use the HTML5 History API
37 | $locationProvider.html5Mode({
38 | enabled: true,
39 | requireBase: false
40 | });
41 | }]);
42 |
43 | })();
--------------------------------------------------------------------------------
/hermes/settings_client.py:
--------------------------------------------------------------------------------
1 | import yaml
2 |
3 |
4 | class Settings(object):
5 | def __init__(self, initial_settings):
6 | self.settings = initial_settings
7 |
8 | @classmethod
9 | def from_settings(cls, settings, initial_settings=None):
10 | _settings = {}
11 | _settings.update(settings.settings)
12 | if initial_settings:
13 | _settings.update(initial_settings)
14 | return cls(_settings)
15 |
16 | def update_from_config(self, filename):
17 | with open(filename) as config:
18 | data = yaml.safe_load(config.read())
19 |
20 | settings = {}
21 | settings.update(data)
22 |
23 | for key, value in settings.iteritems():
24 | key = key.lower()
25 |
26 | if key not in self.settings:
27 | continue
28 |
29 | override = getattr(self, "override_%s" % key, None)
30 | if override is not None and callable(override):
31 | value = override(value)
32 |
33 | self.settings[key] = value
34 |
35 | def __getitem__(self, key):
36 | return self.settings[key]
37 |
38 | def __getattr__(self, name):
39 | try:
40 | return self.settings[name]
41 | except KeyError as err:
42 | raise AttributeError(err)
43 |
44 |
45 | settings = Settings({
46 | "log_format": "%(asctime)-15s\t%(levelname)s\t%(message)s",
47 | "debug": False,
48 | "user_auth_header": "X-Hermes-Email",
49 | "hermes_server": "http://localhost:10901",
50 | "api_retries": 5
51 | })
52 |
--------------------------------------------------------------------------------
/hermes/routes.py:
--------------------------------------------------------------------------------
1 | from .handlers import frontends, api
2 | from tornado import web
3 | import os
4 |
5 | HANDLERS = [
6 | # Hosts
7 | (r"/api/v1/hosts\/?", api.HostsHandler),
8 | (r"/api/v1/hosts/(?P
3 |
4 |
5 |
6 |
29 |
7 |
12 |
17 |
13 | Loading
14 | Info 15 |
16 | 14 | Info 15 |
18 |
23 |
28 |
24 | Loading
25 | Info 26 |
27 | 25 | Info 26 |
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
--------------------------------------------------------------------------------
/tests/model_tests/test_host.py:
--------------------------------------------------------------------------------
1 | import pytest
2 | from sqlalchemy.exc import IntegrityError
3 |
4 | from hermes import exc
5 | from hermes.models import Host, EventType, Labor, Event
6 |
7 | from .fixtures import db_engine, session, sample_data1
8 |
9 |
10 | def test_creation(session):
11 | Host.create(session, "abc-123")
12 | session.commit()
13 |
14 | hosts = session.query(Host).all()
15 |
16 | assert len(hosts) == 1
17 | assert hosts[0].id == 1
18 | assert hosts[0].hostname == "abc-123"
19 |
20 | host = Host.get_host(session, "abc-123")
21 | assert host.id == 1
22 | assert host.hostname == "abc-123"
23 |
24 |
25 | def test_duplicate(session):
26 | Host.create(session, "abc-123")
27 |
28 | with pytest.raises(IntegrityError):
29 | Host.create(session, "abc-123")
30 |
31 | Host.create(session, "abc-456")
32 |
33 |
34 | def test_required(session):
35 | Host.create(session, "abc-123")
36 |
37 | with pytest.raises(exc.ValidationError):
38 | Host.create(session, None)
39 |
40 |
41 | def test_get_latest_events(sample_data1):
42 | host = Host.get_host(sample_data1, "example.dropbox.com")
43 | assert host.id == 1
44 | assert host.hostname == "example.dropbox.com"
45 |
46 | events = host.get_latest_events().all()
47 |
48 | assert len(events) == 2
49 | assert events[0].note == "example.dropbox.com rebooted."
50 |
51 |
52 | def test_get_labors(sample_data1):
53 | host = Host.get_host(sample_data1, "example.dropbox.com")
54 | assert host.id == 1
55 | assert len(host.labors) == 0
56 |
57 | event_type1 = sample_data1.query(EventType).get(1)
58 | event_type3 = sample_data1.query(EventType).get(3)
59 | event_type4 = sample_data1.query(EventType).get(4)
60 |
61 | print "Creating event1"
62 | Event.create(sample_data1, host, "testman", event_type1)
63 |
64 | print "Creating event2"
65 | Event.create(sample_data1, host, "testman", event_type3)
66 |
67 | print "Creating event3"
68 | closing_event = Event.create(sample_data1, host, "testman", event_type4)
69 |
70 | print "Get labor info"
71 | all_labors = host.get_labors().all()
72 | open_labors = host.get_open_labors().all()
73 |
74 | assert len(all_labors) == 3
75 | assert len(host.labors) == 3
76 | assert len(open_labors) == 1
77 |
78 | assert all_labors[0].completion_time is None
79 | assert all_labors[0].completion_event is None
80 | assert all_labors[1].completion_time is not None
81 | assert all_labors[1].completion_event == closing_event
82 | assert all_labors[0].creation_event == closing_event
83 |
84 |
85 |
--------------------------------------------------------------------------------
/tests/model_tests/test_eventtypes.py:
--------------------------------------------------------------------------------
1 | import pytest
2 | from sqlalchemy.exc import IntegrityError
3 |
4 | from hermes import exc
5 | from hermes.models import EventType, Host, Event
6 |
7 | from .fixtures import db_engine, session, sample_data1
8 |
9 |
10 | def test_creation(session):
11 | EventType.create(session, "foo", "bar", "This is a test")
12 | session.commit()
13 |
14 | event_types = session.query(EventType).all()
15 |
16 | assert len(event_types) == 1
17 | assert event_types[0].id == 1
18 | assert event_types[0].category == "foo"
19 | assert event_types[0].state == "bar"
20 | assert event_types[0].description == "This is a test"
21 |
22 | event_type = EventType.get_event_type(session, "foo", "bar")
23 | assert event_type.id == 1
24 | assert event_type.category == "foo"
25 | assert event_type.state == "bar"
26 | assert event_type.description == "This is a test"
27 |
28 | assert event_type.href('/test') == '/test/eventtypes/1'
29 |
30 |
31 | def test_duplicate(session):
32 | EventType.create(session, "foo", "bar", "This is a test")
33 |
34 | with pytest.raises(IntegrityError):
35 | EventType.create(session, "foo", "bar", "Desc ignored")
36 |
37 | EventType.create(session, "foo", "bar2", "This is second test")
38 | EventType.create(session, "foo2", "bar", "This is second test")
39 |
40 |
41 | def test_required(session):
42 | EventType.create(session, "foo", "bar", "This is a test")
43 | EventType.create(session, "foo", "bar2")
44 |
45 | with pytest.raises(exc.ValidationError):
46 | EventType.create(session, "foo", None)
47 |
48 | with pytest.raises(exc.ValidationError):
49 | EventType.create(session, None, "bar")
50 |
51 |
52 | def test_get_latest_events(session):
53 | event_type1 = EventType.create(session, "foo", "bar", "test type 1")
54 | event_type2 = EventType.create(session, "foo", "baz", "test type 2")
55 |
56 | host1 = Host.create(session, "server1")
57 | host2 = Host.create(session, "server2")
58 |
59 | Event.create(session, host1, "testman", event_type1)
60 | Event.create(session, host1, "testman", event_type2)
61 | Event.create(session, host2, "testman", event_type1)
62 | Event.create(session, host1, "testman", event_type1)
63 | Event.create(session, host1, "testman", event_type2)
64 | last_type2 = Event.create(session, host2, "testman", event_type2)
65 | last_type1 = Event.create(session, host2, "testman", event_type1)
66 |
67 | events1 = event_type1.get_latest_events().all()
68 | events2 = event_type2.get_latest_events().all()
69 |
70 | assert len(events1) == 4
71 | assert len(events2) == 3
72 |
73 | assert events1[0] == last_type1
74 | assert events2[0] == last_type2
75 |
76 |
--------------------------------------------------------------------------------
/db/update_to_051.sql:
--------------------------------------------------------------------------------
1 | SET foreign_key_checks=0;
2 | DROP TABLE IF EXISTS event_types;
3 |
4 | CREATE TABLE event_types (
5 | id int(11) NOT NULL AUTO_INCREMENT,
6 | category varchar(64) COLLATE utf8_unicode_ci NOT NULL,
7 | state varchar(32) COLLATE utf8_unicode_ci NOT NULL,
8 | description varchar(1024) COLLATE utf8_unicode_ci DEFAULT NULL,
9 | PRIMARY KEY (id),
10 | UNIQUE KEY _category_state_uc (category,state),
11 | KEY event_type_idx (id,category,state)
12 | ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
13 |
14 | LOCK TABLES event_types WRITE;
15 | /*!40000 ALTER TABLE event_types DISABLE KEYS */;
16 |
17 | INSERT INTO event_types (id, category, state, description)
18 | VALUES
19 | (1,'system-reboot','required','System requires a reboot'),
20 | (2,'system-reboot','completed','System rebooted'),
21 | (3,'system-maintenance','required','System requires maintenance'),
22 | (4,'system-maintenance','ready','System ready for maintenance'),
23 | (5,'system-maintenance','completed','System maintenance completed'),
24 | (6,'system-maintenance','acknowledge','Acknowledge system maintenance'),
25 | (7,'system-maintenance','cancel','Cancel system maintenance');
26 |
27 | /*!40000 ALTER TABLE event_types ENABLE KEYS */;
28 | UNLOCK TABLES;
29 |
30 |
31 | # Dump of table fates
32 | # ------------------------------------------------------------
33 |
34 | DROP TABLE IF EXISTS fates;
35 |
36 | CREATE TABLE fates (
37 | id int(11) NOT NULL AUTO_INCREMENT,
38 | creation_type_id int(11) NOT NULL,
39 | follows_id int(11) DEFAULT NULL,
40 | for_creator int(1) NOT NULL DEFAULT '0',
41 | for_owner int(1) NOT NULL DEFAULT '1',
42 | description varchar(2048) COLLATE utf8_unicode_ci DEFAULT NULL,
43 | PRIMARY KEY (id),
44 | UNIQUE KEY _creation_completion_uc (creation_type_id,follows_id),
45 | KEY ix_fates_creation_type_id (creation_type_id),
46 | KEY fate_idx (id,creation_type_id,follows_id),
47 | KEY ix_fates_follows_id (follows_id),
48 | CONSTRAINT fates_ibfk_1 FOREIGN KEY (creation_type_id) REFERENCES event_types (id),
49 | CONSTRAINT fates_ibfk_3 FOREIGN KEY (follows_id) REFERENCES fates (id)
50 | ) ENGINE=InnoDB DEFAULT CHARSET=utf8 COLLATE=utf8_unicode_ci;
51 |
52 | LOCK TABLES fates WRITE;
53 | /*!40000 ALTER TABLE fates DISABLE KEYS */;
54 |
55 | INSERT INTO fates (id, creation_type_id, follows_id, for_creator, for_owner, description)
56 | VALUES
57 | (1,1,NULL,0,1,'Reboot or release the system'),
58 | (2,2,1,0,1,'System rebooted'),
59 | (3,3,NULL,0,1,'Release or acknowledge downtime'),
60 | (4,4,3,1,0,'Perform maintenance'),
61 | (5,5,4,1,0,'Maintenance completed'),
62 | (6,6,3,1,0,'Perform online maintenance'),
63 | (7,5,6,1,0,'Maintenance completed'),
64 | (8,7,3,1,0,'Maintenance cancelled'),
65 | (9,7,4,1,0,'Maintenance cancelled'),
66 | (10,7,6,1,0,'Maintenance cancelled');
67 |
68 | /*!40000 ALTER TABLE fates ENABLE KEYS */;
69 | UNLOCK TABLES;
70 | SET foreign_key_checks=1;
--------------------------------------------------------------------------------
/tests/model_tests/test_events.py:
--------------------------------------------------------------------------------
1 | import pytest
2 | from sqlalchemy.exc import IntegrityError
3 |
4 | from hermes import exc
5 | from hermes import models
6 |
7 | from .fixtures import db_engine, session, sample_data1
8 |
9 |
10 | def test_creation(sample_data1):
11 | event_types = sample_data1.query(models.EventType).all()
12 | assert len(event_types) == 7
13 | event_type1 = event_types[0]
14 | assert len(event_type1.events) == 1
15 |
16 | hosts = sample_data1.query(models.Host).all()
17 | assert len(hosts) == 3
18 | host = hosts[0]
19 | assert len(host.events) == 2
20 |
21 | models.Event.create(
22 | sample_data1, host, "testman", event_type1, note="This is a test event"
23 | )
24 | sample_data1.commit()
25 |
26 | events = sample_data1.query(models.Event).all()
27 |
28 | # the total number of events should be 3 now. We care about the new one
29 | assert len(events) == 3
30 | event = events[2]
31 | assert event.id == 3
32 | assert event.host == host
33 | assert event.user == "testman"
34 | assert event.event_type == event_type1
35 | assert event.note == "This is a test event"
36 |
37 | assert len(host.events) == 3
38 | assert len(event_type1.events) == 2
39 |
40 |
41 | def test_duplicate(sample_data1):
42 | """Test to ensure duplicate events are fine b/c there can be multiple identical events"""
43 | event_types = sample_data1.query(models.EventType).all()
44 | assert len(event_types) == 7
45 | event_type1 = event_types[0]
46 |
47 | hosts = sample_data1.query(models.Host).all()
48 | assert len(hosts) == 3
49 | host = hosts[0]
50 |
51 | models.Event.create(
52 | sample_data1, host, "testman", event_type1, note="This is a test event"
53 | )
54 | sample_data1.commit()
55 |
56 | models.Event.create(
57 | sample_data1, host, "testman", event_type1, note="This is another test event"
58 | )
59 | sample_data1.commit()
60 |
61 |
62 | def test_very_large_note(sample_data1):
63 | """Test to ensure notes can be larger than 1024 bytes."""
64 | event_types = sample_data1.query(models.EventType).all()
65 | assert len(event_types) == 7
66 | event_type1 = event_types[0]
67 |
68 | hosts = sample_data1.query(models.Host).all()
69 | assert len(hosts) == 3
70 | host = hosts[0]
71 |
72 | very_large_note = "x" * 60000
73 | models.Event.create(
74 | sample_data1, host, "testman", event_type1, note=very_large_note
75 | )
76 | sample_data1.commit()
77 |
78 | events = sample_data1.query(models.Event).all()
79 |
80 | # the total number of events should be 3 now. We care about the new one
81 | assert len(events) == 3
82 | event = events[2]
83 | assert event.id == 3
84 | assert event.host == host
85 | assert event.user == "testman"
86 | assert event.event_type == event_type1
87 | assert event.note == very_large_note
--------------------------------------------------------------------------------
/tests/model_tests/test_fates.py:
--------------------------------------------------------------------------------
1 | import pytest
2 | from sqlalchemy.exc import IntegrityError
3 |
4 | from hermes import exc
5 | from hermes.models import Fate, EventType
6 |
7 | from .fixtures import db_engine, session, sample_data1
8 |
9 |
10 | def test_creation(sample_data1):
11 | event_types = sample_data1.query(EventType).all()
12 | fates = sample_data1.query(Fate).all()
13 | assert len(event_types) == 7
14 | assert len(fates) == 6
15 |
16 | event_type6 = event_types[5]
17 | event_type7 = event_types[6]
18 |
19 | Fate.create(
20 | sample_data1, event_type6, description="New fate"
21 | )
22 | Fate.create(
23 | sample_data1, event_type7, follows_id=7, description="New fate"
24 | )
25 | sample_data1.commit()
26 |
27 | fates = sample_data1.query(Fate).all()
28 |
29 | # the total number of fates should be 8 now. We care about the new one
30 | assert len(fates) == 8
31 | fate = fates[6]
32 | assert fate.id == 7
33 | assert fate.creation_event_type == event_type6
34 | assert fate.description == "New fate"
35 | assert fate.for_creator is False
36 | assert fate.for_owner is True
37 |
38 | assert len(event_type6.auto_creates) == 1
39 | assert event_type6.auto_creates[0] == fate
40 |
41 | assert len(event_type7.auto_creates) == 1
42 | assert event_type7.auto_creates[0] == fates[7]
43 |
44 |
45 | def test_creation2(sample_data1):
46 | event_types = sample_data1.query(EventType).all()
47 | fates = sample_data1.query(Fate).all()
48 | assert len(event_types) == 7
49 | assert len(fates) == 6
50 |
51 | event_type6 = event_types[5]
52 | event_type7 = event_types[6]
53 |
54 | Fate.create(
55 | sample_data1, event_type6, for_creator=True,
56 | for_owner=False, description="New fate"
57 | )
58 | Fate.create(
59 | sample_data1, event_type7, follows_id=7, description="New fate"
60 | )
61 | sample_data1.commit()
62 |
63 | fates = sample_data1.query(Fate).all()
64 |
65 | # the total number of fates should be 8 now. We care about the new one
66 | assert len(fates) == 8
67 | fate = fates[6]
68 | assert fate.id == 7
69 | assert fate.creation_event_type == event_type6
70 | assert fate.description == "New fate"
71 | assert fate.for_creator is True
72 | assert fate.for_owner is False
73 |
74 | assert len(event_type6.auto_creates) == 1
75 | assert event_type6.auto_creates[0] == fate
76 |
77 | assert len(event_type7.auto_creates) == 1
78 | assert event_type7.auto_creates[0] == fates[7]
79 |
80 |
81 | def test_designation_constraint(sample_data1):
82 | """Fates must be set to for_owner or for_creator or both"""
83 |
84 | event_type1 = sample_data1.query(EventType).get(1)
85 |
86 | with pytest.raises(exc.ValidationError):
87 | Fate.create(
88 | sample_data1, event_type1, description="Wrong fate",
89 | for_creator=False, for_owner=False, follows_id=2
90 | )
91 |
92 |
93 | def test_follows_id_valid(sample_data1):
94 | event_type1 = sample_data1.query(EventType).get(1)
95 |
96 | # There is no Fate 20
97 | with pytest.raises(exc.ValidationError):
98 | Fate.create(
99 | sample_data1, event_type1, description="Coolio",
100 | follows_id=20
101 | )
--------------------------------------------------------------------------------
/tests/api_tests/test_hosts.py:
--------------------------------------------------------------------------------
1 | import json
2 | import pytest
3 | import requests
4 |
5 | from .fixtures import tornado_server, tornado_app
6 | from .util import (
7 | assert_error, assert_success, assert_created, assert_deleted, Client
8 | )
9 |
10 |
11 | def test_malformed(tornado_server):
12 | client = Client(tornado_server)
13 | assert_error(client.post("/hosts", data="Non-JSON"), 400)
14 |
15 |
16 | def test_creation(tornado_server):
17 | client = Client(tornado_server)
18 | assert_success(client.get("/hosts"), {
19 | "hosts": [],
20 | "limit": 10,
21 | "offset": 0,
22 | "totalHosts": 0,
23 | })
24 |
25 | assert_created(
26 | client.create("/hosts", hostname="example"), "/api/v1/hosts/example"
27 | )
28 | assert_error(client.create("/hosts", hostname="example"), 409)
29 |
30 | assert_success(
31 | client.get("/hosts"),
32 | {
33 | "hosts": [{
34 | "id": 1,
35 | "hostname": "example"
36 | }],
37 | "limit": 10,
38 | "offset": 0,
39 | "totalHosts": 1,
40 | }
41 | )
42 |
43 | assert_success(
44 | client.get("/hosts/example"),
45 | {
46 | "id": 1,
47 | "hostname": "example",
48 | "events": [],
49 | "labors": [],
50 | "quests": [],
51 | "lastEvent": None,
52 | "limit": 10,
53 | "offset": 0,
54 | }
55 | )
56 |
57 | assert_created(client.create("/hosts", hostname="sample"), "/api/v1/hosts/sample")
58 | assert_success(
59 | client.get("/hosts", params={"hostname": "sample"}),
60 | {
61 | "hosts": [{
62 | "id": 2,
63 | "hostname": "sample"
64 | }],
65 | "limit": 10,
66 | "offset": 0,
67 | "totalHosts": 1
68 | }
69 | )
70 |
71 | def test_create_multiple(tornado_server):
72 | client = Client(tornado_server)
73 | assert_success(client.get("/hosts"), {
74 | "hosts": [],
75 | "limit": 10,
76 | "offset": 0,
77 | "totalHosts": 0,
78 | })
79 |
80 | client.create(
81 | "/hosts",
82 | hosts=[
83 | {"hostname":"example"},
84 | {"hostname":"sample"},
85 | {"hostname":"test"}
86 | ]
87 | )
88 |
89 | assert_success(client.get("/hosts"), {
90 | "limit": 10,
91 | "offset": 0,
92 | "totalHosts": 3,
93 | }, strip="hosts")
94 |
95 |
96 | def test_update(tornado_server):
97 | client = Client(tornado_server)
98 |
99 | client.create("/hosts", hostname="testname")
100 |
101 | assert_success(
102 | client.update("/hosts/testname", hostname="newname"),
103 | {
104 | "id": 1,
105 | "hostname": "newname"
106 | }
107 | )
108 |
109 | # test failure of empty update calls
110 | assert_error(client.update("/hosts/newname"), 400)
111 |
112 |
113 | def test_merging(tornado_server):
114 | """When renaming a server to an existing servername, just merge them"""
115 | client = Client(tornado_server)
116 |
117 | client.create("/hosts", hostname="testname")
118 | client.create("/hosts", hostname="newname")
119 |
120 | assert_success(
121 | client.update("/hosts/testname", hostname="newname"),
122 | {
123 | "id": 2,
124 | "hostname": "newname"
125 | }
126 | )
--------------------------------------------------------------------------------
/docs/intro.rst:
--------------------------------------------------------------------------------
1 | Introduction
2 | ============
3 |
4 | Hermes logs events, generates tasks, and tracks tasks in logical groups.
5 |
6 | Terminology
7 | ===========
8 |
9 | Rather than mimic the overloaded and overused terminology typically used, and in keeping with the Dropbox principal of "cupcake," Hermes adopts a more interesting language.
10 |
11 | Events and Event Types
12 | ----------------------
13 |
14 | Events double as journal entries, logging system activities like server restarts, and requests for action, such as a need to restart or turn off a server.
15 |
16 | As journal entries, events provide an audit trail and can potentially be used to track a range of activities. As request entries, events can initialize labors and subsequent events would close these labors.
17 |
18 | Each event must be of a predefined event type. An event type consists of a category and state, the combination of which provides meaningful grouping and definition:
19 | ::
20 | ID CATEGORY STATE
21 | [1] system-reboot required
22 | [2] system-reboot completed
23 | [3] system-maintenance required
24 | [4] system-maintenance ready
25 | [5] system-maintenance completed
26 |
27 |
28 | Event types are often written simply as ``category-state``, such as ``system-reboot-required``.
29 |
30 | An individual event entry consists of the event type, the host, and the time of occurrence.
31 |
32 | Labors
33 | ------
34 |
35 | Labors represent tasks that need to be performed or outstanding issues that need to be addressed for a host. All labors are created and closed as the result of events.
36 |
37 | Labors are usually referred to by the event which triggered its creation, so a ``system-reboot-required`` event creates a ``system-reboot-required`` labor.
38 |
39 | Fates
40 | -----
41 | Basics
42 | ``````
43 | The fates define how labors are created and completed. A typical fate will specify which event type will result in the creation of a labor for the host, and which event type will close labors for a host.
44 | ::
45 | [1] system-reboot-required => system-reboot-completed
46 |
47 |
48 | Chained Fates
49 | `````````````
50 | An ``intermediate`` flag in the definition of a fate indicates if the fate only applies to existing labors. This allows fates to be chained together to essentially create a workflow engine.
51 |
52 | For example:
53 | ::
54 | [1] system-maintenance-required => system-maintenance-ready
55 | [2] system-maintenance-ready => system-maintenance-completed
56 |
57 |
58 | (with the second fate being flagged as an intermediate) would essentially mean:
59 | ::
60 | system-maintenance-required => system-maintenance-ready => system-maintenance-completed
61 |
62 | In this example, an event of type ``system-maintenance-ready`` only creates a labor if an existing labor created by an event of type ``system-maintenance-required`` was present.
63 |
64 | Choose Your Own Adventure
65 | `````````````````````````
66 |
67 | Fates can allow multiple ways to resolve a labor.
68 | ::
69 | [1] puppet-restart-required => puppet-restart-completed
70 | [2] puppet-restart-required => system-restart-completed
71 |
72 | In this example, a labor created by the event ``puppet-restart-required`` can be completed by either a ``puppet-restart-completed`` event, or a ``system-restart-completed`` event.
73 |
74 | Quests
75 | ------
76 |
77 | Quests are collections of labors, making tracking and reporting of progress much easier.
78 |
79 | For example, when a security fix is released that requires all web servers to be restarted, a quest can be created with a ``system-restart-required`` labor for all the hosts.
80 |
81 | Quests will eventually contain information to outside references, such as Jira tickets.
82 |
83 | Status
84 | ======
85 |
86 | Development can be tracked at GitHub_ and Travis_CI_
87 |
88 | .. _GitHub: https://github.com/dropbox/hermes
89 | .. _Travis_CI: https://travis-ci.org/dropbox/hermes
90 |
91 | TODOS
92 | =====
93 |
94 | Deletion Support
95 | ----------------
96 |
97 | Currently, nothing can be deleted through the API or client. It would be nice to be able to delete event-types and
98 | fates.
99 |
--------------------------------------------------------------------------------
/bin/hermes-server:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import argparse
4 | import logging
5 | import os
6 | import tornado.ioloop
7 | import tornado.httpserver
8 | import tornado.web
9 |
10 | import hermes
11 | from hermes import version
12 | from hermes.app import Application
13 | from hermes.settings import settings
14 | from hermes.plugin import get_hooks
15 | from hermes import models
16 |
17 |
18 | from sqlalchemy.exc import OperationalError
19 |
20 | try:
21 | from raven.contrib.tornado import AsyncSentryClient
22 | raven_installed = True
23 | except ImportError:
24 | raven_installed = False
25 |
26 | sa_log = logging.getLogger("sqlalchemy.engine.base.Engine")
27 |
28 |
29 | def parse_args():
30 | parser = argparse.ArgumentParser(description="Hermes Web Service")
31 | parser.add_argument("-c", "--config", default="/etc/hermes/server.yaml",
32 | help="Path to config file.")
33 | parser.add_argument(
34 | "-v", "--verbose", action="count", default=0,
35 | help="Increase logging verbosity."
36 | )
37 | parser.add_argument(
38 | "-q", "--quiet", action="count", default=0,
39 | help="Decrease logging verbosity."
40 | )
41 | parser.add_argument(
42 | "-V", "--version", action="version",
43 | version="%%(prog)s %s" % hermes.__version__,
44 | help="Display version information."
45 | )
46 | parser.add_argument(
47 | "-p", "--port", type=int, default=None, help="Override port in config."
48 | )
49 | return parser.parse_args()
50 |
51 |
52 | def main():
53 |
54 | args = parse_args()
55 | settings.update_from_config(args.config)
56 |
57 | if args.verbose:
58 | logging.basicConfig(level=logging.DEBUG, format=settings.log_format)
59 | elif args.quiet:
60 | logging.basicConfig(level=logging.ERROR, format=settings.log_format)
61 | else:
62 | logging.basicConfig(level=logging.INFO, format=settings.log_format)
63 |
64 | tornado_settings = {
65 | "static_path": os.path.join(os.path.dirname(hermes.__file__), "static"),
66 | "debug": settings.debug,
67 | "xsrf_cookies": False,
68 | "cookie_secret": settings.secret_key,
69 | }
70 |
71 | # load and register any hooks we have
72 | # hooks = get_hooks([settings.plugin_dir])
73 | # for hook in hooks:
74 | # logging.debug("registering hook {}".format(hook))
75 | # models.register_hook(hook)
76 |
77 | my_settings = {
78 | "db_uri": settings.database,
79 | "db_engine": None,
80 | "db_session": None,
81 | "domain": settings.domain,
82 | "count_events": settings.count_events,
83 | }
84 |
85 | application = Application(my_settings=my_settings, **tornado_settings)
86 |
87 | logging.info("HERMES SERVER v{}".format(version.__version__))
88 |
89 | # If Sentry DSN is set, try to import raven
90 | if settings.sentry_dsn:
91 | if not raven_installed:
92 | logging.warning(
93 | 'Sentry DSN set but raven not installed. Not enabling Sentry.'
94 | )
95 | else:
96 | logging.info(
97 | 'Sentry DSN set and raven installed. Enabling Sentry.'
98 | )
99 | application.sentry_client = AsyncSentryClient(settings.sentry_dsn)
100 | else:
101 | logging.info('Sentry DSN not set. Not enabling Sentry.')
102 |
103 | port = args.port or settings.port
104 |
105 | logging.info(
106 | "Starting application server with %d processes on port %d",
107 | settings.num_processes, port
108 | )
109 |
110 | server = tornado.httpserver.HTTPServer(application)
111 | server.bind(port, address=settings.bind_address)
112 | server.start(settings.num_processes)
113 | try:
114 | tornado.ioloop.IOLoop.instance().start()
115 | except KeyboardInterrupt:
116 | tornado.ioloop.IOLoop.instance().stop()
117 | finally:
118 | print "Bye"
119 |
120 |
121 | if __name__ == "__main__":
122 | main()
123 |
--------------------------------------------------------------------------------
/tests/api_tests/fixtures.py:
--------------------------------------------------------------------------------
1 | import base64
2 | import json
3 | import logging
4 | import os
5 | import pytest
6 | import requests
7 | import socket
8 | import threading
9 | import tornado
10 | import tornado.httpserver
11 | import tornado.ioloop
12 | from tornado import netutil
13 |
14 | import hermes
15 | from hermes import models
16 | from hermes.models import Model, Session, Host, EventType, Event, Fate, Labor, Quest
17 | from hermes.settings import settings
18 | from hermes.app import Application
19 | from .util import load_json, Client
20 |
21 |
22 | sa_log = logging.getLogger("sqlalchemy.engine.base.Engine")
23 |
24 | # Uncomment to have all queries printed out
25 | # sa_log.setLevel(logging.INFO)
26 |
27 |
28 | class Server(object):
29 | """ Wrapper around Tornado server with test helpers. """
30 |
31 | def __init__(self, tornado_app):
32 | self.tornado_app = tornado_app
33 | self.server = tornado.httpserver.HTTPServer(
34 | tornado_app
35 | )
36 | self.server.add_sockets(netutil.bind_sockets(
37 | None, "localhost", family=socket.AF_INET
38 | ))
39 | self.server.start()
40 | self.io_thread = threading.Thread(
41 | target=tornado.ioloop.IOLoop.instance().start
42 | )
43 | self.io_thread.start()
44 |
45 | @property
46 | def port(self):
47 | return self.server._sockets.values()[0].getsockname()[1]
48 |
49 |
50 | @pytest.fixture()
51 | def tornado_app(request, tmpdir):
52 | db_path = tmpdir.join("nsot.sqlite")
53 | db_engine = models.get_db_engine("sqlite:///%s" % db_path)
54 |
55 | Model.metadata.drop_all(db_engine)
56 | Model.metadata.create_all(db_engine)
57 | Session.configure(bind=db_engine)
58 |
59 | Fate._all_fates = None
60 |
61 | my_settings = {
62 | "db_engine": db_engine,
63 | "db_session": Session,
64 | "domain": "example.com"
65 | }
66 |
67 | tornado_settings = {
68 | "debug": False,
69 | }
70 |
71 | return Application(my_settings=my_settings, **tornado_settings)
72 |
73 |
74 | @pytest.fixture()
75 | def tornado_server(request, tornado_app):
76 |
77 | server = Server(tornado_app)
78 |
79 | def fin():
80 | tornado.ioloop.IOLoop.instance().stop()
81 | server.io_thread.join()
82 | request.addfinalizer(fin)
83 |
84 | return server
85 |
86 |
87 | @pytest.fixture
88 | def session(request, tmpdir):
89 | db_path = tmpdir.join("nsot.sqlite")
90 | db_engine = models.get_db_engine("sqlite:///%s" % db_path)
91 |
92 | Model.metadata.drop_all(db_engine)
93 | Model.metadata.create_all(db_engine)
94 | Session.configure(bind=db_engine)
95 | session = Session()
96 |
97 | def fin():
98 | session.close()
99 | request.addfinalizer(fin)
100 |
101 | return session
102 |
103 | @pytest.fixture
104 | def sample_data1_server(tornado_server):
105 | client = Client(tornado_server)
106 | hosts_data = load_json("set1/hosts.json")
107 | client.create("/hosts/", hosts=hosts_data["hosts"])
108 |
109 | event_types_data = load_json("set1/eventtypes.json")
110 | client.create("/eventtypes/", eventTypes=event_types_data["eventTypes"])
111 |
112 | events = load_json("set1/event.json")
113 | client.post("/events/", json=events["event1"])
114 | client.post("/events/", json=events['event2'])
115 |
116 | fates = load_json("set1/fates.json")
117 | client.post("/fates/", json=fates["fate1"])
118 | client.post("/fates/", json=fates["fate2"])
119 | client.post("/fates/", json=fates["fate3"])
120 | client.post("/fates/", json=fates["fate4"])
121 | client.post("/fates/", json=fates["fate5"])
122 |
123 | return client
124 |
125 |
126 | @pytest.fixture
127 | def sample_data2_server(tornado_server):
128 | client = Client(tornado_server)
129 | hosts_data = load_json("set1/hosts.json")
130 | client.create("/hosts/", hosts=hosts_data["hosts"])
131 |
132 | event_types_data = load_json("set1/eventtypes.json")
133 | client.create("/eventtypes/", eventTypes=event_types_data["eventTypes"])
134 |
135 | events = load_json("set1/event.json")
136 | for x in range(1, len(events) + 1):
137 | client.post("/events/", json=events["event{}".format(x)])
138 |
139 | fates = load_json("set1/fates.json")
140 | client.post("/fates/", json=fates["fate1"])
141 | client.post("/fates/", json=fates["fate2"])
142 | client.post("/fates/", json=fates["fate3"])
143 | client.post("/fates/", json=fates["fate4"])
144 | client.post("/fates/", json=fates["fate5"])
145 |
146 | return client
--------------------------------------------------------------------------------
/hermes/webapp/src/js/controllers/userHomeCtrl.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | 'use strict';
3 |
4 | function UserHomeCtrl(hermesService, $q, $routeParams, $location, smoothScroll) {
5 | var vm = this;
6 |
7 | vm.errorMessage = null;
8 |
9 | vm.domain = null;
10 | vm.user = null;
11 | vm.questData = null;
12 | vm.totalQuests = null;
13 | vm.totalUserCreatedQuests = null;
14 | vm.totalLabors = null;
15 | vm.totalUserLabors = null;
16 |
17 | vm.questsUrl = null;
18 | vm.laborsUrl = null;
19 |
20 | vm.goToQuestsPage = goToQuestsPage;
21 | vm.goToLaborsPage = goToLaborsPage;
22 |
23 | hermesService.getCurrentUser().then(function (user) {
24 | if (user) {
25 | vm.user = user;
26 | }
27 |
28 | // find labors and quests for this user
29 | getOpenQuests();
30 | getOpenLabors();
31 | });
32 |
33 | hermesService.getServerConfig().then(function(config) {
34 | vm.domain = config['domain'];
35 | });
36 |
37 | function goToCreatePage() {
38 | $location.url("/v1/quest/new");
39 | }
40 |
41 | function goToQuestsPage() {
42 | $location.url(vm.questsUrl);
43 | }
44 |
45 | function goToLaborsPage() {
46 | $location.url(vm.laborsUrl);
47 | }
48 |
49 | /**
50 | * Get open quest information, but we only want basic overview information.
51 | */
52 | function getOpenQuests() {
53 | vm.errorMessage = null;
54 |
55 | var options = {};
56 | options['overviewOnly'] = true;
57 |
58 | hermesService.getOpenQuests(options).then(function (questData) {
59 | vm.questData = questData['quests'];
60 | vm.totalQuests = questData['totalQuests'];
61 |
62 | // see which quests are overdue and which are owned by this user
63 | vm.totalUserCreatedQuests = 0;
64 | for (var idx in vm.questData) {
65 | evalDueDate(vm.questData[idx]);
66 | if (vm.questData[idx]['creator'] == vm.user) {
67 | vm.totalUserCreatedQuests++;
68 | }
69 | }
70 |
71 | if (vm.totalUserCreatedQuests == 0) {
72 | vm.questsUrl = "/v1/quests/?byCreator=";
73 | } else {
74 | vm.questsUrl = "/v1/quests?byCreator=" + vm.user;
75 | }
76 | });
77 | }
78 |
79 | /**
80 | * Get labor information (overview only) for all open labors and labors
81 | * that apply to this user.
82 | */
83 | function getOpenLabors() {
84 | var options = {};
85 | options['overviewOnly'] = true;
86 |
87 | hermesService.getOpenLabors(options).then(function (laborData){
88 | vm.totalLabors = laborData['totalLabors'];
89 | });
90 |
91 | options['filterByOwner'] = vm.user;
92 |
93 | hermesService.getOpenLabors(options).then(function (laborData) {
94 | vm.totalUserLabors = laborData['totalLabors'];
95 | vm.laborsUrl = "/v1/labors?byOwner=" + vm.user;
96 | }).catch(function(error) {
97 | vm.totalUserLabors = 0;
98 | vm.laborsUrl = "/v1/labors?byOwner=";
99 | });
100 | }
101 |
102 | /**
103 | * Determine if the quest is overdue and add a property to indicate
104 | * @param quest the quest to analyze
105 | */
106 | function evalDueDate(quest) {
107 | if (quest.targetTime) {
108 | var dateRegex = /(\d{4})-(\d{2})-(\d{2}) (\d{2}):(\d{2}):(\d{2})/;
109 | var dateArray = dateRegex.exec(quest.targetTime);
110 | var targetDate = new Date(
111 | (+dateArray[1]),
112 | (+dateArray[2]) - 1, // Careful, month starts at 0!
113 | (+dateArray[3]),
114 | (+dateArray[4]),
115 | (+dateArray[5]),
116 | (+dateArray[6])
117 | );
118 |
119 | if (targetDate - new Date() <= 0) quest.overDue = true;
120 | else quest.overDue = false;
121 | } else {
122 | quest.overDue = false;
123 | }
124 | }
125 | }
126 |
127 | angular.module('hermesApp').controller('UserHomeCtrl', UserHomeCtrl);
128 | UserHomeCtrl.$inject = ['HermesService', '$q', '$routeParams', '$location', 'smoothScroll'];
129 | })();
130 |
--------------------------------------------------------------------------------
/hermes/webapp/src/js/directives/questProgressBar.js:
--------------------------------------------------------------------------------
1 | /**
2 | * directive for building quest progress bars with Raphael
3 | */
4 | (function() {
5 | function questProgressBar ($timeout, $window) {
6 | return {
7 | restrict: 'A',
8 | scope: {
9 | data: '=',
10 | onClick: '&'
11 | },
12 | link: function ($scope, $ele, $attrs) {
13 | var renderTimeout;
14 | var lastData;
15 | var isVisible = true;
16 | var graphHeight = parseInt($attrs.graphHeight) || 30;
17 | var raphael = new Raphael($ele[0], "100%", graphHeight);
18 |
19 | $scope.$watch('data', function (newData) {
20 | lastData = [newData];
21 | $scope.render([newData]);
22 | }, true);
23 |
24 | $window.onresize = function () {
25 | $scope.$apply();
26 | };
27 |
28 | $scope.$watch(function () {
29 | return angular.element($window)[0].innerWidth;
30 | }, function () {
31 | $scope.render([$scope.data]);
32 | });
33 |
34 | $scope.render = function (data) {
35 | if (!data || !isVisible) return;
36 | if (renderTimeout) clearTimeout(renderTimeout);
37 |
38 | renderTimeout = $timeout(function () {
39 | var width = $ele[0].offsetWidth;
40 | var topPadding = graphHeight * .05;
41 | var barWidth = width;
42 | var barBaseLine = graphHeight * 1;
43 | var barHeight = graphHeight * .3;
44 | var percentXLoc = data[0].percentComplete * barWidth / 100;
45 |
46 | var colors = ['#7b8994','#3d464d'];
47 | var textColor = '#3d464d';
48 |
49 | if (data[0].overDue) {
50 | colors = ['#944D4D', '#6A1C0E'];
51 | textColor = '#6A1C0E';
52 | }
53 |
54 | // erase everything
55 | raphael.clear();
56 |
57 | // draw the full bar, which shows the full extent of the progress bar
58 | var fullBar = raphael.rect(
59 | 0, barBaseLine - barHeight,
60 | barWidth, barHeight
61 | );
62 | fullBar.attr({'fill': colors[0]});
63 | fullBar.attr({'stroke-width': 0});
64 |
65 | // color in the part to represent the percentage complete
66 | var percentBar = raphael.rect(
67 | 0, barBaseLine - barHeight,
68 | percentXLoc, barHeight
69 | );
70 | percentBar.attr({'fill': colors[1]});
71 | percentBar.attr({'stroke-width': 0});
72 |
73 | // draw the little line that points up to the percentage label
74 | var pathStr = "M" + percentXLoc + "," + (barBaseLine - (barHeight * 1.5))
75 | + " L" + percentXLoc + "," + barBaseLine;
76 | raphael.path(pathStr).attr({'stroke': colors[1]});
77 |
78 | // add the percentage amount text
79 | var label = raphael.text(
80 | width/2,
81 | (barBaseLine - (barHeight * 2)),
82 | data[0].percentComplete + "%"
83 | ).attr({
84 | 'font-size': barHeight,
85 | 'fill': textColor,
86 | 'font-family': "Titillium Web",
87 | });
88 |
89 | var bb = label.getBBox();
90 | var labelWidth = Math.abs(bb.x2) - Math.abs(bb.x) + 1;
91 | if (percentXLoc - (labelWidth / 2) <= 0) {
92 | label.attr({'x': labelWidth / 2});
93 | } else if (percentXLoc + (labelWidth / 2) >= barWidth) {
94 | label.attr({'x': barWidth - (labelWidth/2)});
95 | } else {
96 | label.attr({'x': percentXLoc});
97 | }
98 |
99 | }, 0);
100 | };
101 | }
102 | }
103 | }
104 |
105 | angular.module('hermesApp').directive('questProgressBar', questProgressBar);
106 | questProgressBar.$inject = ['$timeout', '$window'];
107 | })();
--------------------------------------------------------------------------------
/tests/api_tests/test_fates.py:
--------------------------------------------------------------------------------
1 | import json
2 | import pytest
3 | import requests
4 |
5 | from .fixtures import tornado_server, tornado_app, sample_data1_server
6 | from .util import (
7 | assert_error, assert_success, assert_created, assert_deleted, Client
8 | )
9 |
10 |
11 | def test_malformed(sample_data1_server):
12 | client = sample_data1_server
13 | assert_error(client.post("/fates", data="Non-JSON"), 400)
14 |
15 |
16 | def test_bad_creation(sample_data1_server):
17 | """Fate's must be either set to forOwner, forCreator, or both"""
18 | client = sample_data1_server
19 | assert_error(
20 | client.post(
21 | "/fates",
22 | data={
23 | "creationEventTypeId": 6,
24 | "forOwner": False,
25 | "forCreator": False,
26 | "precedesIds": [],
27 | "description":"New fate"
28 | }
29 | ),
30 | 400
31 | )
32 |
33 |
34 | def test_creation(sample_data1_server):
35 | client = sample_data1_server
36 | assert_success(
37 | client.get("/eventtypes"),
38 | {
39 | "limit": 10,
40 | "offset": 0,
41 | "totalEventTypes": 7,
42 | },
43 | strip="eventTypes"
44 | )
45 |
46 | assert_created(
47 | client.create(
48 | "/fates/",
49 | creationEventTypeId=6,
50 | description="New fate"
51 | ),
52 | "/api/v1/fates/6"
53 | )
54 |
55 | assert_created(
56 | client.create(
57 | "/fates/",
58 | creationEventTypeId=7,
59 | followsId=6,
60 | description="New fate2"
61 | ),
62 | "/api/v1/fates/7"
63 | )
64 |
65 | assert_success(
66 | client.get("/fates/6"),
67 | {
68 | "id": 6,
69 | "creationEventTypeId": 6,
70 | "followsId": None,
71 | "forOwner": True,
72 | "forCreator": False,
73 | "precedesIds": [7],
74 | "description": "New fate"
75 | }
76 | )
77 |
78 | assert_success(
79 | client.get("/fates/7"),
80 | {
81 | "id": 7,
82 | "creationEventTypeId": 7,
83 | "followsId": 6,
84 | "forOwner": True,
85 | "forCreator": False,
86 | "precedesIds": [],
87 | "description": "New fate2"
88 | }
89 | )
90 |
91 |
92 | def test_update(sample_data1_server):
93 | client = sample_data1_server
94 | assert_created(
95 | client.create(
96 | "/fates/",
97 | creationEventTypeId=6,
98 | description="New fate"
99 | ),
100 | "/api/v1/fates/6"
101 | )
102 |
103 | assert_success(
104 | client.get("/fates/6"),
105 | {
106 | "id": 6,
107 | "creationEventTypeId": 6,
108 | "followsId": None,
109 | "forOwner": True,
110 | "forCreator": False,
111 | "precedesIds": [],
112 | "description": "New fate"
113 | }
114 | )
115 |
116 | assert_success(
117 | client.update(
118 | "/fates/6",
119 | followsId=1
120 | ),
121 | {
122 | "id": 6,
123 | "creationEventTypeId": 6,
124 | "followsId": 1,
125 | "forOwner": True,
126 | "forCreator": False,
127 | "precedesIds": [],
128 | "description": "New fate"
129 | }
130 | )
131 |
132 | assert_success(
133 | client.update(
134 | "/fates/6",
135 | description="New desc"
136 | ),
137 | {
138 | "id": 6,
139 | "creationEventTypeId": 6,
140 | "followsId": 1,
141 | "forOwner": True,
142 | "forCreator": False,
143 | "precedesIds": [],
144 | "description": "New desc"
145 | }
146 | )
147 |
148 | assert_success(
149 | client.update(
150 | "/fates/6",
151 | followsId=None,
152 | description="Another desc"
153 | ),
154 | {
155 | "id": 6,
156 | "creationEventTypeId": 6,
157 | "followsId": None,
158 | "forOwner": True,
159 | "forCreator": False,
160 | "precedesIds": [],
161 | "description": "Another desc"
162 | }
163 | )
164 |
165 | assert_success(
166 | client.get("/fates/6"),
167 | {
168 | "id": 6,
169 | "creationEventTypeId": 6,
170 | "followsId": None,
171 | "forOwner": True,
172 | "forCreator": False,
173 | "precedesIds": [],
174 | "description": "Another desc"
175 | }
176 | )
177 |
178 |
--------------------------------------------------------------------------------
/hermes/webapp/src/js/controllers/questEditCtrl.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | 'use strict';
3 |
4 | function QuestEditCtrl(hermesService, $q, $routeParams, $location) {
5 | var vm = this;
6 |
7 | vm.user = null; // holds the current user; we should only let current owners update quests
8 | vm.today = new Date(); // used to restrict how far back the due date can be set
9 | vm.quest = null; // holds the retrieve quest details
10 |
11 | // new values that the user can edit
12 | vm.newCreator = null;
13 | vm.description = null;
14 | vm.targetDate = null;
15 |
16 | vm.editingCreator = false; // controls if we show the creator editing field
17 | vm.editingDate = false; // controls if we show the date picker
18 | vm.editingDesc = false; // controls if we show the desc edit field
19 |
20 | // various messaging fields
21 | vm.successMessage = null;
22 | vm.errorMessage = null;
23 |
24 | hermesService.getCurrentUser().then(function(user){
25 | if (user) {
26 | vm.user = user;
27 | } else {
28 | vm.errorMessages.push("Cannot create a new quest if not authenticated.");
29 | }
30 | });
31 |
32 | refreshQuestInfo();
33 |
34 | vm.calDateClasser = calDateClasser;
35 | vm.focus = focus;
36 | vm.saveCreator = saveCreator;
37 | vm.saveTargetTime = saveTargetTime;
38 | vm.saveDescription = saveDescription;
39 | vm.refreshQuestInfo = refreshQuestInfo;
40 |
41 | ////////////////////////////////
42 |
43 | function refreshQuestInfo() {
44 | hermesService.getQuestDetails($routeParams.questId).then(function(quest) {
45 | vm.quest = quest;
46 | vm.description = quest.description;
47 | vm.targetDate = new Date();
48 | //vm.targetDate.setDate(new Date(targetDate).getDate());
49 | vm.targetDate.setTime(Math.round(vm.targetDate.getTime() / 900000) * 900000);
50 | });
51 | }
52 |
53 | /**
54 | * Adds our classes to the date picker
55 | * @param date the date in question
56 | * @param mode the mode
57 | */
58 | function calDateClasser(date, mode) {
59 | return "date-picker";
60 | }
61 |
62 | /**
63 | * Helper to set focus and select the text
64 | * @param id the item that gets focus
65 | */
66 | function focus(id) {
67 | setTimeout(function() {
68 | document.getElementById(id).focus();
69 | document.getElementById(id).select();
70 | }, 10);
71 | }
72 |
73 | /**
74 | * Change the creator for a quest
75 | */
76 | function saveCreator() {
77 | hermesService.updateQuest(vm.quest.id, {"creator": vm.newCreator})
78 | .then(function(response) {
79 | vm.successMessage = "Updated creator to " + vm.newCreator;
80 | vm.newCreator = null;
81 | vm.editingCreator = false;
82 | vm.refreshQuestInfo();
83 | })
84 | .catch(function(error) {
85 | vm.errorMessage = "Error updating creator: " + error.statusText;
86 | })
87 | }
88 |
89 | /**
90 | * Change the target time for a quest
91 | */
92 | function saveTargetTime() {
93 | hermesService.updateQuest(vm.quest.id, {"targetTime": vm.targetDate})
94 | .then(function(response) {
95 | vm.successMessage = "Updated target time to " + vm.targetDate;
96 | vm.editingDate = false;
97 | vm.refreshQuestInfo();
98 | })
99 | .catch(function(error) {
100 | vm.errorMessage = "Error updating target time: " + error.statusText;
101 | })
102 | }
103 |
104 | /**
105 | * Change the description for a quest
106 | */
107 | function saveDescription() {
108 | hermesService.updateQuest(vm.quest.id, {"description": vm.description})
109 | .then(function(response) {
110 | vm.successMessage = "Updated description!";
111 | vm.editingDesc = false;
112 | vm.refreshQuestInfo();
113 | })
114 | .catch(function(error) {
115 | vm.errorMessage = "Error updating description: " + error.statusText;
116 | })
117 | }
118 |
119 | }
120 |
121 | angular.module('hermesApp').controller('QuestEditCtrl', QuestEditCtrl);
122 | QuestEditCtrl.$inject = ['HermesService', '$q', '$routeParams', '$location'];
123 | })();
124 |
--------------------------------------------------------------------------------
/tests/api_tests/test_eventtypes.py:
--------------------------------------------------------------------------------
1 | import json
2 | import pytest
3 | import requests
4 |
5 | from .fixtures import tornado_server, tornado_app, sample_data1_server
6 | from .util import (
7 | assert_error, assert_success, assert_created, assert_deleted, Client
8 | )
9 |
10 |
11 | def test_malformed(tornado_server):
12 | client = Client(tornado_server)
13 | assert_error(client.post("/eventtypes", data="Non-JSON"), 400)
14 |
15 |
16 | def test_creation(tornado_server):
17 | client = Client(tornado_server)
18 | assert_success(client.get("/eventtypes"), {
19 | "eventTypes": [],
20 | "limit": 10,
21 | "offset": 0,
22 | "totalEventTypes": 0,
23 | })
24 |
25 | assert_created(
26 | client.create(
27 | "/eventtypes",
28 | category="foo",
29 | state="bar",
30 | description="This is a test",
31 | ), "/api/v1/eventtypes/1"
32 | )
33 | assert_error(
34 | client.create(
35 | "/eventtypes",
36 | category="foo",
37 | state="bar",
38 | description="Reject duplicate"
39 | ), 409
40 | )
41 |
42 | assert_success(
43 | client.get("/eventtypes"),
44 | {
45 | "eventTypes": [{
46 | "id": 1,
47 | "category": "foo",
48 | "state": "bar",
49 | "description": "This is a test",
50 | "restricted": False,
51 | }],
52 | "limit": 10,
53 | "offset": 0,
54 | "totalEventTypes": 1,
55 | }
56 | )
57 |
58 | assert_success(
59 | client.get("/eventtypes/1"),
60 | {
61 | "id": 1,
62 | "category": "foo",
63 | "state": "bar",
64 | "description": "This is a test",
65 | "restricted": False,
66 | "events": [],
67 | "limit": 10,
68 | "offset": 0,
69 | }
70 | )
71 |
72 | assert_created(
73 | client.create(
74 | "/eventtypes",
75 | category="foo",
76 | state="baz",
77 | description="This is a second test"
78 | ), "/api/v1/eventtypes/2"
79 | )
80 | assert_success(
81 | client.get("/eventtypes?expand=fates",
82 | params={"category": "foo", "state": "baz"}),
83 | {
84 | "eventTypes": [{
85 | "id": 2,
86 | "category": "foo",
87 | "state": "baz",
88 | "description": "This is a second test",
89 | "restricted": False,
90 | "autoCreates": []
91 | }],
92 | "limit": 10,
93 | "offset": 0,
94 | "totalEventTypes": 1
95 | }
96 | )
97 |
98 |
99 | def test_create_multiple(tornado_server):
100 | client = Client(tornado_server)
101 | assert_success(client.get("/eventtypes"), {
102 | "eventTypes": [],
103 | "limit": 10,
104 | "offset": 0,
105 | "totalEventTypes": 0,
106 | })
107 |
108 | client.create(
109 | "/eventtypes",
110 | eventTypes=[
111 | {
112 | "category": "foo",
113 | "state": "bar",
114 | "description": "This is a test",
115 | "restricted": False,
116 | },
117 | {
118 | "category": "foo",
119 | "state": "baz",
120 | "description": "This is a 2nd test",
121 | "restricted": False,
122 | }
123 | ]
124 | )
125 |
126 | assert_success(client.get("/eventtypes"), {
127 | "limit": 10,
128 | "offset": 0,
129 | "totalEventTypes": 2,
130 | }, strip="eventTypes")
131 |
132 |
133 | def test_update(tornado_server):
134 | client = Client(tornado_server)
135 | assert_success(client.get("/eventtypes"), {
136 | "eventTypes": [],
137 | "limit": 10,
138 | "offset": 0,
139 | "totalEventTypes": 0,
140 | })
141 |
142 | assert_created(
143 | client.create(
144 | "/eventtypes",
145 | category="foo",
146 | state="bar",
147 | description="This is a test"
148 | ), "/api/v1/eventtypes/1"
149 | )
150 |
151 | assert_success(
152 | client.update("/eventtypes/1", description="new"),
153 | {
154 | "id": 1,
155 | "category": "foo",
156 | "state": "bar",
157 | "description": "new",
158 | "restricted": False,
159 | }
160 | )
161 |
162 | assert_error(client.update("/eventtypes/1"), 400)
163 |
164 |
165 | def test_filter_by_creating_types(sample_data1_server):
166 | client = sample_data1_server
167 |
168 | assert_success(
169 | client.get("/eventtypes?startingTypes=true"), {
170 | "limit": 10,
171 | "offset": 0,
172 | "totalEventTypes": 2
173 | }, strip=['eventTypes']
174 | )
175 |
--------------------------------------------------------------------------------
/gulpfile.js:
--------------------------------------------------------------------------------
1 | /**
2 | * Build tasks are broken up as either top-level tasks, for example `build`,
3 | * or sub-tasks, namespaced with a top-level task name and a color as a prefix,
4 | * for example, `build:js`
5 | *
6 | * You'll likely want to have gulp installed globally if you're using it regularly
7 | * though you'll be able to run it fron `node_modules/.bin/gulp` if you don't
8 | * use it often.
9 | *
10 | * Top Level Tasks
11 | * ---------------
12 | * gulp clean - Remove built assets
13 | * gulp build - Build all static assets for distribution
14 | * gulp lint - Lint JavaScript and CSS files
15 | * gulp bower - Update local cache for web dependencies
16 | */
17 |
18 | var gulp = require('gulp');
19 |
20 | // Plugin Imports
21 | var jshint = require('gulp-jshint');
22 | var concat = require('gulp-concat');
23 | var ngAnnotate = require('gulp-ng-annotate');
24 | var uglify = require('gulp-uglify');
25 | var rename = require('gulp-rename');
26 | var minifyCss = require('gulp-minify-css');
27 | var csslint = require('gulp-csslint');
28 | var mainBowerFiles = require('main-bower-files');
29 | var bower = require('gulp-bower');
30 | var sort = require('gulp-sort');
31 | var del = require('del');
32 | var watch = require('gulp-watch');
33 | var less = require('gulp-less');
34 | var path = require('path');
35 |
36 | var SRC_ROOT = './hermes/webapp/src/';
37 | var BUILD_DEST = './hermes/webapp/build/';
38 | var VENDOR_ROOT = "./_bc/";
39 |
40 | var JS_MAIN_SRC = SRC_ROOT + 'js/hermesApp.js';
41 | var JS_SRC = SRC_ROOT + 'js/**/*.js';
42 | var STYLE_SRC = SRC_ROOT + 'css/**/*.less';
43 | var IMAGE_SRC = SRC_ROOT + 'img/**';
44 | var HTML_SRC = SRC_ROOT + "**/*.html";
45 | var BS_FONT_SRC = VENDOR_ROOT + "bootstrap/dist/fonts/*.woff2";
46 |
47 |
48 | /**
49 | * Task to lint JavaScript files.
50 | */
51 | gulp.task('lint:js', function() {
52 | return gulp.src([JS_MAIN_SRC, JS_SRC])
53 | .pipe(jshint())
54 | .pipe(jshint.reporter('jshint-stylish'));
55 | });
56 |
57 |
58 | /**
59 | * Task to lint CSS files.
60 | */
61 | gulp.task('lint:style', function() {
62 | return gulp.src(STYLE_SRC)
63 | .pipe(csslint())
64 | .pipe(csslint.reporter());
65 | });
66 |
67 |
68 | /**
69 | * Top level Task to run all lint tasks.
70 | */
71 | gulp.task('lint', ['lint:js', 'lint:style']);
72 |
73 |
74 | /**
75 | * Updates the local cache of bower dependencies
76 | */
77 | gulp.task('bower', function() {
78 | return bower({ cmd: 'update'});
79 | });
80 |
81 |
82 | /**
83 | * Task to build JavaScript files.
84 | */
85 | gulp.task('build:js', function() {
86 | return gulp.src([JS_MAIN_SRC, JS_SRC])
87 | .pipe(ngAnnotate())
88 | //.pipe(sort())
89 | .pipe(concat('app.js'))
90 | .pipe(gulp.dest((BUILD_DEST + 'js')))
91 | .pipe(uglify())
92 | .pipe(rename('app.min.js'))
93 | .pipe(gulp.dest((BUILD_DEST + 'js')));
94 | });
95 |
96 | /**
97 | * Task to build our HTML files
98 | */
99 | gulp.task('build:html', function() {
100 | return gulp.src(HTML_SRC)
101 | .pipe(gulp.dest((BUILD_DEST)))
102 | });
103 |
104 |
105 | /**
106 | * Task to build CSS files.
107 | */
108 | gulp.task('build:style', function() {
109 | return gulp.src(STYLE_SRC)
110 | .pipe(less({
111 | paths: [ path.join(__dirname, 'less', 'includes') ]
112 | }))
113 | .pipe(sort())
114 | .pipe(concat('hermes.css'))
115 | .pipe(gulp.dest((BUILD_DEST + 'css')))
116 | .pipe(minifyCss())
117 | .pipe(rename('hermes.min.css'))
118 | .pipe(gulp.dest((BUILD_DEST + 'css')));
119 | });
120 |
121 | /**
122 | * Task to process less files for bootstrap
123 | */
124 | gulp.task('build:bsless', function() {
125 | return gulp.src('_bc/bootstrap/less/bootstrap.less')
126 | .pipe(less({
127 | paths: [ path.join(__dirname, 'less', 'includes') ]
128 | }))
129 | .pipe(gulp.dest(BUILD_DEST + 'css'));
130 | });
131 |
132 |
133 | /**
134 | * Task to "build" images. While we're not doing anything interesting
135 | * now this opens up the option for building sprites if needed. This
136 | * also keeps our src separate from our build where we'll do things like
137 | * hash built files eventually.
138 | */
139 | gulp.task('build:images', function() {
140 | return gulp.src(IMAGE_SRC)
141 | .pipe(gulp.dest((BUILD_DEST + 'img')))
142 | });
143 |
144 | gulp.task('build:fonts', function() {
145 | return gulp.src(BS_FONT_SRC)
146 | .pipe(gulp.dest((BUILD_DEST + 'fonts')))
147 | });
148 |
149 | /**
150 | * Uses bower to install the "main" files into our build. In most cases
151 | * the "main" files are manually specified in the `overrides` section
152 | * of bower.json
153 | */
154 | gulp.task('build:3rdparty', ['bower'], function() {
155 | return gulp.src(mainBowerFiles(), {base: '_bc'})
156 | .pipe(gulp.dest(BUILD_DEST + 'vendor'))
157 | });
158 |
159 |
160 | /**
161 | * Create a hashed version of all built files. This is currently
162 | * just a placeholder and hasn't been finished yet.
163 | */
164 | gulp.task('build:revisions', ['build:html', 'build:js', 'build:bsless', 'build:style', 'build:images', 'build:fonts', 'build:3rdparty'], function() {
165 | // TODO(gary): Do.
166 | return gulp.src(BUILD_DEST);
167 | });
168 |
169 |
170 | /**
171 | * Super task to build everything.
172 | */
173 | gulp.task('build', ['build:revisions']);
174 |
175 |
176 | /**
177 | * Remove the build directory
178 | */
179 | gulp.task('clean', function(cb) {
180 | del([BUILD_DEST], cb);
181 | });
182 |
183 |
184 | gulp.task('watch', ['build'], function() {
185 | gulp.watch([JS_MAIN_SRC, JS_SRC, STYLE_SRC, IMAGE_SRC, HTML_SRC], ['build']);
186 | });
187 |
--------------------------------------------------------------------------------
/tests/api_tests/util.py:
--------------------------------------------------------------------------------
1 | import json
2 | import os
3 | import requests
4 | import urllib
5 | import urlparse
6 |
7 |
8 | def _deep_sort(obj):
9 | if isinstance(obj, dict):
10 | return {
11 | key: _deep_sort(value)
12 | for key, value in obj.iteritems()
13 | }
14 | elif isinstance(obj, list):
15 | return sorted(_deep_sort(elem) for elem in obj)
16 | return obj
17 |
18 |
19 | def _stripper(obj, strip):
20 | if isinstance(obj, dict):
21 | json = {}
22 | for key, value in obj.iteritems():
23 | if isinstance(value, basestring):
24 | value = str(value)
25 | if key not in strip:
26 | json[str(key)] = _stripper(value, strip)
27 |
28 | return json
29 | elif isinstance(obj, list):
30 | return [_stripper(elem, strip) for elem in obj]
31 | return obj
32 |
33 |
34 | def assert_error(response, code):
35 | output = response.json()
36 | assert output["status"] == "error"
37 | assert output["error"]["code"] == code
38 |
39 |
40 | def assert_success(response, data=None, ignore_order=True, strip=[]):
41 | output = response.json()
42 | if isinstance(strip, basestring):
43 | strip = [strip, "href"]
44 | else:
45 | strip.append("href")
46 | output = _stripper(output, strip)
47 | assert response.status_code == 200
48 | assert output["status"] == "ok"
49 |
50 | data["status"] = "ok"
51 | if ignore_order:
52 | assert _deep_sort(output) == _deep_sort(data)
53 | else:
54 | assert output == data
55 |
56 |
57 | def assert_created(response, location, data=None):
58 | output = response.json()
59 | assert response.status_code == 201
60 | assert output["status"] == "created"
61 | assert response.headers.get("Location") == location
62 | if data is not None:
63 | assert output == data
64 |
65 |
66 | def assert_deleted(response):
67 | output = response.json()
68 | assert response.status_code == 200
69 | assert output["status"] == "ok"
70 |
71 |
72 | class Client(object):
73 | def __init__(self, tornado_server, user="user"):
74 | self.tornado_server = tornado_server
75 | self.user = "{}@localhost".format(user)
76 |
77 | @property
78 | def base_url(self):
79 | return "http://localhost:{}/api/v1".format(self.tornado_server.port)
80 |
81 | def request(self, method, url, **kwargs):
82 |
83 | headers = {
84 | "X-NSoT-Email": self.user
85 | }
86 |
87 | if method.lower() in ("put", "post"):
88 | headers["Content-type"] = "application/json"
89 |
90 | return requests.request(
91 | method, self.base_url + url,
92 | headers=headers, **kwargs
93 | )
94 |
95 | def get(self, url, **kwargs):
96 | return self.request("GET", url, **kwargs)
97 |
98 | def post(self, url, **kwargs):
99 | return self.request("POST", url, **kwargs)
100 |
101 | def put(self, url, **kwargs):
102 | return self.request("PUT", url, **kwargs)
103 |
104 | def delete(self, url, **kwargs):
105 | return self.request("DELETE", url, **kwargs)
106 |
107 | def create(self, url, **kwargs):
108 | return self.post(url, data=json.dumps(kwargs))
109 |
110 | def update(self, url, **kwargs):
111 | return self.put(url, data=json.dumps(kwargs))
112 |
113 |
114 | def load_json(relpath):
115 | """
116 | Load JSON files relative to this directory.
117 |
118 | Files are loaded from the 'data' directory. So for example for
119 | ``/path/to/data/devices/foo.json`` the ``relpath`` would be
120 | ``devices/foo.json``.
121 |
122 | :param relpath:
123 | Relative path to our directory's "data" dir
124 | """
125 | our_path = os.path.dirname(os.path.abspath(__file__))
126 | data_dir = os.path.join(our_path, 'data')
127 | filepath = os.path.join(data_dir, relpath)
128 | with open(filepath, 'rb') as f:
129 | return json.load(f)
130 |
131 |
132 | def run_set_queries(resource_name, client, device_queries):
133 | """
134 | Run set queries on the specified resource.
135 |
136 | The directory structure is expected to match the resource path. So
137 | "devices/query" would map to both the data directory for JSON response
138 | files, and the API URL of "/api/sites/1/devices/query".
139 |
140 | The ``device_queries is expected to be a list of 2-tuples of (query,
141 | filename) where query is a set query and filename is a file containing the
142 | expected response JSON. Example::
143 |
144 | [
145 | ('foo=bar', 'test1.json'),
146 | ('bar=baz', 'test2.json'),
147 | ]
148 |
149 | :param resource_name:
150 | The resource for which to run query tests
151 |
152 | :param client:
153 | A ``Client`` instance
154 |
155 | :param devices_queries:
156 | A list of 2-tuples of (query, filename)
157 | """
158 | base_path = '/sites/1'
159 | path = os.path.join(resource_name, 'query')
160 | base_uri = os.path.join(base_path, path)
161 | uri = base_uri + '?query=' # '/sites/1/devices/query?query='
162 |
163 | # Walk the query and filename, construct a URL w/ the query, load up the
164 | # file, call the URL w/ the client, and compare the return data to the
165 | # loaded data.
166 | for query, filename in device_queries:
167 | qs = urllib.quote_plus(query) # 'foo=bar' => 'foo%3Dbar'
168 | url = uri + qs # => /sites/1/devices/query?query=foo%3Dbar
169 | filepath = os.path.join(path, filename) # devices/query/query1.json
170 | output = load_json(filepath)
171 | assert_success(
172 | client.get(url),
173 | output['data']
174 | )
175 |
--------------------------------------------------------------------------------
/hermes/util.py:
--------------------------------------------------------------------------------
1 | """
2 | Project-wide utilities.
3 | """
4 |
5 | import logging
6 | import random
7 | import requests
8 | import smtplib
9 | import string
10 |
11 | from email.mime.text import MIMEText
12 | from email.mime.multipart import MIMEMultipart
13 |
14 | from .settings import settings
15 |
16 |
17 | log = logging.getLogger(__name__)
18 |
19 |
20 | def id_generator(size=6, chars=string.ascii_lowercase + string.digits):
21 | """Generate a random ID of specified length
22 |
23 | Args:
24 | size: the length of the id to generate
25 | chars: the characters to use
26 |
27 | Returns:
28 | string of random id generated
29 | """
30 | return ''.join(random.choice(chars) for _ in range(size))
31 |
32 |
33 | def slack_message(message):
34 | """Post a message to Slack if a webhook as been defined.
35 |
36 | Args:
37 | message: the content of the Slack post
38 | """
39 | if not settings.slack_webhook:
40 | return
41 |
42 | if settings.slack_proxyhost:
43 | proxies = {
44 | "http": "http://{}".format(settings.slack_proxyhost),
45 | "https": "http://{}".format(settings.slack_proxyhost)
46 | }
47 | else:
48 | proxies = None
49 |
50 | json = {
51 | "text": message,
52 | "username": "Hermes Log",
53 | "icon_emoji": ":hermes:",
54 | }
55 | try:
56 | log.debug("{} {}".format(settings.slack_webhook, json))
57 | response = requests.post(
58 | settings.slack_webhook, json=json, proxies=proxies
59 | )
60 | except Exception as exc:
61 | log.warn("Error writing to Slack: {}".format(exc.message))
62 |
63 |
64 | def email_message(recipients, subject, message, html_message=None, cc=None, sender=None):
65 | """Email a message to a user.
66 |
67 | Args:
68 | subject: the subject of the email we wish to send
69 | message: the content of the email we wish to send
70 | recipients: the email address to whom we wish to send the email
71 | html_message: optional html formatted message we wish to send
72 | cc: optional list of email addresses to carbon copy
73 | sender: optional sender email address
74 | """
75 |
76 | if not settings.email_notifications:
77 | return
78 |
79 | if isinstance(recipients, basestring):
80 | recipients = recipients.split(",")
81 | if isinstance(settings.email_always_copy, basestring):
82 | extra_recipients = settings.email_always_copy.split(",")
83 | else:
84 | extra_recipients = [settings.email_always_copy]
85 |
86 | if cc and isinstance(cc, basestring):
87 | extra_recipients.append(cc)
88 | elif cc:
89 | extra_recipients.extend(cc)
90 |
91 | # If this is the dev environment, we need to only send to the dev recipient
92 | # and put a tag explaining what would have happened
93 |
94 | if settings.environment == "dev":
95 | recipients_statement = "To: {} CC: {}\n".format(
96 | recipients, extra_recipients
97 | )
98 | subject = "[DEV] {}".format(subject)
99 | message = (
100 | "[DEV]: Sent to {}\nOriginally addressed as: {}\n\n{}".format(
101 | settings.dev_email_recipient,
102 | recipients_statement,
103 | message
104 | )
105 | )
106 | if html_message:
107 | html_message = (
108 | "DEV: Sent to {}
"
109 | "Originally addressed as: {}
2 |
111 |
--------------------------------------------------------------------------------
/hermes/handlers/util.py:
--------------------------------------------------------------------------------
1 | import json
2 | import logging
3 | import requests
4 | import sys
5 | from tornado.web import RequestHandler, urlparse, HTTPError
6 | from tornado.escape import utf8
7 | from werkzeug.http import parse_options_header
8 |
9 | from .. import exc
10 | from .. import models
11 | from ..settings import settings
12 |
13 |
14 | # Logging object
15 | log = logging.getLogger(__name__)
16 |
17 | # If raven library is available, modify the base handler to support Sentry.
18 | try:
19 | from raven.contrib.tornado import SentryMixin
20 | except ImportError:
21 | pass
22 | else:
23 | class SentryHandler(SentryMixin, RequestHandler):
24 | pass
25 | RequestHandler = SentryHandler
26 |
27 |
28 | API_VER = "/api/v1"
29 |
30 |
31 | class BaseHandler(RequestHandler):
32 | def initialize(self):
33 |
34 | my_settings = self.application.my_settings
35 |
36 | # Lazily build the engine and session for support of multi-processing
37 | if my_settings.get("db_engine") is None:
38 | my_settings["db_engine"] = models.get_db_engine(my_settings.get("db_uri"))
39 | models.Session.configure(bind=my_settings["db_engine"])
40 | my_settings["db_session"] = models.Session
41 |
42 | self.engine = my_settings.get("db_engine")
43 | self.session = my_settings.get("db_session")()
44 | self.domain = my_settings.get("domain")
45 | self.count_events = my_settings.get("count_events", True)
46 |
47 | def on_finish(self):
48 | self.session.close()
49 |
50 | def get_current_user(self):
51 | """Default global user fetch by user_auth_header."""
52 |
53 | # Fetch the email address from the auth_header (e.g. X-Hermes-Email)
54 | auth_header = settings.user_auth_header
55 | log.debug(' fetching auth_header: %s' % auth_header)
56 | email = self.request.headers.get(auth_header)
57 |
58 | if email is not None:
59 | log.debug('auth_header authenticated user: %s' % email)
60 | return email
61 | return None
62 |
63 | def prepare(self):
64 | log.debug('BaseHandler.prepare()')
65 |
66 |
67 | class FeHandler(BaseHandler):
68 |
69 | def prepare(self):
70 | BaseHandler.prepare(self)
71 | # Need to access token to set Cookie.
72 | # self.xsrf_token
73 |
74 | def render_template(self, template_name, **kwargs):
75 | template = self.application.my_settings["template_env"].get_template(
76 | template_name
77 | )
78 | content = template.render(kwargs)
79 | return content
80 |
81 | def render(self, template_name, **kwargs):
82 | context = {}
83 | context.update(self.get_template_namespace())
84 | context.update(kwargs)
85 | self.write(self.render_template(template_name, **context))
86 |
87 | def write_error(self, status_code, **kwargs):
88 | message = "An unknown problem has occured :("
89 | if "exc_info" in kwargs:
90 | inst = kwargs["exc_info"][1]
91 | if isinstance(inst, HTTPError):
92 | message = inst.log_message
93 | else:
94 | message = str(inst)
95 |
96 | # Pass context to the error template
97 | self.render("error.html", code=status_code, message=message)
98 |
99 |
100 | class ApiHandler(BaseHandler):
101 | def initialize(self):
102 | BaseHandler.initialize(self)
103 | self._jbody = None
104 | self.href_prefix = None
105 |
106 | @property
107 | def jbody(self):
108 | if self._jbody is None:
109 | if self.request.body:
110 | self._jbody = json.loads(self.request.body)
111 | else:
112 | self._jbody = {}
113 | return self._jbody
114 |
115 | def get_pagination_values(self, max_limit=None):
116 | if self.get_arguments("limit"):
117 | if self.get_arguments("limit")[0] == "all":
118 | limit = None
119 | else:
120 | limit = int(self.get_arguments("limit")[0])
121 | else:
122 | limit = 10
123 | offset = int((self.get_arguments("offset") or [0])[0])
124 |
125 | if max_limit is not None and limit > max_limit:
126 | limit = max_limit
127 |
128 | return offset, limit, self.get_arguments("expand")
129 |
130 | def paginate_query(self, query, offset, limit, count=True):
131 | total = None
132 | if count:
133 | total = query.count()
134 |
135 | query = query.offset(offset)
136 | if limit is not None:
137 | query = query.limit(limit)
138 |
139 | return query, total
140 |
141 | def prepare(self):
142 | BaseHandler.prepare(self)
143 |
144 | if self.request.method.lower() in ("put", "post"):
145 | content_type = parse_options_header(
146 | self.request.headers.get("Content-Type")
147 | )[0]
148 | if content_type.lower() != "application/json":
149 | raise exc.BadRequest("Invalid Content-Type for POST/PUT request.")
150 |
151 | self.add_header(
152 | "Content-Type",
153 | "application/json"
154 | )
155 |
156 | self.href_prefix = "{}://{}{}".format(
157 | self.request.protocol,
158 | self.request.host,
159 | API_VER
160 | )
161 |
162 | def not_supported(self):
163 | self.write({
164 | "status": "error",
165 | "error": {
166 | "code": 405,
167 | "message": "Method not supported for this resource."
168 | }
169 | })
170 | self.set_status(405, reason="Method not supported.")
171 |
172 | def write_error(self, status_code, **kwargs):
173 |
174 | message = "An unknown problem has occured :("
175 | if "message" in kwargs:
176 | message = kwargs['message']
177 |
178 | if "exc_info" in kwargs:
179 | inst = kwargs["exc_info"][1]
180 | if isinstance(inst, HTTPError):
181 | message = inst.log_message
182 | else:
183 | message = str(inst)
184 |
185 | self.write({
186 | "status": "error",
187 | "error": {
188 | "code": status_code,
189 | "message": message,
190 | },
191 | })
192 | self.set_status(status_code, message)
193 |
194 | def success(self, data):
195 | """200 OK"""
196 | data['status'] = "ok"
197 | if 'href' not in data:
198 | data['href'] = "{}://{}{}".format(
199 | self.request.protocol,
200 | self.request.host,
201 | self.request.uri
202 | )
203 | self.write(data)
204 | self.finish()
205 |
206 | def created(self, location=None, data=None):
207 | """201 CREATED"""
208 | self.set_status(201)
209 | if data is None:
210 | data = {}
211 | data['status'] = 'created'
212 | if location is not None:
213 | self.set_header(
214 | "Location",
215 | urlparse.urljoin(utf8(self.request.uri), utf8(location))
216 | )
217 | self.write(data)
218 | self.finish()
219 |
--------------------------------------------------------------------------------
/docs/Makefile:
--------------------------------------------------------------------------------
1 | # Makefile for Sphinx documentation
2 | #
3 |
4 | # You can set these variables from the command line.
5 | SPHINXOPTS =
6 | SPHINXBUILD = sphinx-build
7 | PAPER =
8 | BUILDDIR = _build
9 |
10 | # User-friendly check for sphinx-build
11 | ifeq ($(shell which $(SPHINXBUILD) >/dev/null 2>&1; echo $$?), 1)
12 | $(error The '$(SPHINXBUILD)' command was not found. Make sure you have Sphinx installed, then set the SPHINXBUILD environment variable to point to the full path of the '$(SPHINXBUILD)' executable. Alternatively you can add the directory with the executable to your PATH. If you don't have Sphinx installed, grab it from http://sphinx-doc.org/)
13 | endif
14 |
15 | # Internal variables.
16 | PAPEROPT_a4 = -D latex_paper_size=a4
17 | PAPEROPT_letter = -D latex_paper_size=letter
18 | ALLSPHINXOPTS = -d $(BUILDDIR)/doctrees $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
19 | # the i18n builder cannot share the environment and doctrees with the others
20 | I18NSPHINXOPTS = $(PAPEROPT_$(PAPER)) $(SPHINXOPTS) .
21 |
22 | .PHONY: help clean html dirhtml singlehtml pickle json htmlhelp qthelp devhelp epub latex latexpdf text man changes linkcheck doctest gettext
23 |
24 | help:
25 | @echo "Please use \`make
3 |
102 |
4 |
8 |
9 |
5 |
6 |
7 | Editing Quest {{qc.quest.id}}
10 |
32 |
33 |
11 |
28 |
12 |
13 | {{qc.quest.creator}}
14 |
17 |
19 |
20 |
22 |
23 |
25 |
26 |
27 |
29 |
31 | The creator/owner of the quest is responsible for managing and closing out the quest.
30 |
34 |
63 |
64 |
35 |
59 |
36 | Current Target Time: {{qc.quest.targetTime}}
37 |
40 |
41 |
42 |
43 |
58 |
44 |
46 |
47 |
49 |
50 |
52 |
53 |
55 |
56 |
57 |
60 |
62 | The targeted completion date and time for the quest. As the date gets closer, notifications to service owners will intensify.
61 |
65 |
92 |
93 |
66 |
86 |
67 |
68 |
70 |
71 |
85 | {{qc.quest.description}}
72 |
73 |
75 |
76 |
77 |
79 |
80 |
82 |
83 |
84 |
87 |
91 | The Quest description is what most users will see so be as
88 | descriptive as possible. Let users know what is going on
89 | and what action they should take.
90 |
94 |
101 |
95 |
96 |
97 |
98 |
99 |
100 |
103 |
110 |
104 |
109 | {{qc.successMessage}}
105 |
106 |
107 |
108 |
2 |
156 |
--------------------------------------------------------------------------------
/hermes/webapp/src/js/directives/questProgressChart.js:
--------------------------------------------------------------------------------
1 | /**
2 | * directive for building quest progress bars with Raphael
3 | */
4 | (function() {
5 | function questProgressChart (hermesService, $timeout, $window) {
6 | return {
7 | restrict: 'A',
8 | scope: {
9 | data: '=',
10 | types: '=',
11 | colors: '=',
12 | onClick: '&'
13 | },
14 | link: function ($scope, $ele, $attrs) {
15 | var width = $ele[0].offsetWidth;
16 | var graphHeight = 200;
17 | var legendFontSize = graphHeight * .06;
18 | var legendSpacing = graphHeight * .09;
19 | var titleFontSize = graphHeight * .12;
20 |
21 |
22 | var renderTimeout;
23 | var types = null;
24 | var numberOfTypes = 0;
25 | var rad = Math.PI / 180;
26 |
27 | // we don't pull this from the backend b/c the backend gives a total that
28 | // includes completed intermediate labors
29 | var totalLabors = 0;
30 | var colors;
31 | var raphael = new Raphael($ele[0], "100%", graphHeight);
32 |
33 | var graphData = null;
34 | hermesService.getFatesGraph().then(function(data) {
35 | graphData = data;
36 | });
37 |
38 | $scope.$watch('data', function (newData) {
39 | $scope.render([newData]);
40 | }, true);
41 |
42 | $scope.$watch('types', function (newData) {
43 | types = newData;
44 | numberOfTypes = 0;
45 | totalLabors = 0;
46 | for (var idx in types) {
47 | numberOfTypes++;
48 | totalLabors += types[idx];
49 | }
50 | });
51 |
52 | $window.onresize = function () {
53 | $scope.$apply();
54 | };
55 |
56 | $scope.$watch(function () {
57 | return angular.element($window)[0].innerWidth;
58 | }, function () {
59 | $scope.render([$scope.data]);
60 | });
61 |
62 |
63 | $scope.$watch('colors', function (newData) {
64 | colors = newData;
65 | }, true);
66 |
67 | $scope.render = function (data) {
68 | if (!data) return;
69 | if (renderTimeout) clearTimeout(renderTimeout);
70 |
71 | function wrapText(text, textEle, maxWidth) {
72 | text = text.replace(/\s+/g, ' ').trim();
73 | text = text.replace('\n', ' ');
74 | var words = text.split(" ");
75 | var wrappedText = '';
76 | for (var idx in words) {
77 | textEle.attr("text", wrappedText + " " + words[idx]);
78 | if (textEle.getBBox().width > maxWidth) {
79 | wrappedText += '\n' + words[idx];
80 | } else {
81 | wrappedText += ' ' + words[idx];
82 | }
83 | }
84 |
85 | var bb = textEle.getBBox();
86 | var h = Math.abs(bb.y2) - Math.abs(bb.y) + 1;
87 | textEle.attr({
88 | 'y': bb.y + h
89 | });
90 | }
91 |
92 | renderTimeout = $timeout(function () {
93 | var width = $ele[0].offsetWidth;
94 | var legendX = width * .70;
95 | var legendY = ((graphHeight *.9) + ((numberOfTypes-1)* legendSpacing)) / 2;
96 | var pieX = width * .5;
97 | var pieY = graphHeight * .5;
98 | var pieR = graphHeight * .45;
99 |
100 | // erase everything
101 | raphael.clear();
102 |
103 | // add the quest info to the top left
104 | var title = raphael.text(0, titleFontSize,
105 | "Quest " + data[0].id)
106 | .attr({
107 | 'text-anchor': 'start',
108 | 'font-size': titleFontSize,
109 | 'font-family': "Titillium Web"
110 | });
111 |
112 | var creator = raphael.text(0, titleFontSize
113 | + legendFontSize * 2,
114 | "Created by: " + data[0].creator)
115 | .attr({
116 | 'text-anchor': 'start',
117 | 'font-size': legendFontSize,
118 | 'font-family': "Titillium Web"
119 | });
120 |
121 | // add the quest description
122 | var desc = raphael.text(0, legendY - legendSpacing /1.5)
123 | .attr({
124 | 'text-anchor': 'start',
125 | 'font-size': legendFontSize,
126 | 'font-family': "Titillium Web"
127 | });
128 |
129 | wrapText(data[0].description, desc, width *.35);
130 |
131 | if (data[0].overDue) {
132 | raphael.text(legendX, titleFontSize, "OVERDUE")
133 | .attr({
134 | 'font-size': titleFontSize,
135 | 'font-family': "Titillium Web",
136 | 'fill': "#953D2D",
137 | 'text-anchor': 'start'
138 | });
139 | }
140 |
141 | // draw out the legend on the right
142 | var i = 0;
143 | var lastAngle = 0;
144 | for (var idx in types) {
145 | var type = idx;
146 | var x = legendX;
147 | var y = legendY + (i * legendSpacing * 1.1);
148 | var text = raphael.text(
149 | x, y, type
150 | ).attr({
151 | 'font-size': legendFontSize,
152 | 'font-family': "Titillium Web",
153 | 'text-anchor': 'start'
154 | });
155 |
156 | var boxX = x - legendSpacing- (legendSpacing/4);
157 | var boxY = y - legendSpacing/2;
158 |
159 | var box = raphael.rect(boxX, boxY, legendSpacing, legendSpacing)
160 | .attr('fill', colors[i])
161 | .attr('stroke-width', '0');
162 |
163 | var angle = types[idx] / totalLabors * 360;
164 | if (angle == 360) {
165 | var circle = raphael.circle(pieX, pieY, pieR)
166 | .attr({
167 | 'fill': colors[i],
168 | 'stroke': 'none'
169 | });
170 | } else {
171 | var pie = sector(
172 | pieX, pieY, pieR, lastAngle, lastAngle + angle,
173 | {
174 | 'fill': colors[i],
175 | 'stroke': 'none'
176 | }
177 | );
178 | lastAngle += angle;
179 | }
180 | i++;
181 | }
182 | }, 0);
183 | };
184 |
185 | function sector(cx, cy, r, startAngle, endAngle, params) {
186 | var x1 = cx + r * Math.cos(-startAngle * rad),
187 | x2 = cx + r * Math.cos(-endAngle * rad),
188 | y1 = cy + r * Math.sin(-startAngle * rad),
189 | y2 = cy + r * Math.sin(-endAngle * rad);
190 | return raphael.path(["M", cx, cy, "L", x1, y1, "A", r, r, 0, +(endAngle - startAngle > 180), 0, x2, y2, "z"]).attr(params);
191 | }
192 | }
193 | }
194 | }
195 |
196 | angular.module('hermesApp').directive('questProgressChart', questProgressChart);
197 | questProgressChart.$inject = ['HermesService', '$timeout', '$window'];
198 | })();
--------------------------------------------------------------------------------
/docs/conf.py:
--------------------------------------------------------------------------------
1 | # -*- coding: utf-8 -*-
2 | #
3 | # Network Source of Truth documentation build configuration file, created by
4 | # sphinx-quickstart on Fri Dec 26 11:33:34 2014.
5 | #
6 | # This file is execfile()d with the current directory set to its
7 | # containing dir.
8 | #
9 | # Note that not all possible configuration values are present in this
10 | # autogenerated file.
11 | #
12 | # All configuration values have a default; values that are commented out
13 | # serve to show the default.
14 |
15 | import sys
16 | import os
17 | import sphinx_rtd_theme
18 |
19 |
20 | # If extensions (or modules to document with autodoc) are in another directory,
21 | # add these directories to sys.path here. If the directory is relative to the
22 | # documentation root, use os.path.abspath to make it absolute, like shown here.
23 | sys.path.insert(0, os.path.abspath('..'))
24 |
25 | # -- General configuration ------------------------------------------------
26 |
27 | # If your documentation needs a minimal Sphinx version, state it here.
28 | #needs_sphinx = '1.0'
29 |
30 | # Add any Sphinx extension module names here, as strings. They can be
31 | # extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
32 | # ones.
33 | extensions = [
34 | "sphinxcontrib.httpdomain",
35 | "sphinxcontrib.autohttp.tornado",
36 | ]
37 |
38 | # Add any paths that contain templates here, relative to this directory.
39 | templates_path = ['_templates']
40 |
41 | # The suffix of source filenames.
42 | source_suffix = '.rst'
43 |
44 | # The encoding of source files.
45 | #source_encoding = 'utf-8-sig'
46 |
47 | # The master toctree document.
48 | master_doc = 'index'
49 |
50 | # General information about the project.
51 | project = u'Hermes'
52 | copyright = u'2015, Dropbox, Inc.'
53 |
54 | # The version info for the project you're documenting, acts as replacement for
55 | # |version| and |release|, also used in various other places throughout the
56 | # built documents.
57 | #
58 | # The short X.Y version.
59 | def get_version():
60 | from hermes import __version__
61 | return __version__
62 |
63 | version = get_version()
64 | # The full version, including alpha/beta/rc tags.
65 | release = version
66 |
67 | # The language for content autogenerated by Sphinx. Refer to documentation
68 | # for a list of supported languages.
69 | #language = None
70 |
71 | # There are two options for replacing |today|: either, you set today to some
72 | # non-false value, then it is used:
73 | #today = ''
74 | # Else, today_fmt is used as the format for a strftime call.
75 | #today_fmt = '%B %d, %Y'
76 |
77 | # List of patterns, relative to source directory, that match files and
78 | # directories to ignore when looking for source files.
79 | exclude_patterns = ['_build']
80 |
81 | # The reST default role (used for this markup: `text`) to use for all
82 | # documents.
83 | #default_role = None
84 |
85 | # If true, '()' will be appended to :func: etc. cross-reference text.
86 | #add_function_parentheses = True
87 |
88 | # If true, the current module name will be prepended to all description
89 | # unit titles (such as .. function::).
90 | #add_module_names = True
91 |
92 | # If true, sectionauthor and moduleauthor directives will be shown in the
93 | # output. They are ignored by default.
94 | #show_authors = False
95 |
96 | # The name of the Pygments (syntax highlighting) style to use.
97 | pygments_style = 'sphinx'
98 |
99 | # A list of ignored prefixes for module index sorting.
100 | #modindex_common_prefix = []
101 |
102 | # If true, keep warnings as "system message" paragraphs in the built documents.
103 | #keep_warnings = False
104 |
105 |
106 | # -- Options for HTML output ----------------------------------------------
107 |
108 | html_theme = "sphinx_rtd_theme"
109 | html_theme_path = [sphinx_rtd_theme.get_html_theme_path()]
110 |
111 | # The theme to use for HTML and HTML Help pages. See the documentation for
112 | # a list of builtin themes.
113 | #html_theme = 'default'
114 |
115 | # Theme options are theme-specific and customize the look and feel of a theme
116 | # further. For a list of options available for each theme, see the
117 | # documentation.
118 | #html_theme_options = {}
119 |
120 | # Add any paths that contain custom themes here, relative to this directory.
121 | #html_theme_path = []
122 |
123 | # The name for this set of Sphinx documents. If None, it defaults to
124 | # "
3 |
139 |
4 |
8 |
9 |
5 |
6 |
7 | Create a quest:
10 |
67 |
68 |
11 |
35 | For {{qc.hostList.length}} hosts:
12 |
13 |
20 |
23 |
24 |
14 |
16 |
17 | {{host}}
18 |
19 |
25 |
34 |
26 |
29 |
30 |
31 |
32 |
33 |
36 |
37 |
38 |
66 |
39 |
48 |
40 |
43 |
44 |
45 |
46 |
47 |
49 | 
50 |
57 |
51 |
53 |
54 | {{host}}
55 |
56 |
58 |
65 |
59 |
60 |
61 |
62 |
63 |
64 |
69 |
85 |
86 |
70 |
76 |
77 |
78 |
84 |
79 | Need help picking a quest type?
80 |
83 | Use the explorer to see the quest types and what kind of workflow each implies..
81 | 82 |
87 |
99 |
100 |
88 |
95 |
89 |
91 |
92 |
94 |
96 |
98 | The targeted completion date and time for the quest. As the date gets closer, notifications to service owners will intensify.
97 |
101 |
114 |
115 |
102 |
108 |
103 |
106 |
107 |
109 |
113 | The Quest description is what most users will see so be as
110 | descriptive as possible. Let users know what is going on
111 | and what action they should take.
112 |
116 |
129 |
130 |
117 |
118 |
125 |
119 |
123 |
124 |
126 |
127 |
128 |
131 |
138 |
132 |
133 |
134 |
135 |
136 |
137 |
140 |
147 |
141 |
142 |
146 |
143 |
144 |
145 |
148 |
155 |
149 |
154 | {{qc.successMessage}}
150 |
151 |
152 |
153 | "
245 | "Hermes Notifications"
246 | "
"
247 | "This email is being sent to {} because that is the owner listed\n" 248 | "for the systems with open Hermes labors listed below.
" 249 | "Due dates, if any, are noted with each quest.
" 250 | "".format(owner) 251 | ) 252 | msg += ( 253 | "To throw an event manually, you can run the following command " 254 | "on a shell server:
" 255 | "$ hermes event create [event] --host " 256 | "[hostname]" 257 | "
Or you can visit the quests linked below.
"
266 | "QUEST {}
" 267 | "CREATOR: {}
" 268 | ).format( 269 | quest_id, quest.creator 270 | ) 271 | if quest.target_time: 272 | msg += "DUE: {}
".format(quest.target_time) 273 | msg += "DESC:
".format( 275 | settings.frontend, quest_id 276 | ) 277 | else: 278 | msg += ( 279 | "
" 267 | "CREATOR: {}
" 268 | ).format( 269 | quest_id, quest.creator 270 | ) 271 | if quest.target_time: 272 | msg += "DUE: {}
".format(quest.target_time) 273 | msg += "DESC:
\"{}\"
".format(quest.description) 274 | msg += "LINK:{}/v1/quests/{}".format( 275 | settings.frontend, quest_id 276 | ) 277 | else: 278 | msg += ( 279 | "
"
281 | "Labors not "
282 | "associated with a quest:
" 283 | ) 284 | 285 | msg += "
"
296 |
297 | msg += ""
298 |
299 | return msg
300 |
301 |
302 | if __name__ == "__main__":
303 | main()
304 |
--------------------------------------------------------------------------------
/tests/api_tests/test_events.py:
--------------------------------------------------------------------------------
1 | import json
2 | import pytest
3 | import requests
4 |
5 | from .fixtures import tornado_server, tornado_app, sample_data1_server, sample_data2_server
6 | from .util import (
7 | assert_error, assert_success, assert_created, assert_deleted, Client
8 | )
9 |
10 |
11 | def test_malformed(sample_data1_server):
12 | client = sample_data1_server
13 | assert_error(client.post("/events", data="Non-JSON"), 400)
14 |
15 | assert_error(
16 | client.create(
17 | "/events",
18 | hostname="example",
19 | user="testman@example.com",
20 | note="This is a test event"
21 | ),
22 | 400
23 | )
24 |
25 | assert_error(
26 | client.create(
27 | "/events",
28 | hostname="example",
29 | category="blah",
30 | user="testman@example.com",
31 | note="This is a test event"
32 | ),
33 | 500
34 | )
35 |
36 | assert_error(
37 | client.create(
38 | "/events",
39 | hostname="example",
40 | state="blah",
41 | user="testman@example.com",
42 | note="This is a test event"
43 | ),
44 | 500
45 | )
46 |
47 |
48 | def test_creation(sample_data1_server):
49 | client = sample_data1_server
50 | assert_success(
51 | client.get("/eventtypes"),
52 | {
53 | "eventTypes": [{"category": "system-reboot",
54 | "description": "This system requires a reboot.",
55 | "restricted": False,
56 | "id": 1,
57 | "state": "required"},
58 | {"category": "system-reboot",
59 | "description": "This system rebooted.",
60 | "restricted": False,
61 | "id": 2,
62 | "state": "completed"},
63 | {"category": "system-maintenance",
64 | "description": "This system requires maintenance.",
65 | "restricted": False,
66 | "id": 3,
67 | "state": "required"},
68 | {"category": "system-maintenance",
69 | "description": "This system is ready for maintenance.",
70 | "restricted": False,
71 | "id": 4,
72 | "state": "ready"},
73 | {"category": "system-maintenance",
74 | "description": "System maintenance completed.",
75 | "restricted": False,
76 | "id": 5,
77 | "state": "completed"},
78 | {"category": "system-shutdown",
79 | "description": "System shutdown required.",
80 | "restricted": False,
81 | "id": 6,
82 | "state": "required"},
83 | {"category": "system-shutdown",
84 | "description": "System shutdown completed.",
85 | "restricted": False,
86 | "id": 7,
87 | "state": "completed"}],
88 | "limit": 10,
89 | "offset": 0,
90 | "totalEventTypes": 7,
91 | }
92 | )
93 |
94 | assert_success(
95 | client.get("/events"),
96 | {
97 | "events": [{"eventTypeId": 1,
98 | "hostId": 1,
99 | "id": 1,
100 | "note": "example needs a reboot",
101 | "user": "system@example.com"},
102 | {"eventTypeId": 2,
103 | "hostId": 1,
104 | "id": 2,
105 | "note": "example needs a rebooted",
106 | "user": "system@example.com"}],
107 | "limit": 10,
108 | "offset": 0,
109 | "totalEvents": 2
110 | },
111 | strip=["timestamp"]
112 | )
113 |
114 | assert_created(
115 | client.create(
116 | "/events",
117 | hostname="example",
118 | user="testman@example.com",
119 | eventTypeId=1,
120 | note="This is a test event"
121 | ),
122 | "/api/v1/events/3"
123 | )
124 |
125 | assert_success(
126 | client.get("/events/3"),
127 | {
128 | "id": 3,
129 | "hostId": 1,
130 | "note": "This is a test event",
131 | "eventTypeId": 1,
132 | "user": "testman@example.com"
133 | },
134 | strip=["timestamp"]
135 | )
136 |
137 | assert_created(
138 | client.create(
139 | "/events",
140 | hostname="example",
141 | user="testman@example.com",
142 | category="system-reboot",
143 | state="completed",
144 | note="This is another test event"
145 | ),
146 | "/api/v1/events/4"
147 | )
148 |
149 | assert_success(
150 | client.get("/events/4"),
151 | {
152 | "id": 4,
153 | "hostId": 1,
154 | "note": "This is another test event",
155 | "eventTypeId": 2,
156 | "user": "testman@example.com"
157 | },
158 | strip=["timestamp"]
159 | )
160 |
161 |
162 | def test_update(sample_data1_server):
163 | client = sample_data1_server
164 | assert_created(
165 | client.create(
166 | "/events",
167 | hostname="example",
168 | user="testman@example.com",
169 | eventTypeId=1,
170 | note="This is a test event"
171 | ),
172 | "/api/v1/events/3"
173 | )
174 |
175 | assert_success(
176 | client.get("/events/3"),
177 | {
178 | "id": 3,
179 | "hostId": 1,
180 | "note": "This is a test event",
181 | "eventTypeId": 1,
182 | "user": "testman@example.com"
183 | },
184 | strip=["timestamp"]
185 | )
186 |
187 | assert_error(client.put("/events/3", json={"note": "New note"}), 405)
188 |
189 |
190 | def test_multi_host_events(sample_data1_server):
191 | client = sample_data1_server
192 | result = client.create(
193 | "/events",
194 | hostnames=["example","sample","test"],
195 | user="testman@example.com",
196 | eventTypeId=1,
197 | note="This is a test event"
198 | )
199 |
200 | result_json = result.json()
201 |
202 | assert result_json['totalEvents'] == 3
203 |
204 |
205 | def test__before_after_query(sample_data1_server):
206 | client = sample_data1_server
207 | event2 = client.get("/events/2").json()
208 |
209 | assert event2['timestamp'] is not None
210 |
211 | assert_created(
212 | client.create(
213 | "/events",
214 | hostname="example",
215 | user="testman@example.com",
216 | eventTypeId=1,
217 | note="This is a test event"
218 | ),
219 | "/api/v1/events/3"
220 | )
221 |
222 | new_event = client.get("/events/3").json()
223 | new_timestamp = new_event['timestamp']
224 |
225 | result = client.get("/events/?after={}".format(new_timestamp)).json()
226 | assert result['totalEvents'] == 1
227 |
228 | result = client.get("/events/?before={}".format(new_timestamp)).json()
229 | assert result['totalEvents'] == 2
230 |
231 |
232 | def test_after_event_type_query(sample_data2_server):
233 | client = sample_data2_server
234 | assert_success(
235 | client.get("/events"),
236 | {
237 | "limit": 10,
238 | "offset": 0,
239 | "totalEvents": 15
240 | },
241 | strip=["timestamp", "events"]
242 | )
243 | assert_success(
244 | client.get("/events?hostname=example&afterEventType=3"),
245 | {
246 | "limit": 10,
247 | "offset": 0,
248 | "totalEvents": 3
249 | },
250 | strip=["timestamp", "events"]
251 | )
252 |
253 |
254 | def test_after_event_id_query(sample_data2_server):
255 | """
256 | Test the afterEventId param to the events endpoint.
257 | """
258 | client = sample_data2_server
259 | assert_success(
260 | client.get("/events"),
261 | {
262 | "limit": 10,
263 | "offset": 0,
264 | "totalEvents": 15
265 | },
266 | strip=["timestamp", "events"]
267 | )
268 |
269 |
270 | # There are 8 events with hostname=example in the data set,
271 | # with ID values 1-8. After event Id 2, there should be 7 total events.
272 | assert_success(
273 | client.get("/events?hostname=example&afterEventId=2"),
274 | {
275 | "limit": 10,
276 | "offset": 0,
277 | "totalEvents": 7
278 | },
279 | strip=["timestamp", "events"]
280 | )
281 | # After event Id 3 there should be 6 total events.
282 | assert_success(
283 | client.get("/events?hostname=example&afterEventId=3"),
284 | {
285 | "limit": 10,
286 | "offset": 0,
287 | "totalEvents": 6
288 | },
289 | strip=["timestamp", "events"]
290 | )
291 |
292 |
293 | # Test with the after argument.
294 | assert_success(
295 | client.get("/events?hostname=example&afterEventId=2&after=1970-01-01"),
296 | {
297 | "limit": 10,
298 | "offset": 0,
299 | "totalEvents": 7
300 | },
301 | strip=["timestamp", "events"]
302 | )
303 | # After event Id 3 there should be 6 total events.
304 | assert_success(
305 | client.get("/events?hostname=example&afterEventId=3"),
306 | {
307 | "limit": 10,
308 | "offset": 0,
309 | "totalEvents": 6
310 | },
311 | strip=["timestamp", "events"]
312 | )
313 |
314 | # Test with the after argument.
315 | assert_success(
316 | client.get("/events?hostname=example&afterEventId=2&after=1970-01-01"),
317 | {
318 | "limit": 10,
319 | "offset": 0,
320 | "totalEvents": 7
321 | },
322 | strip=["timestamp", "events"]
323 | )
324 |
325 |
326 | # Test with the before argument.
327 | assert_success(
328 | client.get("/events?hostname=example&afterEventId=2&before=2050-01-01"),
329 | {
330 | "limit": 10,
331 | "offset": 0,
332 | "totalEvents": 7
333 | },
334 | strip=["timestamp", "events"]
335 | )
336 |
337 | # Test with the before and after argument.
338 | assert_success(
339 | client.get("/events?hostname=example&afterEventId=2&after=1970-01-01&before=2050-01-01"),
340 | {
341 | "limit": 10,
342 | "offset": 0,
343 | "totalEvents": 7
344 | },
345 | strip=["timestamp", "events"]
346 | )
347 |
348 |
349 | # Test with the before and after argument, with no events.
350 | assert_success(
351 | client.get("/events?hostname=example&afterEventId=2&after=1970-01-01&before=1970-02-01"),
352 | {
353 | "limit": 10,
354 | "offset": 0,
355 | "totalEvents": 0
356 | },
357 | strip=["timestamp", "events"]
358 | )
359 |
360 | def test_count_events_disabled(sample_data2_server):
361 | client = sample_data2_server
362 | client.tornado_server.tornado_app.my_settings["count_events"] = False
363 | assert_success(
364 | client.get("/events"),
365 | {
366 | "limit": 10,
367 | "offset": 0,
368 | },
369 | strip=["timestamp", "events"]
370 | )
--------------------------------------------------------------------------------
" 283 | ) 284 | 285 | msg += "
Machines with labors:
" 286 | 287 | msg += ""
288 | for hostname in sorted(info[owner][quest_id]):
289 | if tags[hostname]:
290 | tags_str = "{}".format((", ".join(tags[hostname])))
291 | else:
292 | tags_str = "no services"
293 | msg += "{} ({})\n".format(hostname, tags_str)
294 |
295 | msg += "