[WIP] 0.6 new gekko events

core/budfox/budfox.js

@@ -42,26 +42,25 @@ var BudFox = function(config) {
     this.candleManager.processTrades
   );
 
+  // relay a marketUpdate event
+  this.marketDataProvider.on(
+    'marketUpdate',
+    e => this.emit('marketUpdate', e)
+  );
+
+  // relay a marketStart event
+  this.marketDataProvider.on(
+    'marketStart',
+    e => this.emit('marketStart', e)
+  );
+
   // Output the candles
   this.candleManager.on(
     'candles',
     this.pushCandles
   );
 
   this.heart.pump();
-
-  //    Budfox also reports:
-
-  // Trades & last trade
-  //
-  // this.marketDataProvider.on(
-  //   'trades',
-  //   this.broadcast('trades')
-  // );
-  // this.marketDataProvider.on(
-  //   'trades',
-  //   this.broadcastTrade
-  // );
 }
 
 var Readable = require('stream').Readable;
@@ -76,18 +75,4 @@ BudFox.prototype.pushCandles = function(candles) {
   _.each(candles, this.push);
 }
 
-// BudFox.prototype.broadcastTrade = function(trades) {
-//   _.defer(function() {
-//     this.emit('trade', trades.last);
-//   }.bind(this));
-// }
-
-// BudFox.prototype.broadcast = function(message) {
-//   return function(payload) {
-//     _.defer(function() {
-//       this.emit(message, payload);
-//     }.bind(this));
-//   }.bind(this);
-// }
-
 module.exports = BudFox;

core/budfox/candleManager.js

@@ -21,10 +21,6 @@ var Manager = function() {
 
   this.candleCreator
     .on('candles', this.relayCandles);
-
-  this.messageFirstCandle = _.once(candle => {
-    cp.firstCandle(candle);
-  })
 };
 
 util.makeEventEmitter(Manager);
