@splitsoftware/splitio 10.17.2 → 10.17.3-rc.0

package/src/engine/engine/index.js

@@ -1,63 +0,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.
-**/
-
-import logFactory from '../../utils/logger';
-const log = logFactory('splitio-engine');
-import legacy from './legacy';
-import murmur from './murmur3/murmur3';
-const MURMUR_ID = 2;
-
-/**
- * Returns the bucket function by algoId.
- */
-function getBucketAlgo(algoId) {
-  if (algoId === MURMUR_ID) {
-    return murmur.bucket;
-  } else {
-    return legacy.bucket;
-  }
-}
-
-const engine = {
-  /**
-   * Get the treatment name given a key, a seed, and the percentage of each treatment.
-   */
-  getTreatment(key, seed, treatments, algoId) {
-    const bucket = getBucketAlgo(algoId)(key, seed);
-
-    const 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(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) {
-      const bucket = getBucketAlgo(algoId)(key, trafficAllocationSeed);
-
-      if (bucket > trafficAllocation) {
-        return false;
-      }
-    }
-    return true;
-  }
-};
-
-export default engine;

package/src/engine/engine/legacy.js

@@ -1,66 +0,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) {
-  let 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 */ {
-  let h = 0;
-
-  for (let 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;
-}
-
-export default {
-  hash,
-  bucket
-};

package/src/engine/engine/murmur3/common.js

@@ -1,54 +0,0 @@
-import { stringSource, stringDestination, encodeUTF16toUTF8 } from './utfx';
-
-export function UTF16ToUTF8(key) {
-  let sd;
-
-  encodeUTF16toUTF8(
-    stringSource(key),
-    sd = 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. |
- * +----------------------------------------------------------------------------------+
- */
-
-export 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);
-}
-
-
-export 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));
-}
-
-export 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/src/engine/engine/murmur3/murmur3.js

@@ -1,79 +0,0 @@
-/* eslint-disable no-fallthrough */
-import { UTF16ToUTF8, x86Fmix, x86Multiply, x86Rotl } from './common';
-
-/*!
- * +----------------------------------------------------------------------------------+
- * | 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 = x86Multiply(k1, c1);
-    k1 = x86Rotl(k1, 15);
-    k1 = x86Multiply(k1, c2);
-
-    h1 ^= k1;
-    h1 = x86Rotl(h1, 13);
-    h1 = 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 = x86Multiply(k1, c1);
-      k1 = x86Rotl(k1, 15);
-      k1 = x86Multiply(k1, c2);
-      h1 ^= k1;
-  }
-
-  h1 ^= key.length;
-  h1 = x86Fmix(h1);
-
-  return h1 >>> 0;
-}
-
-function hash(str /*: string */, seed /*: number */) /*: number */ {
-  return hash32(UTF16ToUTF8(str), seed >>> 0);
-}
-
-function bucket(str /*: string */, seed /*: number */) /*: number */ {
-  return Math.abs(hash(str, seed) % 100) + 1;
-}
-
-export default {
-  hash,
-  bucket,
-};

package/src/engine/engine/murmur3/murmur3_128.js

@@ -1,273 +0,0 @@
-/* eslint-disable no-fallthrough */
-import { UTF16ToUTF8 } from './common';
-
-/*!
- * +----------------------------------------------------------------------------------+
- * | 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
- */
-export function hash128(str /*: string */, seed /*: number */) /*: string */ {
-  return hash128x64(UTF16ToUTF8(str), seed >>> 0);
-}