@splitsoftware/splitio 10.17.3-rc.3 → 10.17.3-rc.4

package/lib/engine/engine/index.js

@@ -0,0 +1,71 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _logger = _interopRequireDefault(require("../../utils/logger"));
+
+var _legacy = _interopRequireDefault(require("./legacy"));
+
+var _murmur = _interopRequireDefault(require("./murmur3/murmur3"));
+
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+var log = (0, _logger.default)('splitio-engine');
+var MURMUR_ID = 2;
+/**
+ * Returns the bucket function by algoId.
+ */
+
+function getBucketAlgo(algoId) {
+  if (algoId === MURMUR_ID) {
+    return _murmur.default.bucket;
+  } else {
+    return _legacy.default.bucket;
+  }
+}
+
+var engine = {
+  /**
+   * Get the treatment name given a key, a seed, and the percentage of each treatment.
+   */
+  getTreatment: function getTreatment(key, seed, treatments, algoId) {
+    var bucket = getBucketAlgo(algoId)(key, seed);
+    var treatment = treatments.getTreatmentFor(bucket);
+    log.debug("[engine] using algo " + (algoId !== MURMUR_ID ? 'legacy' : 'murmur') + " bucket " + bucket + " for key " + key + " using seed " + seed + " - treatment " + treatment);
+    return treatment;
+  },
+
+  /**
+   * Evaluates the traffic allocation to see if we should apply rollout conditions or not.
+   */
+  shouldApplyRollout: function shouldApplyRollout(trafficAllocation, key, trafficAllocationSeed, algoId) {
+    // For rollout, if traffic allocation for splits is 100%, we don't need to filter it because everything should evaluate the rollout.
+    if (trafficAllocation < 100) {
+      var bucket = getBucketAlgo(algoId)(key, trafficAllocationSeed);
+
+      if (bucket > trafficAllocation) {
+        return false;
+      }
+    }
+
+    return true;
+  }
+};
+var _default = engine;
+exports.default = _default;

package/lib/engine/engine/legacy.js

@@ -0,0 +1,83 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+/**
+Copyright 2016 Split Software
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+**/
+//
+// JAVA reference implementation for the hashing function.
+//
+// int h = 0;
+// for (int i = 0; i < key.length(); i++) {
+//     h = 31 * h + key.charAt(i);
+// }
+// return h ^ seed; // XOR the hash and seed
+//
+function ToInteger(x) {
+  x = Number(x);
+  return x < 0 ? Math.ceil(x) : Math.floor(x);
+}
+
+function modulo(a, b) {
+  return a - Math.floor(a / b) * b;
+}
+
+function ToUint32(x) {
+  return modulo(ToInteger(x), Math.pow(2, 32));
+}
+
+function ToInt32(x) {
+  var uint32 = ToUint32(x);
+
+  if (uint32 >= Math.pow(2, 31)) {
+    return uint32 - Math.pow(2, 32);
+  } else {
+    return uint32;
+  }
+}
+
+function hash(str
+/*: string */
+, seed
+/*: number */
+)
+/*: number */
+{
+  var h = 0;
+
+  for (var i = 0; i < str.length; i++) {
+    h = ToInt32(ToInt32(31 * h) + str.charCodeAt(i));
+  }
+
+  return ToInt32(h ^ seed);
+}
+
+function bucket(str
+/*: string */
+, seed
+/*: number */
+)
+/*: number */
+{
+  return Math.abs(hash(str, seed) % 100) + 1;
+}
+
+var _default = {
+  hash: hash,
+  bucket: bucket
+};
+exports.default = _default;

package/lib/engine/engine/murmur3/common.js

@@ -0,0 +1,52 @@
+"use strict";
+
+exports.__esModule = true;
+exports.UTF16ToUTF8 = UTF16ToUTF8;
+exports.x86Multiply = x86Multiply;
+exports.x86Rotl = x86Rotl;
+exports.x86Fmix = x86Fmix;
+
+var _utfx = require("./utfx");
+
+function UTF16ToUTF8(key) {
+  var sd;
+  (0, _utfx.encodeUTF16toUTF8)((0, _utfx.stringSource)(key), sd = (0, _utfx.stringDestination)());
+  return sd();
+}
+/*!
+ * +----------------------------------------------------------------------------------+
+ * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
+ * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
+ * |----------------------------------------------------------------------------------|
+ * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
+ * +----------------------------------------------------------------------------------+
+ */
+
+
+function x86Multiply(m, n) {
+  //
+  // Given two 32bit ints, returns the two multiplied together as a
+  // 32bit int.
+  //
+  return (m & 0xffff) * n + (((m >>> 16) * n & 0xffff) << 16);
+}
+
+function x86Rotl(m, n) {
+  //
+  // Given a 32bit int and an int representing a number of bit positions,
+  // returns the 32bit int rotated left by that number of positions.
+  //
+  return m << n | m >>> 32 - n;
+}
+
+function x86Fmix(h) {
+  //
+  // Given a block, returns murmurHash3's final x86 mix of that block.
+  //
+  h ^= h >>> 16;
+  h = x86Multiply(h, 0x85ebca6b);
+  h ^= h >>> 13;
+  h = x86Multiply(h, 0xc2b2ae35);
+  h ^= h >>> 16;
+  return h;
+}

