Moving over the snapshot API

index.js

@@ -3,5 +3,10 @@
 const Fluctor = require('./lib/fluctor');
 
 module.exports = {
-  Fluctor
+  Fluctor,
+  create: options => new Promise((resolve, reject) => {
+    let fluctor = new Fluctor(options);
+    fluctor.on('ready', resolve);
+    fluctor.on('initError', reject);
+  })
 };

lib/blockchain/blockchain.js

@@ -60,6 +60,17 @@ class BlockChain extends LinkedList{
   get Block(){
     return Block;
   }
+
+  load(state, newBlockchain, state_container) {
+    if(state)
+      state_container.rewrite(state);
+
+    newBlockchain
+      .map(block => BlockChain.Block.load(block))
+      .forEach(block => this.append(block));
+
+    this.apply(state_container);
+  }
 
 }
 

lib/comm/sync.client.js

@@ -51,10 +51,8 @@ class SyncClient extends EventEmitter {
 
     this.client.on('snapshot', snapshot => {
       if('timestamp' in snapshot){
-        console.log(new Date(), snapshot.id);
-        console.log('Before Compact', this.block_chain.toArray().length);
         this.block_chain.compact(snapshot.timestamp);
-        console.log('After Compact', this.block_chain.toArray().length);
+        this.emit('snapshot', snapshot);
       }
     });
   }

lib/fluctor.js

@@ -6,7 +6,8 @@ const SyncClient = require('./comm/sync.client');
 const Transaction = require('./transaction/transaction');
 const TransactionTransport = require('./transaction/transaction.transport');
 const BlockChain = require('./blockchain/blockchain');
-const Snapshot = require('./blockchain/snapshot');
+const Snapshot = require('./snapshot/snapshot');
+const SnapshotFactory = require('./snapshot/snapshot.factory');
 const AppenderFactory = require('./blockchain/appender.factory');
 
 class Fluctor extends EventEmitter {
@@ -27,52 +28,31 @@ class Fluctor extends EventEmitter {
 
     AppenderFactory.create('redis', this.options.connection)
       .then(appender => this.appender = appender)
+      .then(() => 
+        this.snapshot_factory = new SnapshotFactory(
+          this.state_container, 
+          this.blockchain, 
+          this.appender, 
+          this.sync_client, 
+          this.options.snapshot
+        )
+      )
       .then(() => this.blockchain.blocks.on('pushed', ({ block }) => this.appender.pushBlock(block)))
       .then(() => this.appender.load())
-      .then(({ state, blockchain }) => {
-
-        if(state)
-          this.state_container.rewrite(state);
-
-        blockchain
-          .map(block => BlockChain.Block.load(block))
-          .forEach(block => this.blockchain.append(block));
-
-        this.blockchain.apply(this.state_container);
-      })
+      .then(({ state, blockchain }) => this.blockchain.load(state, blockchain, this.state_container))
       .then(() => this.sync_client.wait.end())
       .then(() => this.emit('ready', this))
       .then(() => this.snapshot.next())
-      .catch(err => this.emit('error', err));
+      .catch(err => this.emit('initError', err));
   }
 
   _bindEventHandlers(){
     this.sync_client.on('stateChange', () => this.emit('stateChange'));
-
-    this.sync_client.client.on('snapshot', () => this.snapshot.next());
-
     this.sync_client.on('error', err => this.emit('error', err));
   }
 
   get snapshot() {
-    let _this = this;
-    return {
-      create() {
-        let snapshot = new Snapshot(_this.state, _this.blockchain.tail, _this.appender);
-        return snapshot;
-      },
-      save(snapshot) {
-        snapshot = snapshot || this.create();
-        _this.sync_client.publish.snapshot(snapshot);
-        return snapshot.push();
-      },
-      next() {
-        if(_this.nextSnapshot)
-          clearTimeout(_this.nextSnapshot);
-        let time = ( _this.options.snapshotInterval || 1000 * 60 * 60 ) + Math.random() * ( _this.options.snapshotRandom || 10000 );
-        _this.nextSnapshot = setTimeout(() => this.save(), time);
-      }
-    };
+    return this.snapshot_factory;
   }
 
   get state(){

lib/snapshot/snapshot.factory.js

@@ -0,0 +1,35 @@
+
+const Snapshot = require('./snapshot');
+
+const DEFAULTS = {
+  interval: 1000 * 60 * 60,
+  random: 1000
+};
+
+class SnapshotFactory {
+
+  constructor(state_container, blockchain, appender, sync_client, options=DEFAULTS) {
+    Object.assign(this, { state_container, blockchain, appender, sync_client, options });
+
+    sync_client.on('snapshot', () => this.next());
+  }
+
+  create(state) {
+    return new Snapshot(this.state_container.state, this.blockchain.tail, this.appender);
+  }
+
+  save(snapshot) {
+    snapshot = snapshot || this.create();
+    this.sync_client.publish.snapshot(snapshot);
+    return snapshot.push();
+  }
+
+  next() {
+    if(this.nextSnapshot)
+      clearTimeout(this.nextSnapshot);
+    let time = this.options.interval + Math.random() * this.options.random;
+    this.nextSnapshot = setTimeout(() => this.save(), time);
+  }
+}
+
+module.exports = SnapshotFactory;

lib/blockchain/snapshot.js → lib/snapshot/snapshot.js

@@ -28,6 +28,11 @@ class Snapshot {
     });
   }
 
+  static creare(state, lastBlock, appender) {
+    let snapshot = new Snapshot(state, lastBlock, appender);
+    return snapshot;
+  }
+
 }
 
 module.exports = Snapshot;

test/snapshot.test.js

@@ -8,20 +8,28 @@ chai.use(chaiAsPromised);
 const assert = chai.assert;
 const expect = chai.expect;
 
-const Fluctor = require('../lib/fluctor');
+const { create } = require('../index');
 const AppenderFactory = require('../lib/blockchain/appender.factory');
-const Snapshot = require('../lib/blockchain/snapshot');
+const Snapshot = require('../lib/snapshot/snapshot');
 
 
 describe('Snapshot', () => {
 
   let mock_appender;
+  let fluctor;
 
-  beforeEach(() => {
+  beforeEach(done => {
     mock_appender = {
       load: sinon.spy(),
       pushSnapshot: sinon.spy()
     };
+
+    create()
+      .then(f => {
+        fluctor = f;
+        done();
+      })
+      .catch(err => done(err));
   });
 
   it('Snapshot added to appender', () => {
@@ -37,17 +45,13 @@ describe('Snapshot', () => {
 
   it('Snapshot Creation API', () => {
 
-    let fluctor = new Fluctor();
-
     let snapshot = fluctor.snapshot.create();
 
     expect(snapshot).to.be.instanceOf(Snapshot);
   });
 
   it('Snapshot Save API', () => {
 
-    let fluctor = new Fluctor();
-
     let mock_snapshot = {
       push: sinon.spy()
     };