" 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 |
--------------------------------------------------------------------------------
/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 |
--------------------------------------------------------------------------------
/bower.json:
--------------------------------------------------------------------------------
1 | {
2 | "name": "hermes",
3 | "version": "0.0.0",
4 | "private": true,
5 | "homepage": "https://github.com/diggyk/hermes",
6 | "authors": [
7 | "Digant Kasundra " 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 += "DEV: Sent to {}
"
109 | "Originally addressed as: {}
40 |
41 |
42 |
43 |
44 |
45 |
46 |
47 |
48 |
49 |
50 |
51 |
52 |
53 |
54 |
55 |
--------------------------------------------------------------------------------
/hermes/webapp/src/js/controllers/questCreationCtrl.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | 'use strict';
3 |
4 | function QuestCreationCtrl(hermesService, $q, $routeParams, $location) {
5 | var vm = this;
6 |
7 | vm.user = null;
8 | vm.hostList = [];
9 | vm.selectedFate = null;
10 | vm.description = null;
11 | vm.today = new Date();
12 | vm.targetDate = new Date();
13 | vm.targetDate.setDate(new Date().getDate() + 14);
14 | vm.targetDate.setTime(Math.round(vm.targetDate.getTime() / 900000) * 900000);
15 |
16 | vm.errorMessages = null;
17 | vm.addHostErrorMessages = [];
18 | vm.queryErrorMessage = null;
19 | vm.successMessage = null;
20 | vm.createInProgress = false;
21 | vm.queryInProgress = false;
22 | vm.result = null;
23 | vm.showFatesModal = false;
24 | vm.queryString = null;
25 | vm.hostNameEntry = null;
26 |
27 | vm.queriedHosts = [];
28 | vm.startingEventTypes = null;
29 | vm.startingFates = [];
30 |
31 | vm.selectOptions = {
32 | updateOn: 'default change blur',
33 | getterSetter: true,
34 | allowInvalid: true
35 | };
36 |
37 |
38 | hermesService.getFates().then(function(fates) {
39 | vm.startingFates = [];
40 | for (var idx in fates) {
41 | if (!fates[idx]['followsId']) {
42 | vm.startingFates.push(fates[idx]);
43 | }
44 | }
45 | if (vm.startingFates.length != 0) {
46 | vm.selectedFate = vm.startingFates[0];
47 | }
48 | });
49 |
50 | hermesService.getCurrentUser().then(function(user){
51 | if (user) {
52 | vm.user = user;
53 | } else {
54 | vm.errorMessages.push("Cannot create a new quest if not authenticated.");
55 | }
56 | });
57 |
58 | vm.runQuery = runQuery;
59 | vm.removeQueriedHost = removeQueriedHost;
60 | vm.removeHost = removeHost;
61 | vm.addHost = addHost;
62 | vm.moveQueriedToQueued = moveQueriedToQueued;
63 | vm.fateSelection = fateSelection;
64 | vm.createQuest = createQuest;
65 | vm.calDateClasser = calDateClasser;
66 |
67 |
68 | ////////////////////////////////
69 |
70 | /**
71 | * Create a quest with the information we have
72 | */
73 | function createQuest() {
74 | if (vm.createInProgress) return;
75 |
76 | vm.createInProgress = true;
77 |
78 | vm.errorMessages = [];
79 |
80 | if (vm.hostList.length == 0) {
81 | vm.errorMessages.push("Cannot create a quest with an empty list of hosts.");
82 | }
83 |
84 | if (!vm.selectedFate) {
85 | vm.errorMessages.push("Cannot create a quest without a starting fate.");
86 | }
87 |
88 | if (!vm.description) {
89 | vm.errorMessages.push("Cannot create a quest without a description.");
90 | }
91 |
92 | if (!vm.user) {
93 | vm.errorMessages.push("Cannot create a new quest if not authenticated.");
94 | }
95 |
96 | if (vm.errorMessages.length != 0) {
97 | vm.createInProgress = false;
98 | return;
99 | }
100 |
101 | vm.result = hermesService.createQuest(vm.user, vm.hostList,
102 | vm.selectedFate.id, vm.targetDate, vm.description)
103 | .then(function(response) {
104 | vm.createInProgress = false;
105 | vm.hostList = [];
106 | vm.description = null;
107 | vm.successMessage = "Successfully create quest " + response.data.id;
108 | })
109 | .catch(function(error) {
110 | vm.createInProgress = false;
111 | vm.errorMessages.push("Quest creation failed! " + error.statusText);
112 | });
113 |
114 | }
115 |
116 | /**
117 | * The getter/setter for event types
118 | */
119 | function fateSelection(selection) {
120 | if (angular.isDefined(selection)) {
121 | vm.selectedFate = selection;
122 | } else {
123 | return vm.selectedFate;
124 | }
125 |
126 | }
127 |
128 | /**
129 | * Run the user specified query against the query passthrough service
130 | */
131 | function runQuery() {
132 | if (!vm.queryString || vm.queryString.trim().length == 0) {
133 | vm.queryErrorMessage = "Query is empty.";
134 | return;
135 | }
136 | vm.queryErrorMessage = null;
137 | vm.queryInProgress = true;
138 | hermesService.runQuery(vm.queryString).then(function(hosts) {
139 | vm.queryInProgress = false;
140 | if (hosts && hosts.length != 0) {
141 | vm.queriedHosts = hosts;
142 | } else {
143 | vm.queryErrorMessage = "Query returned no results.";
144 | }
145 | }).catch(function(error) {
146 | vm.queryInProgress = false;
147 | vm.queryErrorMessage = "Failed to run query! " + error.statusText;
148 | });
149 | }
150 |
151 | /**
152 | * Remove a host from the list of hosts generated by the query
153 | * @param host the host to remove
154 | */
155 | function removeQueriedHost(host) {
156 | var idx = vm.queriedHosts.indexOf(host);
157 | if (idx > -1) {
158 | vm.queriedHosts.splice(idx, 1);
159 | }
160 | }
161 |
162 | /**
163 | * Remove a host from the list of hosts queued up for this quest
164 | * @param host the host to remove
165 | */
166 | function removeHost(host) {
167 | var idx = vm.hostList.indexOf(host);
168 | if (idx > -1) {
169 | vm.hostList.splice(idx, 1);
170 | }
171 | }
172 |
173 | /**
174 | * Add a specified host to the hosts queued up, but only if it isn't
175 | * in there already
176 | * @param host the host to add
177 | */
178 | function addHost(host) {
179 | vm.addHostErrorMessages = [];
180 | if (!host) {
181 | vm.addHostErrorMessages.push("Hostname empty.");
182 | return;
183 | }
184 |
185 | var hosts = host.split(",");
186 | for (var idx in hosts) {
187 | var host = hosts[idx].trim();
188 | if (vm.hostList.indexOf(host) == -1) {
189 | vm.hostList.push(host);
190 | } else {
191 | vm.addHostErrorMessages.push("Ignoring duplicate host " + host);
192 | }
193 | }
194 | }
195 |
196 | /**
197 | * Add queried hosts to queued hosts
198 | */
199 | function moveQueriedToQueued() {
200 | while (vm.queriedHosts.length > 0) {
201 | addHost(vm.queriedHosts.shift());
202 | }
203 | }
204 |
205 | /**
206 | * Adds our classes to the date picker
207 | * @param date the date in question
208 | * @param mode the mode
209 | */
210 | function calDateClasser(date, mode) {
211 | return "date-picker";
212 | }
213 |
214 | }
215 |
216 | angular.module('hermesApp').controller('QuestCreationCtrl', QuestCreationCtrl);
217 | QuestCreationCtrl.$inject = ['HermesService', '$q', '$routeParams', '$location'];
218 | })();
219 |
--------------------------------------------------------------------------------
/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 |
--------------------------------------------------------------------------------
/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/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/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 | })();
--------------------------------------------------------------------------------
/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 | })();
--------------------------------------------------------------------------------
/hermes/webapp/src/js/directives/scrollWatch.js:
--------------------------------------------------------------------------------
1 | (function() {
2 | function scrollWatch ($anchorScroll, $timeout) {
3 | return {
4 | restrict: 'A',
5 | transclude: true,
6 | link: function ($scope, $ele, $attrs) {
7 | if ($scope.$last === true) {
8 | $timeout(function () {
9 | $anchorScroll();
10 | }, 100);
11 | }
12 | }
13 | }
14 | }
15 |
16 | angular.module('hermesApp').directive('scrollWatch', scrollWatch);
17 | scrollWatch.inject = ['$anchorScroll', '$timeout'];
18 | })();
--------------------------------------------------------------------------------
/hermes/webapp/src/js/directives/viewportHeight.js:
--------------------------------------------------------------------------------
1 | /**
2 | * directive for having a div's height based on the size of the viewport
3 | */
4 | (function() {
5 | function viewportHeight ($window) {
6 | return {
7 | restrict: 'A',
8 | scope: {
9 | },
10 | link: function ($scope, $ele, $attrs) {
11 | var minHeight = $attrs.minHeight || 200;
12 | var padding = $attrs.padding || 120;
13 |
14 | $ele.css('overflow', 'scroll');
15 |
16 | angular.element($window).bind('resize', function() {
17 | fixHeight();
18 | });
19 |
20 | function fixHeight() {
21 | var innerHeight = $window.innerHeight;
22 | var height = minHeight;
23 | if (innerHeight > minHeight) {
24 | height = innerHeight - padding - 80;
25 | }
26 |
27 | $ele.css('height', height + 'px');
28 | }
29 |
30 | fixHeight();
31 | }
32 | }
33 | }
34 |
35 | angular.module('hermesApp').directive('viewportHeight', viewportHeight);
36 | viewportHeight.$inject = ['$window'];
37 | })();
--------------------------------------------------------------------------------
/hermes/webapp/src/js/filters/encode.js:
--------------------------------------------------------------------------------
1 | (function() {
2 |
3 | 'use strict';
4 |
5 | function EncodeFilter() {
6 | return window.encodeURIComponent;
7 | }
8 |
9 | angular.module('hermesApp').filter('encode', EncodeFilter);
10 | })();
--------------------------------------------------------------------------------
/hermes/webapp/src/js/filters/num.js:
--------------------------------------------------------------------------------
1 | (function() {
2 |
3 | 'use strict';
4 |
5 | function NumFilter() {
6 | return function (input) {
7 | return parseInt(input, 10);
8 | };
9 | }
10 |
11 | angular.module('hermesApp').filter('num', NumFilter);
12 |
13 | })();
--------------------------------------------------------------------------------
/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/webapp/src/js/services/skipReload.js:
--------------------------------------------------------------------------------
1 | (function() {
2 |
3 | angular.module('hermesApp').factory('skipReload', [
4 | '$route',
5 | '$rootScope',
6 | function ($route, $rootScope) {
7 | return function () {
8 | var lastRoute = $route.current;
9 | var un = $rootScope.$on('$locationChangeSuccess', function () {
10 | $route.current = lastRoute;
11 | un();
12 | });
13 | };
14 | }
15 | ]);
16 | })();
--------------------------------------------------------------------------------
/hermes/webapp/src/templates/fateViewer.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
--------------------------------------------------------------------------------
/hermes/webapp/src/templates/questCreation.html:
--------------------------------------------------------------------------------
1 |
2 |
156 |
--------------------------------------------------------------------------------
/hermes/webapp/src/templates/questEdit.html:
--------------------------------------------------------------------------------
1 |
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 |
2 |
111 |
--------------------------------------------------------------------------------
/hermes/webapp/src/templates/userHome.html:
--------------------------------------------------------------------------------
1 |
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 |
30 |
--------------------------------------------------------------------------------
/package.json:
--------------------------------------------------------------------------------
1 | {
2 | "devDependencies": {
3 | "bower": "^1.5.2",
4 | "del": "^2.0.0",
5 | "gulp": "^3.9.0",
6 | "gulp-bower": "0.0.10",
7 | "gulp-concat": "^2.6.0",
8 | "gulp-csslint": "^0.2.0",
9 | "gulp-jshint": "^1.11.2",
10 | "gulp-less": "^3.0.3",
11 | "gulp-minify-css": "^1.2.1",
12 | "gulp-ng-annotate": "^1.1.0",
13 | "gulp-rename": "^1.2.2",
14 | "gulp-sort": "^1.1.1",
15 | "gulp-uglify": "^1.4.0",
16 | "gulp-watch": "^4.3.5",
17 | "main-bower-files": "^2.9.0"
18 | }
19 | }
20 |
--------------------------------------------------------------------------------
/requirements-dev.txt:
--------------------------------------------------------------------------------
1 | -r requirements.txt
2 | mrproxy==0.3.3
3 | py==1.4.26
4 | pytest==2.6.4
5 | Pygments==2.0.1
6 | Sphinx==1.2.3
7 | argh==0.26.1
8 | docutils==0.12
9 | livereload==2.3.2
10 | pathtools==0.1.2
11 | sphinx-autobuild==0.4.0
12 | watchdog==0.8.2
13 | sphinxcontrib-httpdomain==1.3.0
14 | sphinx-rtd-theme==0.1.6
15 | pytest-capturelog==0.7
16 |
--------------------------------------------------------------------------------
/requirements.txt:
--------------------------------------------------------------------------------
1 | enum34==1.0.4
2 | cffi==0.9.2
3 | pyasn1==0.1.7
4 | six==1.9.0
5 | pycparser==2.10
6 | cryptography==0.8.1
7 | Jinja2==2.7.3
8 | Mako==1.0.1
9 | MarkupSafe==0.23
10 | PyYAML==3.11
11 | SQLAlchemy==0.9.8
12 | Werkzeug==0.9.6
13 | alembic==0.7.4
14 | argparse==1.4.0
15 | backports.ssl-match-hostname==3.4.0.2
16 | bittle==0.2.1
17 | certifi==14.05.14
18 | ipaddress==1.0.7
19 | tornado==4.0.2
20 | MySQL-python==1.2.5
21 | requests[security]==2.7.0
22 | python-dateutil==2.4.2
23 | annex==0.3.1
24 | pytz==2015.6
25 |
--------------------------------------------------------------------------------
/setup.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | import os
4 |
5 | from setuptools import find_packages
6 | from distutils.core import setup
7 |
8 | execfile('hermes/version.py')
9 |
10 | with open('requirements.txt') as requirements:
11 | required = requirements.read().splitlines()
12 |
13 | package_data = {}
14 | def get_package_data(package, base_dir):
15 | for dirpath, dirnames, filenames in os.walk(base_dir):
16 | dirpath = dirpath[len(package)+1:] # Strip package dir
17 | for filename in filenames:
18 | package_data.setdefault(package, []).append(os.path.join(dirpath, filename))
19 | for dirname in dirnames:
20 | get_package_data(package, dirname)
21 |
22 | get_package_data("hermes", "hermes/webapp/build")
23 | get_package_data("hermes", "hermes/templates")
24 |
25 | kwargs = {
26 | "name": "hermes",
27 | "version": str(__version__),
28 | "packages": find_packages(exclude=['tests']),
29 | "package_data": package_data,
30 | "scripts": ["bin/hermes-server", "bin/hermes", "bin/hermes-notify"],
31 | "description": "Hermes Event Management and Autotasker",
32 | "author": "Digant C Kasundra",
33 | "maintainer": "Digant C Kasundra",
34 | "author_email": "digant@dropbox.com",
35 | "maintainer_email": "digant@dropbox.com",
36 | "license": "Apache",
37 | "install_requires": required,
38 | "url": "https://github.com/dropbox/hermes",
39 | "download_url": "https://github.com/dropbox/hermes/archive/master.tar.gz",
40 | "classifiers": [
41 | "Programming Language :: Python",
42 | "Topic :: Software Development",
43 | "Topic :: Software Development :: Libraries",
44 | "Topic :: Software Development :: Libraries :: Python Modules",
45 | ]
46 | }
47 |
48 | setup(**kwargs)
49 |
--------------------------------------------------------------------------------
/tests/api_tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dropbox/hermes/36e5c0532571eed42d5f6edea35f755b837a5b2d/tests/api_tests/__init__.py
--------------------------------------------------------------------------------
/tests/api_tests/data/set1/event.json:
--------------------------------------------------------------------------------
1 | {
2 | "event1": {
3 | "hostname": "example",
4 | "user": "system",
5 | "eventTypeId": 1,
6 | "note": "example needs a reboot"
7 | },
8 | "event2": {
9 | "hostname": "example",
10 | "user": "system",
11 | "eventTypeId": 2,
12 | "note": "example needs a rebooted"
13 | },
14 | "event3": {
15 | "hostname": "example",
16 | "user": "system",
17 | "eventTypeId": 3,
18 | "note": "example needs a reboot"
19 | },
20 | "event4": {
21 | "hostname": "example",
22 | "user": "system",
23 | "eventTypeId": 4,
24 | "note": "example needs a rebooted"
25 | },
26 | "event5": {
27 | "hostname": "example",
28 | "user": "system",
29 | "eventTypeId": 5,
30 | "note": "example needs a reboot"
31 | },
32 | "event6": {
33 | "hostname": "example",
34 | "user": "system",
35 | "eventTypeId": 3,
36 | "note": "example needs a rebooted"
37 | },
38 | "event7": {
39 | "hostname": "example",
40 | "user": "system",
41 | "eventTypeId": 4,
42 | "note": "example needs a reboot"
43 | },
44 | "event8": {
45 | "hostname": "example",
46 | "user": "system",
47 | "eventTypeId": 1,
48 | "note": "example needs a rebooted"
49 | },
50 | "event9": {
51 | "hostname": "sample",
52 | "user": "system",
53 | "eventTypeId": 3,
54 | "note": "sample needs a reboot"
55 | },
56 | "event10": {
57 | "hostname": "sample",
58 | "user": "system",
59 | "eventTypeId": 4,
60 | "note": "sample needs a rebooted"
61 | },
62 | "event11": {
63 | "hostname": "sample",
64 | "user": "system",
65 | "eventTypeId": 5,
66 | "note": "sample needs a reboot"
67 | },
68 | "event12": {
69 | "hostname": "test",
70 | "user": "system",
71 | "eventTypeId": 3,
72 | "note": "test needs a reboot"
73 | },
74 | "event13": {
75 | "hostname": "test",
76 | "user": "system",
77 | "eventTypeId": 1,
78 | "note": "test needs a reboot"
79 | },
80 | "event14": {
81 | "hostname": "test",
82 | "user": "system",
83 | "eventTypeId": 2,
84 | "note": "test needs a reboot"
85 | },
86 | "event15": {
87 | "hostname": "test",
88 | "user": "system",
89 | "eventTypeId": 4,
90 | "note": "test needs a reboot"
91 | }
92 | }
--------------------------------------------------------------------------------
/tests/api_tests/data/set1/eventtypes.json:
--------------------------------------------------------------------------------
1 | {
2 | "eventTypes": [
3 | {
4 | "category": "system-reboot",
5 | "state": "required",
6 | "description": "This system requires a reboot."
7 | },
8 | {
9 | "category": "system-reboot",
10 | "state": "completed",
11 | "description": "This system rebooted."
12 | },
13 | {
14 | "category": "system-maintenance",
15 | "state": "required",
16 | "description": "This system requires maintenance."
17 | },
18 | {
19 | "category": "system-maintenance",
20 | "state": "ready",
21 | "description": "This system is ready for maintenance."
22 | },
23 | {
24 | "category": "system-maintenance",
25 | "state": "completed",
26 | "description": "System maintenance completed."
27 | },
28 | {
29 | "category": "system-shutdown",
30 | "state": "required",
31 | "description": "System shutdown required."
32 | },
33 | {
34 | "category": "system-shutdown",
35 | "state": "completed",
36 | "description": "System shutdown completed."
37 | }
38 | ]
39 | }
40 |
41 |
--------------------------------------------------------------------------------
/tests/api_tests/data/set1/fates.json:
--------------------------------------------------------------------------------
1 | {
2 | "fate1": {
3 | "creationEventTypeId": 1,
4 | "description": "A system that needs a reboot can be cleared by rebooting the machine."
5 | },
6 | "fate2": {
7 | "creationEventTypeId": 2,
8 | "followsId": 1,
9 | "description": "A system that needs a reboot can be cleared by rebooting the machine."
10 | },
11 | "fate3": {
12 | "creationEventTypeId": 3,
13 | "description": "A system that needs maintenance made ready before maintenance can occur."
14 | },
15 | "fate4": {
16 | "creationEventTypeId": 4,
17 | "followsId": 3,
18 | "forCreator": true,
19 | "forOwner": false,
20 | "description": "A system that needs maintenance made ready before maintenance can occur."
21 | },
22 | "fate5": {
23 | "creationEventTypeId": 5,
24 | "followsId": 4,
25 | "description": "Maintenance must be performed on a system that is prepped."
26 | },
27 | "fate6": {
28 | "creationEventTypeId": 3,
29 | "description": "Maintenance must be performed on a new system."
30 | },
31 | "fate7": {
32 | "creationEventTypeId": 5,
33 | "followsId": 6,
34 | "description": "Maintenance must be performed on a new system that is prepped."
35 | }
36 |
37 | }
--------------------------------------------------------------------------------
/tests/api_tests/data/set1/hosts.json:
--------------------------------------------------------------------------------
1 | {
2 | "hosts": [
3 | {
4 | "hostname": "example"
5 | },
6 | {
7 | "hostname": "sample"
8 | },
9 | {
10 | "hostname": "test"
11 | }
12 | ]
13 | }
--------------------------------------------------------------------------------
/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
--------------------------------------------------------------------------------
/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 |
--------------------------------------------------------------------------------
/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 |
--------------------------------------------------------------------------------
/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 | )
--------------------------------------------------------------------------------
/tests/api_tests/test_labors.py:
--------------------------------------------------------------------------------
1 | import json
2 | import pytest
3 | import requests
4 |
5 | from datetime import datetime, timedelta
6 |
7 | from .fixtures import tornado_server, tornado_app, sample_data1_server
8 | from .util import (
9 | assert_error, assert_success, assert_created, assert_deleted, Client
10 | )
11 |
12 |
13 | def test_malformed(sample_data1_server):
14 | client = sample_data1_server
15 | assert_error(client.post("/quests", data="Non-JSON"), 400)
16 |
17 |
18 | def test_creation(sample_data1_server):
19 | client = sample_data1_server
20 | assert_success(
21 | client.get("/events"),
22 | {
23 | "limit": 10,
24 | "offset": 0,
25 | "totalEvents": 2
26 | },
27 | strip=["timestamp", "events"]
28 | )
29 |
30 | assert_success(
31 | client.get("/quests"),
32 | {
33 | "limit": 10,
34 | "offset": 0,
35 | "totalQuests": 0,
36 | "quests": []
37 | }
38 | )
39 |
40 | assert_success(
41 | client.get("/labors"),
42 | {
43 | "limit": 10,
44 | "offset": 0,
45 | "totalLabors": 0,
46 | "labors": []
47 | }
48 | )
49 |
50 | target_time = datetime.utcnow() + timedelta(days=7)
51 |
52 | assert_created(
53 | client.create(
54 | "/quests",
55 | creator="johnny",
56 | fateId=1,
57 | targetTime=str(target_time),
58 | description="This is a quest almighty",
59 | hostnames=["example", "sample", "test"]
60 | ),
61 | "/api/v1/quests/1"
62 | )
63 |
64 | assert_success(
65 | client.get("/labors"),
66 | {
67 | "limit": 10,
68 | "offset": 0,
69 | "totalLabors": 3,
70 | "labors": [{"ackTime": None,
71 | "ackUser": None,
72 | "fateId": 1,
73 | "closingFateId": None,
74 | "completionEventId": None,
75 | "creationEventId": 3,
76 | "targetTime": str(target_time),
77 | "hostId": 1,
78 | "forOwner": True,
79 | "forCreator": False,
80 | "id": 1,
81 | "startingLaborId": None,
82 | "questId": 1},
83 | {"ackTime": None,
84 | "ackUser": None,
85 | "completionEventId": None,
86 | "creationEventId": 4,
87 | "targetTime": str(target_time),
88 | "hostId": 2,
89 | "forOwner": True,
90 | "forCreator": False,
91 | "fateId": 1,
92 | "closingFateId": None,
93 | "id": 2,
94 | "startingLaborId": None,
95 | "questId": 1},
96 | {"ackTime": None,
97 | "ackUser": None,
98 | "completionEventId": None,
99 | "creationEventId": 5,
100 | "targetTime": str(target_time),
101 | "hostId": 3,
102 | "forOwner": True,
103 | "forCreator": False,
104 | "fateId": 1,
105 | "closingFateId": None,
106 | "id": 3,
107 | "startingLaborId": None,
108 | "questId": 1}],
109 | },
110 | strip=["creationTime", "completionTime"]
111 | )
112 |
113 |
114 | def test_update(sample_data1_server):
115 | client = sample_data1_server
116 |
117 | # create a quest without a target_time
118 | assert_created(
119 | client.create(
120 | "/quests",
121 | creator="johnny",
122 | fateId=1,
123 | description="This is a quest almighty",
124 | hostnames=["example", "sample", "test"]
125 | ),
126 | "/api/v1/quests/1"
127 | )
128 |
129 | # make sure 3 labors was created for this quest
130 | assert_success(
131 | client.get("/labors"),
132 | {
133 | "limit": 10,
134 | "offset": 0,
135 | "totalLabors": 3
136 | },
137 | strip=["creationTime", "labors"]
138 | )
139 |
140 | # create a new event that would create another labor
141 | assert_created(
142 | client.create(
143 | "/events",
144 | hostname="example",
145 | user="testman@example.com",
146 | eventTypeId=1,
147 | note="This is a test event"
148 | ),
149 | "/api/v1/events/6"
150 | )
151 |
152 | # make sure the labor is not attached to a quest
153 | assert_success(
154 | client.get("/labors/4"),
155 | {
156 | "ackTime": None,
157 | "ackUser": None,
158 | "completionEventId": None,
159 | "completionTime": None,
160 | "creationEventId": 6,
161 | "hostId": 1,
162 | "forOwner": True,
163 | "forCreator": False,
164 | "fateId": 1,
165 | "closingFateId": None,
166 | "id": 4,
167 | "startingLaborId": None,
168 | "questId": None
169 | },
170 | strip=["creationTime"]
171 | )
172 |
173 | # attach the labor to a quest
174 | response = client.update(
175 | "/labors/4",
176 | ackUser="johnny@example.com",
177 | questId=1
178 | )
179 |
180 | # make sure the labor is attached to the quest
181 | assert_success(
182 | response,
183 | {
184 | "ackUser": "johnny@example.com",
185 | "completionEventId": None,
186 | "completionTime": None,
187 | "creationEventId": 6,
188 | "targetTime": None,
189 | "hostId": 1,
190 | "fateId": 1,
191 | "closingFateId": None,
192 | "forOwner": True,
193 | "forCreator": False,
194 | "id": 4,
195 | "startingLaborId": None,
196 | "questId": 1
197 | },
198 | strip=["creationTime", "ackTime"]
199 | )
200 |
201 | assert response.json()['ackTime'] is not None
202 |
203 |
204 | def test_labor_filter_by_eventttype(sample_data1_server):
205 | client = sample_data1_server
206 |
207 | assert_success(
208 | client.get("/labors"),
209 | {
210 | "limit": 10,
211 | "offset": 0,
212 | "totalLabors": 0,
213 | "labors": []
214 | }
215 | )
216 |
217 | # create a quest without a target_time
218 | assert_created(
219 | client.create(
220 | "/quests",
221 | creator="johnny",
222 | fateId=1,
223 | description="This is a quest almighty",
224 | hostnames=["example", "sample", "test"]
225 | ),
226 | "/api/v1/quests/1"
227 | )
228 |
229 | # create a quest without a target_time
230 | assert_created(
231 | client.create(
232 | "/quests",
233 | creator="johnny",
234 | fateId=3,
235 | description="This is a 2nd quest almighty",
236 | hostnames=["example", "sample", "test"]
237 | ),
238 | "/api/v1/quests/2"
239 | )
240 |
241 | assert_success(
242 | client.get("/labors"),
243 | {
244 | "limit": 10,
245 | "offset": 0,
246 | "totalLabors": 6,
247 | },
248 | strip=["labors"]
249 | )
250 |
251 | assert_success(
252 | client.get("/labors?hostname=example"),
253 | {
254 | "limit": 10,
255 | "offset": 0,
256 | "totalLabors": 2
257 | },
258 | strip=["labors"]
259 | )
260 |
261 | assert_success(
262 | client.get("/labors?category=system-reboot&state=required"),
263 | {
264 | "limit": 10,
265 | "offset": 0,
266 | "totalLabors": 3
267 | },
268 | strip=["labors"]
269 | )
270 |
271 | assert_success(
272 | client.get("/labors?category=system-maintenance"),
273 | {
274 | "limit": 10,
275 | "offset": 0,
276 | "totalLabors": 3
277 | },
278 | strip=["labors"]
279 | )
280 |
281 |
282 | def test_quest_expansion(sample_data1_server):
283 | client = sample_data1_server
284 |
285 | # create a quest without a target_time
286 | assert_created(
287 | client.create(
288 | "/quests",
289 | creator="johnny",
290 | fateId=1,
291 | description="This is a quest almighty",
292 | hostnames=["example"]
293 | ),
294 | "/api/v1/quests/1"
295 | )
296 |
297 | assert_created(
298 | client.create(
299 | "/events",
300 | eventTypeId=1,
301 | hostname="sample",
302 | user="testman@example.com",
303 | ),
304 | "/api/v1/events/4"
305 | )
306 |
307 | assert_success(
308 | client.get("/labors?expand=quests"),
309 | {
310 | "limit": 10,
311 | "offset": 0,
312 | "totalLabors": 2,
313 | "labors": [
314 | {'ackTime': None,
315 | 'ackUser': None,
316 | 'completionEventId': None,
317 | 'completionTime': None,
318 | 'creationEventId': 3,
319 | 'forCreator': False,
320 | 'forOwner': True,
321 | 'hostId': 1,
322 | 'id': 1,
323 | 'fateId': 1,
324 | "closingFateId": None,
325 | 'quest': {
326 | 'completionTime': None,
327 | 'creator': 'johnny@example.com',
328 | 'description': 'This is a quest almighty',
329 | 'id': 1,
330 | 'targetTime': None
331 | },
332 | 'questId': 1,
333 | 'startingLaborId': None,
334 | 'targetTime': None
335 | },
336 | {'ackTime': None,
337 | 'ackUser': None,
338 | 'completionEventId': None,
339 | 'completionTime': None,
340 | 'creationEventId': 4,
341 | 'forCreator': False,
342 | 'forOwner': True,
343 | 'hostId': 2,
344 | 'id': 2,
345 | 'fateId': 1,
346 | "closingFateId": None,
347 | 'quest': None,
348 | 'questId': None,
349 | 'startingLaborId': None
350 | }
351 | ]
352 | },
353 | strip=["embarkTime", "creationTime"]
354 | )
--------------------------------------------------------------------------------
/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 |
--------------------------------------------------------------------------------
/tests/model_tests/__init__.py:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/dropbox/hermes/36e5c0532571eed42d5f6edea35f755b837a5b2d/tests/model_tests/__init__.py
--------------------------------------------------------------------------------
/tests/model_tests/fixtures.py:
--------------------------------------------------------------------------------
1 | import pytest
2 |
3 | from hermes import models
4 |
5 | @pytest.fixture
6 | def db_engine(tmpdir):
7 | db_path = tmpdir.join("hermes.sqlite")
8 | db_engine = models.get_db_engine("sqlite:///%s" % db_path)
9 |
10 | return db_engine
11 |
12 | @pytest.fixture
13 | def session(db_engine, request, tmpdir):
14 | models.Model.metadata.drop_all(db_engine)
15 | models.Model.metadata.create_all(db_engine)
16 | models.Session.configure(bind=db_engine)
17 | session = models.Session()
18 |
19 | models.Fate._all_fates = None
20 |
21 | def fin():
22 | session.close()
23 | request.addfinalizer(fin)
24 |
25 | return session
26 |
27 | @pytest.fixture
28 | def sample_data1(session):
29 | sql_file = open('tests/sample_data/sample_data1.sql')
30 | sql = sql_file.read()
31 | for statement in sql.split(";"):
32 | session.execute(statement)
33 |
34 | return session
35 |
36 | @pytest.fixture
37 | def sample_data2(session):
38 | sql_file = open('tests/sample_data/sample_data2.sql')
39 | sql = sql_file.read()
40 | for statement in sql.split(";"):
41 | session.execute(statement)
42 |
43 | return session
--------------------------------------------------------------------------------
/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_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 |
--------------------------------------------------------------------------------
/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/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_labors.py:
--------------------------------------------------------------------------------
1 | import pytest
2 |
3 | from sqlalchemy import desc
4 | from sqlalchemy.exc import IntegrityError
5 |
6 | from hermes import exc
7 | from hermes.models import Event, EventType, Fate, Host, Labor
8 |
9 | from .fixtures import db_engine, session, sample_data1, sample_data2
10 |
11 |
12 | def test_lifecycle1(sample_data1):
13 | """Test the automatic creation and closing of labors based on Events and Fates
14 |
15 | Throw event A, and see that it creates Labor A.
16 | Throw event B, and see that it closes Labor A and creates no new Labors.
17 | """
18 | labors = sample_data1.query(Labor).all()
19 | assert len(labors) == 0
20 |
21 | event_type_a = sample_data1.query(EventType).get(1)
22 | event_type_b = sample_data1.query(EventType).get(2)
23 | host = sample_data1.query(Host).first()
24 | assert len(host.labors) == 0
25 |
26 | # Throw event A
27 | Event.create(sample_data1, host, "system", event_type_a)
28 |
29 | event = (
30 | sample_data1.query(Event)
31 | .order_by(desc(Event.id)).first()
32 | )
33 |
34 | assert event.host == host
35 | assert event.event_type == event_type_a
36 |
37 | labors = sample_data1.query(Labor).all()
38 | assert len(labors) == 1
39 | assert labors[0].completion_time is None
40 | assert labors[0].completion_event is None
41 | assert labors[0].creation_event == event
42 | assert labors[0].for_creator is False
43 | assert len(host.labors) == 1
44 | assert len(event.created_labors) == 1
45 | assert len(event.completed_labors) == 0
46 |
47 | # Throw event B
48 | Event.create(
49 | sample_data1, host, "system", event_type_b
50 | )
51 |
52 | event = (
53 | sample_data1.query(Event)
54 | .order_by(desc(Event.id)).first()
55 | )
56 |
57 | assert event.host == host
58 | assert event.event_type == event_type_b
59 |
60 | labors = sample_data1.query(Labor).all()
61 | assert len(labors) == 1
62 | assert labors[0].completion_time is not None
63 | assert labors[0].completion_event == event
64 | assert labors[0].for_creator is False
65 | assert len(event.created_labors) == 0
66 | assert len(event.completed_labors) == 1
67 |
68 | assert len(host.labors) == 1
69 |
70 |
71 | def test_lifecycle_simple2(sample_data1):
72 | """Test another simple lifecycle
73 |
74 | Throw event A, and see that it creates Labor A.
75 | Throw event D, and see that it closes Labor A and creates no new labors.
76 | """
77 | labors = sample_data1.query(Labor).all()
78 | assert len(labors) == 0
79 |
80 | host = sample_data1.query(Host).first()
81 | assert len(host.labors) == 0
82 |
83 | event_a = sample_data1.query(EventType).get(1)
84 | event_d = sample_data1.query(EventType).get(4)
85 |
86 | # Throw event A
87 | Event.create(sample_data1, host, "system", event_a)
88 |
89 | event = (
90 | sample_data1.query(Event)
91 | .order_by(desc(Event.id)).first()
92 | )
93 |
94 | assert event.host == host
95 | assert event.event_type == event_a
96 |
97 | labors = sample_data1.query(Labor).all()
98 | assert len(labors) == 1
99 | assert labors[0].completion_time is None
100 | assert labors[0].completion_event is None
101 | assert labors[0].creation_event == event
102 | assert labors[0].for_creator is False
103 | assert len(host.labors) == 1
104 | assert len(event.created_labors) == 1
105 | assert len(event.completed_labors) == 0
106 |
107 |
108 | # Throw event D
109 | Event.create(
110 | sample_data1, host, "system", event_d
111 | )
112 |
113 | event = (
114 | sample_data1.query(Event)
115 | .order_by(desc(Event.id)).first()
116 | )
117 |
118 | assert event.host == host
119 | assert event.event_type == event_d
120 |
121 | labors = sample_data1.query(Labor).all()
122 | assert len(labors) == 1
123 | assert labors[0].completion_time is not None
124 | assert labors[0].completion_event == event
125 | assert labors[0].for_creator is False
126 | assert len(event.created_labors) == 0
127 | assert len(event.completed_labors) == 1
128 |
129 | assert len(host.labors) == 1
130 |
131 |
132 | def test_lifecycle_complex2(sample_data1):
133 | """Test the automatic creation and closing of labors based on Events and Fates.
134 | This version is a bit more complex in that we make sure unaffiliated labors
135 | are left untouched.
136 |
137 | Throw event A, creates Labor A.
138 | Throw event C, creates Labor C.
139 | Throw event B, closes Labor A, but does nothing to Labor C.
140 | """
141 | labors = sample_data1.query(Labor).all()
142 | assert len(labors) == 0
143 |
144 | fates = sample_data1.query(Fate).all()
145 | fate1 = fates[0]
146 | fate2 = fates[1]
147 | fate4 = fates[3]
148 |
149 | hosts = sample_data1.query(Host).all()
150 | host1 = hosts[0]
151 | host2 = hosts[1]
152 |
153 | # Throw event A and C
154 | Event.create(sample_data1, host1, "system", fate1.creation_event_type)
155 | Event.create(sample_data1, host2, "system", fate4.creation_event_type)
156 |
157 | event = (
158 | sample_data1.query(Event)
159 | .order_by(desc(Event.id)).first()
160 | )
161 |
162 | assert event.host == host2
163 | assert event.event_type == fate4.creation_event_type
164 |
165 | labors = sample_data1.query(Labor).all()
166 | assert len(labors) == 2
167 | assert labors[0].completion_time is None
168 | assert labors[0].completion_event is None
169 | assert labors[0].for_creator is False
170 | assert labors[1].completion_time is None
171 | assert labors[1].completion_event is None
172 | assert labors[1].for_creator is False
173 |
174 | # Throw event B
175 | Event.create(
176 | sample_data1, host1, "system", fate2.creation_event_type
177 | )
178 |
179 | event = (
180 | sample_data1.query(Event)
181 | .order_by(desc(Event.id)).first()
182 | )
183 |
184 | assert event.host == host1
185 | assert event.event_type == fate2.creation_event_type
186 |
187 | labors = sample_data1.query(Labor).all()
188 | assert len(labors) == 2
189 | assert labors[0].completion_time is not None
190 | assert labors[0].completion_event is not None
191 | assert labors[0].for_creator is False
192 | assert labors[1].completion_time is None
193 | assert labors[1].completion_event is None
194 | assert labors[1].for_creator is False
195 |
196 | labors = Labor.get_open_labors(sample_data1).all()
197 | assert len(labors) == 1
198 |
199 | labors = Labor.get_open_unacknowledged(sample_data1)
200 | assert len(labors) == 1
201 |
202 |
203 | def test_acknowledge(sample_data1):
204 | """Test to ensure that acknowledgement correctly flags Labors as such"""
205 |
206 | labors = sample_data1.query(Labor).all()
207 | assert len(labors) == 0
208 |
209 | fate = sample_data1.query(Fate).get(1)
210 | host = sample_data1.query(Host).get(1)
211 |
212 | Event.create(sample_data1, host, "system", fate.creation_event_type)
213 |
214 | event = (
215 | sample_data1.query(Event)
216 | .order_by(desc(Event.id)).first()
217 | )
218 |
219 | assert event.host == host
220 | assert event.event_type == fate.creation_event_type
221 |
222 | labors = Labor.get_open_unacknowledged(sample_data1)
223 | assert len(labors) == 1
224 | assert labors[0].completion_time is None
225 | assert labors[0].completion_event is None
226 | assert labors[0].ack_time is None
227 | assert labors[0].ack_user is None
228 | assert labors[0].creation_event == event
229 | assert labors[0].for_creator is False
230 |
231 | labors[0].acknowledge("testman")
232 |
233 | labors = sample_data1.query(Labor).all()
234 | assert len(labors) == 1
235 | assert labors[0].completion_time is None
236 | assert labors[0].completion_event is None
237 | assert labors[0].ack_time is not None
238 | assert labors[0].ack_user == "testman"
239 | assert labors[0].creation_event == event
240 | assert labors[0].for_creator is False
241 |
242 | labors = Labor.get_open_unacknowledged(sample_data1)
243 | assert len(labors) == 0
244 |
245 |
246 | def test_cannot_start_in_midworkflow(sample_data1):
247 | """Ensures that intermediate fates do not create labors when no labor
248 | exists.
249 |
250 | Given a Fate C -> D, and intermediate Fate D -> E,
251 | Throw event D and ensure Labor D is not created since Labor C does not exist.
252 |
253 | """
254 |
255 | labors = sample_data1.query(Labor).all()
256 | assert len(labors) == 0
257 |
258 | event_type_d = sample_data1.query(EventType).get(4)
259 | host = sample_data1.query(Host).get(1)
260 |
261 | Event.create(sample_data1, host, "system", event_type_d)
262 |
263 | event = (
264 | sample_data1.query(Event)
265 | .order_by(desc(Event.id)).first()
266 | )
267 |
268 | assert event.host == host
269 | assert event.event_type == event_type_d
270 |
271 | labors = Labor.get_open_unacknowledged(sample_data1)
272 | assert len(labors) == 0
273 |
274 |
275 | def test_longer_chain(sample_data2):
276 | """Test chained labors A->B->C->D"""
277 | labors = sample_data2.query(Labor).all()
278 | assert len(labors) == 0
279 |
280 | # system-maintenance audit
281 | event_type_a = sample_data2.query(EventType).get(1)
282 | # system-maintenance needed
283 | event_type_b = sample_data2.query(EventType).get(2)
284 | # system-maintenance ready
285 | event_type_c = sample_data2.query(EventType).get(3)
286 | # system-maintenance completed
287 | event_type_d = sample_data2.query(EventType).get(4)
288 |
289 | host = sample_data2.query(Host).get(1)
290 |
291 | event_a = Event.create(sample_data2, host, "system", event_type_a)
292 |
293 | # We will aggressively validate the events created only for event A
294 | event = (
295 | sample_data2.query(Event)
296 | .order_by(desc(Event.id)).first()
297 | )
298 | assert event == event_a
299 | assert event.host == host
300 | assert event.event_type == event_type_a
301 |
302 | labors = Labor.get_open_unacknowledged(sample_data2)
303 | assert len(labors) == 1
304 | assert len(host.labors) == 1
305 | assert labors[0].starting_labor_id is None
306 | assert labors[0].for_creator is False
307 | starting_labor_id = labors[0].id
308 |
309 | event_b = Event.create(sample_data2, host, "system", event_type_b)
310 | labors = Labor.get_open_unacknowledged(sample_data2)
311 | assert len(labors) == 1
312 | assert len(host.labors) == 2
313 | assert labors[0].starting_labor_id == starting_labor_id
314 | assert labors[0].for_creator is False
315 |
316 | event_c = Event.create(sample_data2, host, "system", event_type_c)
317 | labors = Labor.get_open_unacknowledged(sample_data2)
318 | assert len(labors) == 1
319 | assert len(host.labors) == 3
320 | assert labors[0].starting_labor_id == starting_labor_id
321 | assert labors[0].for_creator is True
322 |
323 | # This last event closes the final labor but does not create a new labor
324 | event_d = Event.create(sample_data2, host, "system", event_type_d)
325 | labors = Labor.get_open_unacknowledged(sample_data2)
326 | assert len(labors) == 0
327 | assert len(host.labors) == 3
328 |
329 |
330 |
331 |
332 |
333 |
--------------------------------------------------------------------------------
/tests/sample_data/sample_data1.sql:
--------------------------------------------------------------------------------
1 | INSERT INTO event_types
2 | VALUES
3 | (1,'system-reboot','required','This system requires a reboot.', 0);
4 |
5 | INSERT INTO event_types
6 | VALUES
7 | (2,'system-reboot','completed','This system rebooted.', 0);
8 |
9 | INSERT INTO event_types
10 | VALUES
11 | (3,'system-maintenance','required','This system requires maintenance.', 0);
12 |
13 | INSERT INTO event_types
14 | VALUES
15 | (4,'system-maintenance','ready','This system is ready for maintenance.', 0);
16 |
17 | INSERT INTO event_types
18 | VALUES
19 | (5,'system-maintenance','completed','System maintenance completed.', 0);
20 |
21 | INSERT INTO event_types
22 | VALUES
23 | (6,'system-shutdown','required','System shutdown required.', 0);
24 |
25 | INSERT INTO event_types
26 | VALUES
27 | (7,'system-shutdown','completed','System shutdown completed.', 0);
28 |
29 | INSERT INTO fates
30 | VALUES
31 | (1,1,NULL, 0, 1, 'Reboot or release the system');
32 |
33 | INSERT INTO fates
34 | VALUES
35 | (2,2,1, 0, 1, 'System rebooted');
36 |
37 | INSERT INTO fates
38 | VALUES
39 | (3,4,1, 0, 1, 'System released');
40 |
41 | INSERT INTO fates
42 | VALUES
43 | (4,3,NULL, 0, 1, 'Release or acknowledge downtime');
44 |
45 | INSERT INTO fates
46 | VALUES
47 | (5,4,4, 1, 0, 'Perform maintenance');
48 |
49 | INSERT INTO fates
50 | VALUES
51 | (6,5,5, 1, 0, 'Maintenance completed');
52 |
53 |
54 | INSERT INTO hosts
55 | VALUES (1, 'example.dropbox.com');
56 |
57 | INSERT INTO hosts
58 | VALUES (2, 'sample.dropbox.com');
59 |
60 | INSERT INTO hosts
61 | VALUES (3, 'test.dropbox.com');
62 |
63 | INSERT INTO events ('id', 'host_id', 'timestamp', 'user', 'event_type_id', 'note')
64 | VALUES (1, 1, "2015-04-31 10:00:00", "system", 1, "example.dropbox.com needs a reboot");
65 |
66 | INSERT INTO events ('id', 'host_id', 'timestamp', 'user', 'event_type_id', 'note')
67 | VALUES (2, 1, "2015-05-01 22:34:03", "system", 2, "example.dropbox.com rebooted.");
68 |
--------------------------------------------------------------------------------
/tests/sample_data/sample_data2.sql:
--------------------------------------------------------------------------------
1 | INSERT INTO event_types
2 | VALUES
3 | (1,'system-maintenance','audit','Audit required', 0);
4 |
5 | INSERT INTO event_types
6 | VALUES
7 | (2,'system-maintenance','needed','This system needs maintenance.', 0);
8 |
9 | INSERT INTO event_types
10 | VALUES
11 | (3,'system-maintenance','ready','This is ready for maintenance.', 0);
12 |
13 | INSERT INTO event_types
14 | VALUES
15 | (4,'system-maintenance','completed','System maintenance completed.', 0);
16 |
17 | INSERT INTO event_types
18 | VALUES
19 | (5,'system-reboot','needed','System reboot required.', 0);
20 |
21 | INSERT INTO event_types
22 | VALUES
23 | (6,'system-reboot','completed','System has rebooted.', 0);
24 |
25 | INSERT INTO event_types
26 | VALUES
27 | (7,'puppet','restart','Puppet has restarted.', 0);
28 |
29 | INSERT INTO fates
30 | VALUES
31 | (1,1,null, 0, 1, 'Audit the system.');
32 |
33 | INSERT INTO fates
34 | VALUES
35 | (2,2,1, 0, 1, 'Reboot, release the system, or authorize downtime.');
36 |
37 | INSERT INTO fates
38 | VALUES
39 | (3,3,2, 1, 0, 'Perform maintenance');
40 |
41 | INSERT INTO fates
42 | VALUES
43 | (4,4,3, 1, 0, 'Maintenance completed');
44 |
45 | INSERT INTO fates
46 | VALUES
47 | (5,6,2, 0, 1, 'System rebooted to finish maintenance');
48 |
49 | INSERT INTO fates
50 | VALUES
51 | (6,5, NULL, 0, 1, 'Reboot the system.');
52 |
53 | INSERT INTO fates
54 | VALUES
55 | (7,6, 6, 0, 1, 'Restart puppet');
56 |
57 | INSERT INTO fates
58 | VALUES
59 | (8,7,7, 1, 0, 'Puppet restarted');
60 |
61 | INSERT INTO fates
62 | VALUES
63 | (9,1,null, 0, 1, 'Release or restart puppet');
64 |
65 | INSERT INTO fates
66 | VALUES
67 | (10,7,9, 0, 1, 'System is fine. Puppet restarted.');
68 |
69 | INSERT INTO hosts
70 | VALUES (1, 'example.dropbox.com');
71 |
72 | INSERT INTO hosts
73 | VALUES (2, 'sample.dropbox.com');
74 |
75 | INSERT INTO hosts
76 | VALUES (3, 'test.dropbox.com');
--------------------------------------------------------------------------------
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 |