Add event subscriptions

Author: silas

lib/marathon.js

@@ -12,6 +12,8 @@ var rapi = require('rapi');
 var util = require('util');
 
 var Apps = require('./marathon/apps').Apps;
+var EventSubscriptions = require('./marathon/event_subscriptions')
+  .EventSubscriptions;
 
 /**
  * Initialize a new `Marathon` client.
@@ -35,6 +37,7 @@ function Marathon(options) {
   rapi.Rapi.call(this, options);
 
   this.apps = new Apps(this);
+  this.eventSubscriptions = new EventSubscriptions(this);
 }
 
 util.inherits(Marathon, rapi.Rapi);

lib/marathon/apps.js

@@ -17,10 +17,7 @@ function Apps(marathon) {
  */
 
 Apps.prototype.create = function(options, callback) {
-  if (typeof options === 'function') {
-    callback = options;
-    options = {};
-  }
+  options = options || {};
 
   this.marathon.emit('debug', 'apps.create', options);
 

lib/marathon/event_subscriptions.js

@@ -0,0 +1,95 @@
+/**
+ * Event subscriptions
+ */
+
+'use strict';
+
+/**
+ * Initialize a new `EventSubscriptions` client.
+ */
+
+function EventSubscriptions(marathon) {
+  this.marathon = marathon;
+}
+
+/**
+ * Register a callback URL as an event subscriber.
+ */
+
+EventSubscriptions.prototype.register = function(options, callback) {
+  if (typeof options === 'string') {
+    options = { url: options };
+  }
+
+  this.marathon.emit('debug', 'eventSubscriptions.register', options);
+
+  if (!options.url) return callback(new Error('url required'));
+
+  var req = {
+    method: 'POST',
+    path: '/eventSubscriptions',
+    query: { callbackUrl: options.url },
+  };
+
+  this.marathon.request(req, function(err) {
+    if (err) return callback(err);
+
+    callback();
+  });
+};
+
+/**
+ * List all event subscriber callback URLs.
+ */
+
+EventSubscriptions.prototype.list = function(options, callback) {
+  if (typeof options === 'function') {
+    callback = options;
+    options = {};
+  }
+
+  this.marathon.emit('debug', 'eventSubscriptions.list', options);
+
+  var req = {
+    method: 'GET',
+    path: '/eventSubscriptions',
+  };
+
+  this.marathon.request(req, function(err, res) {
+    if (err) return callback(err);
+
+    callback(null, res.body.callbackUrls);
+  });
+};
+
+/**
+ * Unregister a callback URL from the event subscribers list.
+ */
+
+EventSubscriptions.prototype.unregister = function(options, callback) {
+  if (typeof options === 'string') {
+    options = { url: options };
+  }
+
+  this.marathon.emit('debug', 'eventSubscriptions.unregister', options);
+
+  if (!options.url) return callback(new Error('url required'));
+
+  var req = {
+    method: 'DELETE',
+    path: '/eventSubscriptions',
+    query: { callbackUrl: options.url },
+  };
+
+  this.marathon.request(req, function(err) {
+    if (err) return callback(err);
+
+    callback();
+  });
+};
+
+/**
+ * Module Exports.
+ */
+
+exports.EventSubscriptions = EventSubscriptions;

test/helper.js

@@ -63,9 +63,38 @@ function waitOnTask(marathon, id, callback) {
   );
 }
 
+/**
+ * Marathon cleanup
+ */
+
+function cleanMarathon(test, callback) {
+  var jobs = {};
+
+  jobs.eventSubscriptions = function(cb) {
+    test.marathon.eventSubscriptions.unregister(test.callbackUrl, cb);
+  };
+
+  jobs.list = test.marathon.apps.list.bind(test);
+
+  jobs.destroy = ['list', function(cb, results) {
+    var ids = results.list.map(function(app) {
+      return app.id;
+    }).filter(function(id) {
+      return id.match(/^test-/);
+    });
+
+    if (!ids.length) return cb();
+
+    async.map(ids, test.marathon.apps.destroy.bind(test), cb);
+  }];
+
+  async.auto(jobs, callback);
+}
+
 /**
  * Module Exports.
  */
 
 exports.debug = debugBuffer;
 exports.waitOnTask = waitOnTask;
