Merge pull request #3 from moxious/v0.4.0

V0.4.0

Author: moxious

README.md

@@ -75,6 +75,17 @@ Create a lot of nodes as fast as possible:
 npm run graph-workload -- -a localhost -u neo4j -p admin --query 'Unwind range(1,1000000) as id create (n);' -n 50 --concurrency 4
 ```
 
+# Neo4j 4.0 / Multidatabase
+
+As of Neo4j 4.0, sessions support multi-database.  Use the `-d` or `--database` argument to direct
+where the workload should go.  By default, the workload goes to the default database (usually `neo4j`).
+
+Example:
+
+```
+npm run graph-workload -- -a neo4j://my-cluster -u neo4j -p admin --database mydb
+```
+
 # Tests
 
 ```

package.json

@@ -1,6 +1,6 @@
 {
   "name": "graph-workload",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Tool for generating workloads running on Neo4j",
   "main": "src/run-workload.js",
   "scripts": {
@@ -23,9 +23,9 @@
     "es6-promise-pool": "^2.5.0",
     "faker": "^4.1.0",
     "generic-pool": "^3.6.1",
-    "lodash": "^4.17.11",
+    "lodash": "^4.17.15",
     "moment": "^2.24.0",
-    "neo4j-driver": "^1.7.2",
+    "neo4j-driver": "^4.0.1",
     "randomstring": "^1.1.5",
     "uuid": "^3.3.2",
     "yargs": "^12.0.5"

src/Strategy.js

@@ -9,6 +9,18 @@ class Strategy {
         this.timings = [];
     }
 
+    sessionOptions() {
+        const opts = {};
+
+        if (this.props.runConfig && this.props.runConfig.database) {
+            opts.database = this.props.runConfig.database;
+        } else if (!this.props.runConfig) {
+            throw new Error('Strategy initialized without runConfig');
+        }
+
+        return opts;
+    }
+
     setup(driver) { 
         this.driver = driver;
         return Promise.resolve(true); 
@@ -65,6 +77,16 @@ class Strategy {
         console.log(`${this.name}: ${runs} runs avg ${avgV.toFixed(2)} ms min ${minV} ms max ${maxV} ms\n`);
     }
 
+    ignore(e, match) {
+        const str = `${e}`;
+
+        if (str.indexOf(match) > -1) {
+            return true;
+        }
+
+        throw e;
+    }
+
     time(somePromiseFunc, data={}) {
         const start = new Date().getTime();
 

src/read-strategy/RandomAccessReadStrategy.js

@@ -1,23 +1,24 @@
 const Strategy = require('../Strategy');
+const neo4j = require('neo4j-driver');
 
 class RandomAccessReadStrategy extends Strategy {
     constructor(props) {
         super(props);
         this.name = 'RandomAccessRead';
-        this.prime = props.prime || 1093;
-        this.limit = props.limit || 50;
+        this.prime = neo4j.int(props.prime || 1093);
+        this.limit = neo4j.int(props.limit || 50);
     }
 
     run() {
-        const nth = Math.floor(Math.random() * this.prime) + 1;
-        const skip = Math.floor(Math.random() * 1000) + 1;
+        const nth = neo4j.int(Math.floor(Math.random() * this.prime) + 1);
+        const skip = neo4j.int(Math.floor(Math.random() * 1000) + 1);
 
         const f = (s) => s.readTransaction(tx => tx.run(`
             MATCH (node)
             WHERE id(node) % $prime = $nth
             RETURN keys(node)
             SKIP $skip LIMIT $limit`,
-            { prime: this.prime, nth, skip, limit: this.limit }));
+            {  prime: this.prime, nth, skip, limit: this.limit }));
 
         return this.time(f);
     }

src/run-configuration.js

@@ -125,6 +125,7 @@ const generateFromArgs = (args) => {
         checkpointFreq: args.checkpoint || process.env.CHECKPOINT_FREQUENCY || 5000,
         failFast,
         phase: 'NOT_STARTED',
+        database: args.database || args.d || null,
     }, terminationType, probabilityTable, connectionDetails, concurrency);
 
     if (obj.runType === 'counted') {
@@ -147,6 +148,7 @@ module.exports = {
             .describe('a', 'address to connect to')
             .describe('u', 'username')
             .describe('p', 'password')
+            .describe('d', 'database')
             .describe('n', 'number of hits on the database')
             .describe('ms', 'number of milliseconds to execute')
             .describe('workload', 'absolute path to JSON probability table/workload')

src/sessionPool.js

@@ -11,7 +11,7 @@ let sessionPool = null;
  * ones who are pulling these sessions.
  */
 module.exports = {
-    getPool: (driver, poolSize) => {
+    getPool: (driver, options) => {
         if (sessionPool) {
             return sessionPool;
         }
@@ -20,7 +20,11 @@ module.exports = {
         // See the generic-pool module for more details.
         const factory = {
             create: () => {
-                const s = driver.session();
+                const config = {};
+                if (options.database) {
+                    config.database = options.database;
+                }
+                const s = driver.session(config);
                 return s;
             },
             destroy: session => {
@@ -32,7 +36,7 @@ module.exports = {
                     .catch(err => false),
         };
 
-        const sessionPoolOpts = { min: 1, max: poolSize };
+        const sessionPoolOpts = { min: 1, max: options.concurrency || 10 };
         console.log('Creating session pool with ', sessionPoolOpts);
         sessionPool = genericPool.createPool(factory, sessionPoolOpts);
         sessionPool.on('factoryCreateError', err => console.log('SESSION POOL ERROR', err));

src/strategies.js

@@ -26,21 +26,21 @@ const RandomAccessReadStrategy = require('./read-strategy/RandomAccessReadStrate
 const builder = (sessionPool, runConfig) => {
     const defaultStratTable = {
         // WRITE STRATEGIES
-        naryWrite: new NAryTreeStrategy({ n: 2, sessionPool }),
-        fatnodeWrite: new FatNodeAppendStrategy({ sessionPool }),
-        mergeWrite: new MergeWriteStrategy({ n: 1000000, sessionPool }),
-        rawWrite: new RawWriteStrategy({ n: 10, sessionPool }),
-        randomLinkage: new RandomLinkageStrategy({ n: 1000000, sessionPool }),
-        starWrite: new StarWriteStrategy({ sessionPool }),
-        indexHeavy: new IndexHeavyStrategy({ sessionPool }),
-        lockTorture: new LockTortureStrategy({ sessionPool }),
-        luceneWrite: new LuceneWriteStrategy({ sessionPool }),
+        naryWrite: new NAryTreeStrategy({ n: 2, sessionPool, runConfig }),
+        fatnodeWrite: new FatNodeAppendStrategy({ sessionPool, runConfig }),
+        mergeWrite: new MergeWriteStrategy({ n: 1000000, sessionPool, runConfig }),
+        rawWrite: new RawWriteStrategy({ n: 10, sessionPool, runConfig }),
+        randomLinkage: new RandomLinkageStrategy({ n: 1000000, sessionPool, runConfig }),
+        starWrite: new StarWriteStrategy({ sessionPool, runConfig }),
+        indexHeavy: new IndexHeavyStrategy({ sessionPool, runConfig }),
+        lockTorture: new LockTortureStrategy({ sessionPool, runConfig }),
+        luceneWrite: new LuceneWriteStrategy({ sessionPool, runConfig }),
 
         // READ STRATEGIES
-        aggregateRead: new AggregateReadStrategy({ sessionPool }),
-        metadataRead: new MetadataReadStrategy({ sessionPool }),
-        longPathRead: new LongPathReadStrategy({ sessionPool }),
-        randomAccess: new RandomAccessReadStrategy({ sessionPool }),
+        aggregateRead: new AggregateReadStrategy({ sessionPool, runConfig }),
+        metadataRead: new MetadataReadStrategy({ sessionPool, runConfig }),
+        longPathRead: new LongPathReadStrategy({ sessionPool, runConfig }),
+        randomAccess: new RandomAccessReadStrategy({ sessionPool, runConfig }),
     };
 
     if (runConfig) {

src/workload.js

@@ -1,7 +1,7 @@
 const pool = require('./sessionPool');
 const strategies = require('./strategies');
 const WorkloadStats = require('./stats');
-const neo4j = require('neo4j-driver').v1;
+const neo4j = require('neo4j-driver');
 const uuid = require('uuid');
 const PromisePool = require('es6-promise-pool');
 
@@ -65,7 +65,7 @@ class Workload {
     this.driver = neo4j.driver(this.runConfig.address,
       neo4j.auth.basic(this.runConfig.username, this.runConfig.password));
 
-    this.sessionPool = pool.getPool(this.driver, this.runConfig.concurrency);
+    this.sessionPool = pool.getPool(this.driver, this.runConfig);
     this.strategyTable = strategies.builder(this.sessionPool, this.runConfig);
     this.stats = new WorkloadStats(this.runConfig);
 

src/write-strategy/IndexHeavyStrategy.js

@@ -14,7 +14,7 @@ class IndexHeavyStrategy extends Strategy {
 
     setup(driver) {
         super.setup(driver);
-        const session = driver.session();
+        const session = driver.session(this.sessionOptions());
 
         const queries = [
             'CREATE INDEX ON :Customer(id)',
@@ -40,8 +40,12 @@ class IndexHeavyStrategy extends Strategy {
             'CREATE INDEX ON :Address(score)',
         ];
 
-        return Promise.map(queries, q => session.run(q))
-            .then(() => session.close());
+        return Promise.all(queries.map(q => {
+            const session = driver.session(this.sessionOptions());
+            return session.run(q)
+                .then(() => session.close())
+                .catch(e => this.ignore(e, 'An equivalent index already exists'));
+        }));
     }
 
     run() {

src/write-strategy/LockTortureStrategy.js

@@ -19,7 +19,7 @@ class LockTortureStrategy extends Strategy {
 
     setup(driver) {
         super.setup(driver);
-        const session = driver.session();
+        const session = driver.session(this.sessionOptions());
 
         // Set up some basic nodes and index.
         const queries = [