package/lib/engine/engine/murmur3/murmur3.js

@@ -0,0 +1,90 @@
+"use strict";
+
+exports.__esModule = true;
+exports.default = void 0;
+
+var _common = require("./common");
+
+/* eslint-disable no-fallthrough */
+
+/*!
+ * +----------------------------------------------------------------------------------+
+ * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
+ * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
+ * |----------------------------------------------------------------------------------|
+ * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
+ * +----------------------------------------------------------------------------------+
+ */
+// PUBLIC FUNCTIONS
+// ----------------
+function hash32(key, seed) {
+  //
+  // Given a string and an optional seed as an int, returns a 32 bit hash
+  // using the x86 flavor of MurmurHash3, as an unsigned int.
+  //
+  key = key || '';
+  seed = seed || 0;
+  var remainder = key.length % 4;
+  var bytes = key.length - remainder;
+  var h1 = seed;
+  var k1 = 0;
+  var c1 = 0xcc9e2d51;
+  var c2 = 0x1b873593;
+
+  for (var i = 0; i < bytes; i = i + 4) {
+    k1 = key.charCodeAt(i) & 0xff | (key.charCodeAt(i + 1) & 0xff) << 8 | (key.charCodeAt(i + 2) & 0xff) << 16 | (key.charCodeAt(i + 3) & 0xff) << 24;
+    k1 = (0, _common.x86Multiply)(k1, c1);
+    k1 = (0, _common.x86Rotl)(k1, 15);
+    k1 = (0, _common.x86Multiply)(k1, c2);
+    h1 ^= k1;
+    h1 = (0, _common.x86Rotl)(h1, 13);
+    h1 = (0, _common.x86Multiply)(h1, 5) + 0xe6546b64;
+  }
+
+  k1 = 0;
+
+  switch (remainder) {
+    case 3:
+      k1 ^= (key.charCodeAt(i + 2) & 0xff) << 16;
+
+    case 2:
+      k1 ^= (key.charCodeAt(i + 1) & 0xff) << 8;
+
+    case 1:
+      k1 ^= key.charCodeAt(i) & 0xff;
+      k1 = (0, _common.x86Multiply)(k1, c1);
+      k1 = (0, _common.x86Rotl)(k1, 15);
+      k1 = (0, _common.x86Multiply)(k1, c2);
+      h1 ^= k1;
+  }
+
+  h1 ^= key.length;
+  h1 = (0, _common.x86Fmix)(h1);
+  return h1 >>> 0;
+}
+
+function hash(str
+/*: string */
+, seed
+/*: number */
+)
+/*: number */
+{
+  return hash32((0, _common.UTF16ToUTF8)(str), seed >>> 0);
+}
+
+function bucket(str
+/*: string */
+, seed
+/*: number */
+)
+/*: number */
+{
+  return Math.abs(hash(str, seed) % 100) + 1;
+}
+
+var _default = {
+  hash: hash,
+  bucket: bucket
+};
+exports.default = _default;

package/lib/engine/engine/murmur3/murmur3_128.js