+exports.cleanMarathon = cleanMarathon;

test/marathon.js

@@ -5,6 +5,7 @@
  */
 
 var async = require('async');
+var http = require('http');
 var should = require('should');
 var uuid = require('node-uuid');
 
@@ -35,33 +36,146 @@ describe('Marathon', function() {
       instances: 1,
     };
 
-    self.marathon.apps.create(options, function(err) {
-      should.not.exist(err);
+    self.events = [];
 
-      done();
+    self.http = http.createServer(function(req, res) {
+      var chunks = [];
+      var bodyLength = 0;
+
+      req.on('data', function(chunk) {
+       chunks.push(chunk);
+       bodyLength += chunk.length;
+      });
+
+      req.on('end', function() {
+        var body = Buffer.concat(chunks, bodyLength).toString();
+
+        self.events.push({
+          path: req.url,
+          body: body,
+        });
+
+        res.writeHead(200);
+        res.end();
+      });
     });
+
+    var eventHost = process.env.EVENT_HOST || '10.141.141.1';
+    var eventPort = process.env.EVENT_PORT || 8088;
+
+    self.callbackUrl = 'http://' + eventHost + ':' + eventPort + '/callback';
+
+    var jobs = {};
+
+    jobs.httpListen = function(cb) {
+      self.http.listen(eventPort, eventHost, cb);
+    };
+
+    jobs.clean = function(cb) {
+      helper.cleanMarathon(self, cb);
+    };
+
+    jobs.app = ['clean', function(cb) {
+      self.marathon.apps.create(options, function(err) {
+        should.not.exist(err);
+
+        cb();
+      });
+    }];
+
+    async.auto(jobs, done);
   });
 
   after(function(done) {
+    this.http.close();
+
+    helper.cleanMarathon(this, done);
+  });
+
+  it('should handle event subscription', function(done) {
     var self = this;
 
-    var jobs = {};
+    var id = 'test-' + uuid.v4();
 
-    jobs.list = self.marathon.apps.list.bind(self);
+    var jobs = [];
 
-    jobs.destroy = ['list', function(cb, results) {
-      var ids = results.list.map(function(app) {
-        return app.id;
-      }).filter(function(id) {
-        return id.match(/^test-/);
+    jobs.push(function(cb) {
+      self.marathon.eventSubscriptions.list(function(err, data) {
+        should.not.exist(err);
+
+        should(data).be.instanceof(Array);
+
+        data.should.not.containEql(self.callbackUrl);
+
+        cb();
       });
+    });
 
-      if (!ids.length) return cb();
+    jobs.push(function(cb) {
+      self.marathon.eventSubscriptions.register(self.callbackUrl, cb);
+    });
 
-      async.map(ids, self.marathon.apps.destroy.bind(self), cb);
-    }];
+    jobs.push(function(cb) {
+      self.marathon.eventSubscriptions.list(function(err, data) {
+        should.not.exist(err);
 
-    async.auto(jobs, done);
+        should(data).be.instanceof(Array);
+
+        data.should.containEql(self.callbackUrl);
+
+        cb();
+      });
+    });
+
+    jobs.push(function(cb) {
+      var options = {
+        id: id,
+        cmd: 'sleep 123',
+        cpus: 1,
+        mem: 16,
+        instances: 1,
+      };
+
+      self.marathon.apps.create(options, function(err) {
+        should.not.exist(err);
+
+        cb();
+      });
+    });
+
+    jobs.push(function(cb) {
+      async.retry(
+        100,
+        function(cb) {
+          if (!self.events.length) {
+            var err = new Error('No events found');
+            return setTimeout(function() { cb(err); }, 100);
+          }
+
+          cb();
+        },
+        cb
+      );
+    });
+
+    async.series(jobs, function(err) {
+      should.not.exist(err);
+
+      var events = self.events;
+
+      events.should.not.eql([]);
+
+      events = events.filter(function(res) {
+        var data = res && res.body && JSON.parse(res.body);
+
+        return data.eventType === 'api_post_event' && data.appDefinition &&
+          data.appDefinition.id === id;
+      });
+
+      events.should.not.eql([]);
+
+      done();
+    });
   });
 
   it('should return all tasks', function(done) {