artillery-engine-skip 0.0.1

package/README.md

@@ -0,0 +1,9 @@
+# artillery-engine-skip
+
+This engine adds support for load testing [skip](https://skiplabs.io) services with Artillery.
+
+# Features
+
+- Open and tail skip streams, with custom event handlers.
+- Issue writes to the skip service's input collections.
+- Loop a fixed number of times/until a condition is met.

package/index.js

@@ -0,0 +1,147 @@
+const A = require('async');
+const { EventSource } = require('eventsource');
+const _ = require('lodash');
+const engineUtil = require('@artilleryio/int-commons').engine_util;
+
+class SkipEngine {
+    constructor(script, events, helpers) {
+        this.script = script;
+        this.helpers = helpers;
+        this.target = script.config?.target;
+        this.skipConfig = script.config?.engines?.['skip'] || {};
+
+        return this;
+    }
+
+    createScenario(spec, events) {
+        const self = this;
+
+        return (initialContext, vuDone) => {
+            const steps = [(callback) => {
+                // NOTE: This is undocumented by artillery, but required.
+                events.emit('started');
+                return callback(null, initialContext);
+            }];
+            for (const step of spec.flow) {
+                steps.push(self.step(step, events));
+            }
+
+            A.waterfall(steps, (err, context) => {
+                vuDone(err, context);
+            });
+        }
+    }
+
+    step(step, events) {
+        if (step.stream) {
+            return this.stepStream(step, events);
+        } else if (step.write) {
+            return this.stepWrite(step, events);
+        } else if (step.log) {
+            return this.stepLog(step, events);
+        } else if (step.think) {
+            return this.stepThink(step, events);
+        } else if (step.loop) {
+            return this.stepLoop(step, events);
+        } else if (step == 'close') {
+            return this.stepClose(step, events);
+        } else {
+            console.error('Unrecognized step', step);
+            return null;
+        }
+    }
+
+    stepStream(step, events) {
+        const self = this;
+        return (context, callback) => {
+            fetch(`${self.skipConfig.control_url}/v1/streams/${step.stream.resource}`, {
+                method: "POST"
+            }).then(resp => resp.text())
+                .then(uuid => {
+                    const es = new EventSource(`${self.skipConfig.stream_url}/v1/streams/${uuid}`);
+                    context.es = es;
+
+                    es.onerror = (err) => {
+                        if (err.status) {
+                            events.emit('counter', `skip.errored_streams.${err.status}`, 1)
+                        } else {
+                            events.emit('counter', 'skip.errored_streams', 1);
+                        }
+                    };
+
+                    if(step.stream.onInit) {
+                        es.addEventListener('init', (e) => {
+                            self.script.config.processor[step.stream.onInit].call(null, e, context, events);
+                        });
+                    }
+
+                    if(step.stream.onUpdate) {
+                        es.addEventListener('update', (e) => {
+                            self.script.config.processor[step.stream.onUpdate].call(null, e, context, events);
+                        });
+                    }
+
+                    es.onopen = () => {
+                        events.emit('counter', 'skip.opened_streams', 1);
+                        callback(null, context);
+                    };
+                });
+        };
+    }
+
+    stepWrite(step, events) {
+        const self = this;
+
+        return (context, callback) => {
+            const data = self.helpers.template(step.write.data, context);
+            if (step.write.hook) {
+                self.script.config.processor[step.write.hook].call(null, step.write.collection, data, context, events);
+            }
+            fetch(`${self.skipConfig.control_url}/v1/inputs/${step.write.collection}`, {
+                method: 'PATCH',
+                body: JSON.stringify(data),
+                headers: {
+                    'Content-Type': 'application/json',
+                }
+            }).then(_ => callback(null, context)).catch(e => callback(e, context));
+        };
+    }
+
+    stepLog(step, events) {
+        const self = this;
+
+        return (context, callback) => {
+            console.log(self.helpers.template(step.log, context));
+            return process.nextTick(() => callback(null, context));
+        };
+    }
+
+    stepThink(step, events) {
+        const self = this;
+
+        return this.helpers.createThink(step, self.script.config.defaults?.think || {});
+    }
+
+    stepLoop(step, events) {
+        const self = this;
+
+        const steps = _.map(step.loop, function (rs) {
+            return self.step(rs, events);
+        });
+        return engineUtil.createLoopWithCount(step.count || -1, steps, {
+            loopValue: step.loopValue || '$loopCount',
+            loopElement: step.loopElement || '$loopElement',
+            overValues: step.over,
+            whileTrue: self.script.config.processor ? self.script.config.processor[step.whileTrue] : undefined,
+        });
+    }
+
+    stepClose(step, events) {
+        return (context, callback) => {
+            context.es?.close();
+            callback(null, context);
+        };
+    }
+}
+
+module.exports = SkipEngine;

package/package.json

@@ -0,0 +1,15 @@
+{
+  "name": "artillery-engine-skip",
+  "version": "0.0.1",
+  "description": "Skip support for Artillery",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "keywords": [],
+  "author": "Lucas Hosseini <lucas@skiplabs.io>",
+  "dependencies": {
+    "async": "^3.2.4",
+    "eventsource": "^3.0.6"
+  }
+}