@@ -34,12 +30,6 @@ Manager.prototype.processTrades = function(tradeBatch) {
 
 Manager.prototype.relayCandles = function(candles) {
   this.emit('candles', candles);
-
-  if(!_.size(candles))
-    return;
-
-  this.messageFirstCandle(_.first(candles));
-  cp.lastCandle(_.last(candles));
 }
 
 module.exports = Manager;

core/budfox/marketDataProvider.js

@@ -35,12 +35,12 @@ Manager.prototype.retrieve = function() {
 Manager.prototype.relayTrades = function(batch) {
   this.emit('trades', batch);
 
-  this.sendStartAt(batch);
-  cp.update(batch.last.date.format());
+  this.sendMarketStart(batch);
+  this.emit('marketUpdate', batch.last.date);
 }
 
-Manager.prototype.sendStartAt = _.once(function(batch) {
-  cp.startAt(batch.first.date.format())
+Manager.prototype.sendMarketStart = _.once(function(batch) {
+  this.emit('marketStart', batch.first.date);
 });
 
 module.exports = Manager;

core/cp.js

@@ -16,24 +16,6 @@ var message = (type, payload) => {
 }
 
 var cp = {
-  // string like: '2016-12-03T22:23:00.000Z'
-  update: latest => message('update', { latest }),
-  startAt: startAt => message('startAt', { startAt }),
-
-  // object like:
-  //
-  // {
-  //   start: '2016-12-03T22:23:00.000Z',
-  //   open: 765,
-  //   high: 765,
-  //   low: 765,
-  //   close: 765,
-  //   vwp: 765,
-  //   volume: 0,
-  //   trades: 0
-  // }
-  lastCandle: lastCandle => message('lastCandle', { lastCandle }),
-  firstCandle: firstCandle => message('firstCandle', { firstCandle }),
 
   // object like:
   //

core/gekkoStream.js

@@ -46,7 +46,7 @@ Gekko.prototype.shutdown = function() {
       if (c.finalize) c.finalize(callback);
       else callback();
     },
-    function() {
+    () => {
       // If we are a child process, we signal to the parent to kill the child once it is done
       // so that is has time to process all remaining events (and send report data)
       if (env === 'child-process') process.send('done');

core/pipeline.js

@@ -44,6 +44,8 @@ var pipeline = (settings) => {
   // and how they should hooked up to consumers.
   var subscriptions = require(dirs.gekko + 'subscriptions');
 
+  var market;
+
   // Instantiate each enabled plugin
   var loadPlugins = function(next) {
     // load all plugins
@@ -74,7 +76,6 @@ var pipeline = (settings) => {
 
   // Subscribe all plugins to other emitting plugins
   var subscribePlugins = function(next) {
-
     // events broadcasted by plugins
     var pluginSubscriptions = _.filter(
       subscriptions,
@@ -88,8 +89,9 @@ var pipeline = (settings) => {
       pluginSubscriptions.filter(s => _.isArray(s.emitter)),
       subscription => {
         var singleEventEmitters = subscription.emitter
-          .filter(s => _.size(plugins.filter(p => p.meta.slug === s)
-        ));
+          .filter(
+            s => _.size(plugins.filter(p => p.meta.slug === s))
+          );
 
         if(_.size(singleEventEmitters) > 1) {
           var error = `Multiple plugins are broadcasting`;
@@ -107,7 +109,7 @@ var pipeline = (settings) => {
     _.each(plugins, function(plugin) {
       _.each(pluginSubscriptions, function(sub) {
 
-        if(_.has(plugin, sub.handler)) {
+        if(plugin[sub.handler]) {
 
           // if a plugin wants to listen
           // to something disabled
@@ -143,27 +145,65 @@ var pipeline = (settings) => {
     _.each(plugins, function(plugin) {
       _.each(marketSubscriptions, function(sub) {
 
-        // for now, only subscribe to candles
-        if(sub.event !== 'candle')
-          return;
-
-        if(_.has(plugin, sub.handler))
-          candleConsumers.push(plugin);
+        if(plugin[sub.handler]) {
+          if(sub.event === 'candle')
+            candleConsumers.push(plugin);
+        }
 
       });
     });
 
     next();
   }
 
-  // TODO: move this somewhere where it makes more sense
   var prepareMarket = function(next) {
     if(mode === 'backtest' && config.backtest.daterange === 'scan')
       require(dirs.core + 'prepareDateRange')(next);
     else
       next();
   }
 
+  var setupMarket = function(next) {
+    // load a market based on the config (or fallback to mode)
+    let marketType;
+    if(config.market)
+      marketType = config.market.type;
+    else
+      marketType = mode;
+
+    var Market = require(dirs.markets + marketType);
+
+    market = new Market(config);
+
+    next();
+  }
+
+  var subscribePluginsToMarket = function(next) {
+
+    // events broadcasted by the market
+    var marketSubscriptions = _.filter(
+      subscriptions,
+      {emitter: 'market'}
+    );
+
+    _.each(plugins, function(plugin) {
+      _.each(marketSubscriptions, function(sub) {
+
+        if(sub.event === 'candle')
+          // these are handled via the market stream
+          return;
+
+        if(plugin[sub.handler]) {
+          market.on(sub.event, plugin[sub.handler]);
+        }
+
+      });
+    });
+
+    next();
+
+  }
+
   log.info('Setting up Gekko in', mode, 'mode');
   log.info('');
 
@@ -172,19 +212,12 @@ var pipeline = (settings) => {
       loadPlugins,
       referenceEmitters,
       subscribePlugins,
-      prepareMarket
+      prepareMarket,
+      setupMarket,
+      subscribePluginsToMarket
     ],
     function() {
-      // load a market based on the config (or fallback to mode)
-      let marketType;
-      if(config.market)
-        marketType = config.market.type;
-      else
-        marketType = mode;
-
-      var Market = require(dirs.markets + marketType);
-
-      var market = new Market(config);
+
       var gekko = new GekkoStream(candleConsumers);
 
       market

docs/extending/add_a_plugin.md

@@ -21,66 +21,11 @@ Note that in order to use custom plugins, you have to run Gekko over [the comman
 
 *And more! Take a look in the `gekko/plugins folder.`*
 
-## What kind of events can I listen to?
-
-Note that these are low level internal events to the plugin system, they have overlap with the websocket events being streamed to the UI but are not the same.
-
-- `candle`: Every time Gekko calculated a new 1 minute candle from the market.
-- `advice`: Every time the trading strategy has new advice.
-- `trade`: Every time a trading plugin (either the live trader or the paper trader) has completed a trade.
-- `portfolioUpdate`: Is broadcasted once a trading plugin has an updated portflio.
-
-Each of these events contains a javascript object describing the latest data.
-
 ## Implementing a new plugin
 
 If you want to add your own plugin you need to expose a constructor function inside
 `plugins/[slugname of plugin].js`. The object needs methods based on which event you want
-to listen to:
-
-- market feed / candle: `processCandle(candle, callback)`.
-  This method will be fed a minute candles like:
-
-      {
-        start: [moment object of the start time of the candle],
-        open: [number, open of candle],
-        high: [number, high of candle],
-        low: [number, low of candle],
-        close: [number, close of candle],
-        vwp: [number, average weighted price of candle],
-        volume: [number, total volume volume],
-        trades: [number, amount of trades]
-      }
-
-  As well as a callback method. You are required to call this method
-  once you are done processing the candle.
-
-- advice feed / advice `processAdvice(advice)`:
-  This method will be fed an advice like:
-
-      {
-        recommendation: [position to take, either long or short],
-        portfolio: [amount of portfolio you should move to position] **DECREPATED**
-      }
-
-- trading feed / trade `processTrade(trade)`:
-  This method will be fed a trade like:
-
-      {
-        action: [either "buy" or "sell"],
-        price: [number, price that was sold at],
-        date: [moment object, exchange time trade completed at],
-        portfolio: [object containing amount in currency and asset],
-        balance: [number, total worth of portfolio]
-      }
-
-- trading feed / portfolioUpdate `portfolioUpdate(portfolio)`:
-  This method will be fed an portfolioUpdate like:
-
-      {
-        currency: [number, portfolio amount of currency],
-        asset: [number, portfolio amount of asset]
-      }
+to listen to. All events can be found in [the events page](../architecture/events.md).
 
 You also need to add an entry for your plugin inside `plugins.js` which registers your plugin for use with Gekko. Finally you need to add a configuration object to `sample-config.js` with at least:
 

docs/internals/architecture.md

@@ -11,7 +11,7 @@ Communicaton between those two components is handled by Node.JS' [Stream API](ht
 
 ## A Market
 
-All markets in Gekko eventually output `candle` data. Where these candles come from and how old they are does not matter to the GekkoStream they get piped into. On default Gekko looks for markets in the [`core/markets/` directory](https://github.com/askmike/gekko/tree/stable/core/markets) (but changing that is [not too hard](https://github.com/askmike/gekko/blob/72a858339afb5a856179c716ec4ea13070a6c87c/gekko.js#L48-L49)). The top orange block in the picture is a BudFox market (the default).
+All markets in Gekko eventually output `candle` data. Where these candles come from and how old they are does not matter to the GekkoStream they get piped into. On default Gekko looks for markets in the [`core/markets/` directory](https://github.com/askmike/gekko/tree/stable/core/markets). The top orange block in the picture is a BudFox market (the default semi-realtime market that gets live data from exchanges).
 
 Example Markets that come included with Gekko are:
 
@@ -23,7 +23,7 @@ Example Markets that come included with Gekko are:
 
 A GekkoStream is nothing more than a collection of [plugins](../commandline/plugins.md). Plugins are simple modules that can subscribe to events, and do something based on event data. The most basic event every GekkoStream has is the "candle" event, this event comes from the market.
 
-However **plugins are allowed to broadcast their own events, which other plugins can subscribe to**. An example of this is the `tradingAdvisor` plugin. This plugin will implement a [trading method](https://github.com/askmike/gekko/blob/stable/docs/Trading_methods.md) that will be fed candle data. As soon as the trading method suggests to take a certain position in the market ("I detect an uptrend, I advice to go **long**") it will broadcast an `advice` event. The `paperTrader` is a plugin that simulates trading using these advices, the `trader` is a plugin that creates real market orders based on these advices. You can decide to only turn the `paperTrader` on or to turn the `trader` on (you now have a live trading bot).
+However **plugins are allowed to broadcast their own events, which other plugins can subscribe to**. An example of this is the `tradingAdvisor` plugin. This plugin will implement a [strategy](../strategies/example_strategies) that will be fed candle data. As soon as the strategy suggests to take a certain position in the market ("I detect an uptrend, I advice to go **long**") it will broadcast an `advice` event. The `paperTrader` is a plugin that simulates trading using these advices, the `trader` is a plugin that creates real market orders based on these advices. You can decide to only turn the `paperTrader` on or to turn the `trader` on (you now have a live trading bot).
 
 When you run a backtest using Gekko the following things happen:
 
@@ -35,7 +35,7 @@ When you run a backtest using Gekko the following things happen:
 
 ## Plugins & Adapters
 
-Those two core components describe the majority of Gekko's flow. A lot "core functionality" like saving candles to disk are simply plugins that push all candles to a database adapter.
+Those two core components describe the majority of Gekko's flow. A lot "core functionality" like saving candles to disk are simply plugins that push all candles to a database.
 
 ## Seperated architecture