@@ -0,0 +1,256 @@
+"use strict";
+
+exports.__esModule = true;
+exports.hash128 = hash128;
+
+var _common = require("./common");
+
+/* eslint-disable no-fallthrough */
+
+/*!
+ * +----------------------------------------------------------------------------------+
+ * | murmurHash3.js v3.0.0 (http://github.com/karanlyons/murmurHash3.js)              |
+ * | A TypeScript/JavaScript implementation of MurmurHash3's hashing algorithms.      |
+ * |----------------------------------------------------------------------------------|
+ * | Copyright (c) 2012-2020 Karan Lyons. Freely distributable under the MIT license. |
+ * +----------------------------------------------------------------------------------+
+ */
+// PRIVATE FUNCTIONS
+// -----------------
+function _x64Add(m, n) {
+  //
+  // Given two 64bit ints (as an array of two 32bit ints) returns the two
+  // added together as a 64bit int (as an array of two 32bit ints).
+  //
+  m = [m[0] >>> 16, m[0] & 0xffff, m[1] >>> 16, m[1] & 0xffff];
+  n = [n[0] >>> 16, n[0] & 0xffff, n[1] >>> 16, n[1] & 0xffff];
+  var o = [0, 0, 0, 0];
+  o[3] += m[3] + n[3];
+  o[2] += o[3] >>> 16;
+  o[3] &= 0xffff;
+  o[2] += m[2] + n[2];
+  o[1] += o[2] >>> 16;
+  o[2] &= 0xffff;
+  o[1] += m[1] + n[1];
+  o[0] += o[1] >>> 16;
+  o[1] &= 0xffff;
+  o[0] += m[0] + n[0];
+  o[0] &= 0xffff;
+  return [o[0] << 16 | o[1], o[2] << 16 | o[3]];
+}
+
+function _x64Multiply(m, n) {
+  //
+  // Given two 64bit ints (as an array of two 32bit ints) returns the two
+  // multiplied together as a 64bit int (as an array of two 32bit ints).
+  //
+  m = [m[0] >>> 16, m[0] & 0xffff, m[1] >>> 16, m[1] & 0xffff];
+  n = [n[0] >>> 16, n[0] & 0xffff, n[1] >>> 16, n[1] & 0xffff];
+  var o = [0, 0, 0, 0];
+  o[3] += m[3] * n[3];
+  o[2] += o[3] >>> 16;
+  o[3] &= 0xffff;
+  o[2] += m[2] * n[3];
+  o[1] += o[2] >>> 16;
+  o[2] &= 0xffff;
+  o[2] += m[3] * n[2];
+  o[1] += o[2] >>> 16;
+  o[2] &= 0xffff;
+  o[1] += m[1] * n[3];
+  o[0] += o[1] >>> 16;
+  o[1] &= 0xffff;
+  o[1] += m[2] * n[2];
+  o[0] += o[1] >>> 16;
+  o[1] &= 0xffff;
+  o[1] += m[3] * n[1];
+  o[0] += o[1] >>> 16;
+  o[1] &= 0xffff;
+  o[0] += m[0] * n[3] + m[1] * n[2] + m[2] * n[1] + m[3] * n[0];
+  o[0] &= 0xffff;
+  return [o[0] << 16 | o[1], o[2] << 16 | o[3]];
+}
+
+function _x64Rotl(m, n) {
+  //
+  // Given a 64bit int (as an array of two 32bit ints) and an int
+  // representing a number of bit positions, returns the 64bit int (as an
+  // array of two 32bit ints) rotated left by that number of positions.
+  //
+  n %= 64;
+
+  if (n === 32) {
+    return [m[1], m[0]];
+  } else if (n < 32) {
+    return [m[0] << n | m[1] >>> 32 - n, m[1] << n | m[0] >>> 32 - n];
+  } else {
+    n -= 32;
+    return [m[1] << n | m[0] >>> 32 - n, m[0] << n | m[1] >>> 32 - n];
+  }
+}
+
+function _x64LeftShift(m, n) {
+  //
+  // Given a 64bit int (as an array of two 32bit ints) and an int
+  // representing a number of bit positions, returns the 64bit int (as an
+  // array of two 32bit ints) shifted left by that number of positions.
+  //
+  n %= 64;
+
+  if (n === 0) {
+    return m;
+  } else if (n < 32) {
+    return [m[0] << n | m[1] >>> 32 - n, m[1] << n];
+  } else {
+    return [m[1] << n - 32, 0];
+  }
+}
+
+function _x64Xor(m, n) {
+  //
+  // Given two 64bit ints (as an array of two 32bit ints) returns the two
+  // xored together as a 64bit int (as an array of two 32bit ints).
+  //
+  return [m[0] ^ n[0], m[1] ^ n[1]];
+}
+
+function _x64Fmix(h) {
+  //
+  // Given a block, returns murmurHash3's final x64 mix of that block.
+  // (`[0, h[0] >>> 1]` is a 33 bit unsigned right shift. This is the
+  // only place where we need to right shift 64bit ints.)
+  //
+  h = _x64Xor(h, [0, h[0] >>> 1]);
+  h = _x64Multiply(h, [0xff51afd7, 0xed558ccd]);
+  h = _x64Xor(h, [0, h[0] >>> 1]);
+  h = _x64Multiply(h, [0xc4ceb9fe, 0x1a85ec53]);
+  h = _x64Xor(h, [0, h[0] >>> 1]);
+  return h;
+} // PUBLIC FUNCTIONS
+// ----------------
+
+
+function hash128x64(key
+/*: string */
+, seed
+/*: number */
+)
+/*: string */
+{
+  //
+  // Given a string and an optional seed as an int, returns a 128 bit
+  // hash using the x64 flavor of MurmurHash3, as an unsigned hex.
+  //
+  key = key || '';
+  seed = seed || 0;
+  var remainder = key.length % 16;
+  var bytes = key.length - remainder;
+  var h1 = [0, seed];
+  var h2 = [0, seed];
+  var k1 = [0, 0];
+  var k2 = [0, 0];
+  var c1 = [0x87c37b91, 0x114253d5];
+  var c2 = [0x4cf5ad43, 0x2745937f];
+
+  for (var i = 0; i < bytes; i = i + 16) {
+    k1 = [key.charCodeAt(i + 4) & 0xff | (key.charCodeAt(i + 5) & 0xff) << 8 | (key.charCodeAt(i + 6) & 0xff) << 16 | (key.charCodeAt(i + 7) & 0xff) << 24, key.charCodeAt(i) & 0xff | (key.charCodeAt(i + 1) & 0xff) << 8 | (key.charCodeAt(i + 2) & 0xff) << 16 | (key.charCodeAt(i + 3) & 0xff) << 24];
+    k2 = [key.charCodeAt(i + 12) & 0xff | (key.charCodeAt(i + 13) & 0xff) << 8 | (key.charCodeAt(i + 14) & 0xff) << 16 | (key.charCodeAt(i + 15) & 0xff) << 24, key.charCodeAt(i + 8) & 0xff | (key.charCodeAt(i + 9) & 0xff) << 8 | (key.charCodeAt(i + 10) & 0xff) << 16 | (key.charCodeAt(i + 11) & 0xff) << 24];
+    k1 = _x64Multiply(k1, c1);
+    k1 = _x64Rotl(k1, 31);
+    k1 = _x64Multiply(k1, c2);
+    h1 = _x64Xor(h1, k1);
+    h1 = _x64Rotl(h1, 27);
+    h1 = _x64Add(h1, h2);
+    h1 = _x64Add(_x64Multiply(h1, [0, 5]), [0, 0x52dce729]);
+    k2 = _x64Multiply(k2, c2);
+    k2 = _x64Rotl(k2, 33);
+    k2 = _x64Multiply(k2, c1);
+    h2 = _x64Xor(h2, k2);
+    h2 = _x64Rotl(h2, 31);
+    h2 = _x64Add(h2, h1);
+    h2 = _x64Add(_x64Multiply(h2, [0, 5]), [0, 0x38495ab5]);
+  }
+
+  k1 = [0, 0];
+  k2 = [0, 0];
+
+  switch (remainder) {
+    case 15:
+      k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 14)], 48));
+
+    case 14:
+      k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 13)], 40));
+
+    case 13:
+      k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 12)], 32));
+
+    case 12:
+      k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 11)], 24));
+
+    case 11:
+      k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 10)], 16));
+
+    case 10:
+      k2 = _x64Xor(k2, _x64LeftShift([0, key.charCodeAt(i + 9)], 8));
+
+    case 9:
+      k2 = _x64Xor(k2, [0, key.charCodeAt(i + 8)]);
+      k2 = _x64Multiply(k2, c2);
+      k2 = _x64Rotl(k2, 33);
+      k2 = _x64Multiply(k2, c1);
+      h2 = _x64Xor(h2, k2);
+
+    case 8:
+      k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 7)], 56));
+
+    case 7:
+      k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 6)], 48));
+
+    case 6:
+      k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 5)], 40));
+
+    case 5:
+      k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 4)], 32));
+
+    case 4:
+      k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 3)], 24));
+
+    case 3:
+      k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 2)], 16));
+
+    case 2:
+      k1 = _x64Xor(k1, _x64LeftShift([0, key.charCodeAt(i + 1)], 8));
+
+    case 1:
+      k1 = _x64Xor(k1, [0, key.charCodeAt(i)]);
+      k1 = _x64Multiply(k1, c1);
+      k1 = _x64Rotl(k1, 31);
+      k1 = _x64Multiply(k1, c2);
+      h1 = _x64Xor(h1, k1);
+  }
+
+  h1 = _x64Xor(h1, [0, key.length]);
+  h2 = _x64Xor(h2, [0, key.length]);
+  h1 = _x64Add(h1, h2);
+  h2 = _x64Add(h2, h1);
+  h1 = _x64Fmix(h1);
+  h2 = _x64Fmix(h2);
+  h1 = _x64Add(h1, h2);
+  h2 = _x64Add(h2, h1);
+  return ('00000000' + (h1[0] >>> 0).toString(16)).slice(-8) + ('00000000' + (h1[1] >>> 0).toString(16)).slice(-8) + ('00000000' + (h2[0] >>> 0).toString(16)).slice(-8) + ('00000000' + (h2[1] >>> 0).toString(16)).slice(-8);
+}
+/**
+ * x64 version of Murmur3 for 128bits.
+ *
+ * @param {string} str
+ */
+
+
+function hash128(str
+/*: string */
+, seed
+/*: number */
+)
+/*: string */
+{
+  return hash128x64((0, _common.UTF16ToUTF8)(str), seed >>> 0);
+}