splitclient-rb 1.0.2.wip → 8.11.1.pre.rc1-java

data/ext/murmurhash/MurmurHash3.java

@@ -0,0 +1,302 @@
+/**
+ * The MurmurHash3 algorithm was created by Austin Appleby and placed in the public domain.
+ * This java port was authored by Yonik Seeley and also placed into the public domain.
+ * The author hereby disclaims copyright to this source code.
+ * <p>
+ * This produces exactly the same hash values as the final C++
+ * version of MurmurHash3 and is thus suitable for producing the same hash values across
+ * platforms.
+ * <p>
+ * The 32 bit x86 version of this hash should be the fastest variant for relatively short keys like ids.
+ * murmurhash3_x64_128 is a good choice for longer strings or if you need more than 32 bits of hash.
+ * <p>
+ * Note - The x86 and x64 versions do _not_ produce the same results, as the
+ * algorithms are optimized for their respective platforms.
+ * <p>
+ * See http://github.com/yonik/java_util for future updates to this file.
+ */
+public final class MurmurHash3 {
+
+    /**
+     * 128 bits of state
+     */
+    public static final class LongPair {
+        public long val1;
+        public long val2;
+    }
+
+    public static final int fmix32(int h) {
+        h ^= h >>> 16;
+        h *= 0x85ebca6b;
+        h ^= h >>> 13;
+        h *= 0xc2b2ae35;
+        h ^= h >>> 16;
+        return h;
+    }
+
+    public static final long fmix64(long k) {
+        k ^= k >>> 33;
+        k *= 0xff51afd7ed558ccdL;
+        k ^= k >>> 33;
+        k *= 0xc4ceb9fe1a85ec53L;
+        k ^= k >>> 33;
+        return k;
+    }
+
+    /**
+     * Gets a long from a byte buffer in little endian byte order.
+     */
+    public static final long getLongLittleEndian(byte[] buf, int offset) {
+        return ((long) buf[offset + 7] << 56)   // no mask needed
+                | ((buf[offset + 6] & 0xffL) << 48)
+                | ((buf[offset + 5] & 0xffL) << 40)
+                | ((buf[offset + 4] & 0xffL) << 32)
+                | ((buf[offset + 3] & 0xffL) << 24)
+                | ((buf[offset + 2] & 0xffL) << 16)
+                | ((buf[offset + 1] & 0xffL) << 8)
+                | ((buf[offset] & 0xffL));        // no shift needed
+    }
+
+
+    /**
+     * Returns the MurmurHash3_x86_32 hash of the UTF-8 bytes of the String without actually encoding
+     * the string to a temporary buffer.  This is more than 2x faster than hashing the result
+     * of String.getBytes().
+     */
+    public static long murmurhash3_x86_32(CharSequence data, int seed) {
+        final int c1 = 0xcc9e2d51;
+        final int c2 = 0x1b873593;
+
+        int h1 = seed;
+
+        int offset = 0;
+        int len = data.length();
+        int pos = offset;
+        int end = offset + len;
+        int k1 = 0;
+        int k2 = 0;
+        int shift = 0;
+        int bits = 0;
+        int nBytes = 0;   // length in UTF8 bytes
+
+
+        while (pos < end) {
+            int code = data.charAt(pos++);
+            if (code < 0x80) {
+                k2 = code;
+                bits = 8;
+
+            } else if (code < 0x800) {
+                k2 = (0xC0 | (code >> 6))
+                        | ((0x80 | (code & 0x3F)) << 8);
+                bits = 16;
+            } else if (code < 0xD800 || code > 0xDFFF || pos >= end) {
+                // we check for pos>=end to encode an unpaired surrogate as 3 bytes.
+                k2 = (0xE0 | (code >> 12))
+                        | ((0x80 | ((code >> 6) & 0x3F)) << 8)
+                        | ((0x80 | (code & 0x3F)) << 16);
+                bits = 24;
+            } else {
+                // surrogate pair
+                // int utf32 = pos < end ? (int) data.charAt(pos++) : 0;
+                int utf32 = (int) data.charAt(pos++);
+                utf32 = ((code - 0xD7C0) << 10) + (utf32 & 0x3FF);
+                k2 = (0xff & (0xF0 | (utf32 >> 18)))
+                        | ((0x80 | ((utf32 >> 12) & 0x3F))) << 8
+                        | ((0x80 | ((utf32 >> 6) & 0x3F))) << 16
+                        | (0x80 | (utf32 & 0x3F)) << 24;
+                bits = 32;
+            }
+
+
+            k1 |= k2 << shift;
+
+            // int used_bits = 32 - shift;  // how many bits of k2 were used in k1.
+            // int unused_bits = bits - used_bits; //  (bits-(32-shift)) == bits+shift-32  == bits-newshift
+
+            shift += bits;
+            if (shift >= 32) {
+                // mix after we have a complete word
+
+                k1 *= c1;
+                k1 = (k1 << 15) | (k1 >>> 17);  // ROTL32(k1,15);
+                k1 *= c2;
+
+                h1 ^= k1;
+                h1 = (h1 << 13) | (h1 >>> 19);  // ROTL32(h1,13);
+                h1 = h1 * 5 + 0xe6546b64;
+
+                shift -= 32;
+                // unfortunately, java won't let you shift 32 bits off, so we need to check for 0
+                if (shift != 0) {
+                    k1 = k2 >>> (bits - shift);   // bits used == bits - newshift
+                } else {
+                    k1 = 0;
+                }
+                nBytes += 4;
+            }
+
+        } // inner
+
+        // handle tail
+        if (shift > 0) {
+            nBytes += shift >> 3;
+            k1 *= c1;
+            k1 = (k1 << 15) | (k1 >>> 17);  // ROTL32(k1,15);
+            k1 *= c2;
+            h1 ^= k1;
+        }
+
+        // finalization
+        h1 ^= nBytes;
+
+        // fmix(h1);
+        h1 ^= h1 >>> 16;
+        h1 *= 0x85ebca6b;
+        h1 ^= h1 >>> 13;
+        h1 *= 0xc2b2ae35;
+        h1 ^= h1 >>> 16;
+
+        return h1 & 0xFFFFFFFFL;
+    }
+
+    // The following set of methods and constants are borrowed from:
+    // `This method is borrowed from `org.apache.commons.codec.digest.MurmurHash3`
+
+    // Constants for 128-bit variant
+    private static final long C1 = 0x87c37b91114253d5L;
+    private static final long C2 = 0x4cf5ad432745937fL;
+    private static final int R1 = 31;
+    private static final int R2 = 27;
+    private static final int R3 = 33;
+    private static final int M = 5;
+    private static final int N1 = 0x52dce729;
+    private static final int N2 = 0x38495ab5;
+
+    /**
+     * Gets the little-endian long from 8 bytes starting at the specified index.
+     *
+     * @param data The data
+     * @param index The index
+     * @return The little-endian long
+     */
+    private static long getLittleEndianLong(final byte[] data, final int index) {
+        return (((long) data[index    ] & 0xff)      ) |
+                (((long) data[index + 1] & 0xff) <<  8) |
+                (((long) data[index + 2] & 0xff) << 16) |
+                (((long) data[index + 3] & 0xff) << 24) |
+                (((long) data[index + 4] & 0xff) << 32) |
+                (((long) data[index + 5] & 0xff) << 40) |
+                (((long) data[index + 6] & 0xff) << 48) |
+                (((long) data[index + 7] & 0xff) << 56);
+    }
+
+    public static long[] hash128x64(final String data, final long seed) {
+        final byte[] dataBytes = data.getBytes();
+        return hash128x64(dataBytes, 0, dataBytes.length, seed);
+    }
+
+    /**
+     * Generates 128-bit hash from the byte array with the given offset, length and seed.
+     *
+     * <p>This is an implementation of the 128-bit hash function {@code MurmurHash3_x64_128}
+     * from from Austin Applyby's original MurmurHash3 {@code c++} code in SMHasher.</p>
+     *
+     * @param data The input byte array
+     * @param offset The first element of array
+     * @param length The length of array
+     * @param seed The initial seed value
+     * @return The 128-bit hash (2 longs)
+     */
+    public static long[] hash128x64(final byte[] data, final int offset, final int length, final long seed) {
+        long h1 = seed;
+        long h2 = seed;
+        final int nblocks = length >> 4;
+
+        // body
+        for (int i = 0; i < nblocks; i++) {
+            final int index = offset + (i << 4);
+            long k1 = getLittleEndianLong(data, index);
+            long k2 = getLittleEndianLong(data, index + 8);
+
+            // mix functions for k1
+            k1 *= C1;
+            k1 = Long.rotateLeft(k1, R1);
+            k1 *= C2;
+            h1 ^= k1;
+            h1 = Long.rotateLeft(h1, R2);
+            h1 += h2;
+            h1 = h1 * M + N1;
+
+            // mix functions for k2
+            k2 *= C2;
+            k2 = Long.rotateLeft(k2, R3);
+            k2 *= C1;
+            h2 ^= k2;
+            h2 = Long.rotateLeft(h2, R1);
+            h2 += h1;
+            h2 = h2 * M + N2;
+        }
+
+        // tail
+        long k1 = 0;
+        long k2 = 0;
+        final int index = offset + (nblocks << 4);
+        switch (offset + length - index) {
+            case 15:
+                k2 ^= ((long) data[index + 14] & 0xff) << 48;
+            case 14:
+                k2 ^= ((long) data[index + 13] & 0xff) << 40;
+            case 13:
+                k2 ^= ((long) data[index + 12] & 0xff) << 32;
+            case 12:
+                k2 ^= ((long) data[index + 11] & 0xff) << 24;
+            case 11:
+                k2 ^= ((long) data[index + 10] & 0xff) << 16;
+            case 10:
+                k2 ^= ((long) data[index + 9] & 0xff) << 8;
+            case 9:
+                k2 ^= data[index + 8] & 0xff;
+                k2 *= C2;
+                k2 = Long.rotateLeft(k2, R3);
+                k2 *= C1;
+                h2 ^= k2;
+
+            case 8:
+                k1 ^= ((long) data[index + 7] & 0xff) << 56;
+            case 7:
+                k1 ^= ((long) data[index + 6] & 0xff) << 48;
+            case 6:
+                k1 ^= ((long) data[index + 5] & 0xff) << 40;
+            case 5:
+                k1 ^= ((long) data[index + 4] & 0xff) << 32;
+            case 4:
+                k1 ^= ((long) data[index + 3] & 0xff) << 24;
+            case 3:
+                k1 ^= ((long) data[index + 2] & 0xff) << 16;
+            case 2:
+                k1 ^= ((long) data[index + 1] & 0xff) << 8;
+            case 1:
+                k1 ^= data[index] & 0xff;
+                k1 *= C1;
+                k1 = Long.rotateLeft(k1, R1);
+                k1 *= C2;
+                h1 ^= k1;
+        }
+
+        // finalization
+        h1 ^= length;
+        h2 ^= length;
+
+        h1 += h2;
+        h2 += h1;
+
+        h1 = fmix64(h1);
+        h2 = fmix64(h2);
+
+        h1 += h2;
+        h2 += h1;
+
+        return new long[] { h1, h2 };
+    }
+}

data/gemfiles/faraday_after_0.13.gemfile

@@ -0,0 +1,7 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "faraday", "> 0.13"
+
+gemspec path: "../"

data/gemfiles/faraday_before_0.13.gemfile

@@ -0,0 +1,8 @@
+# This file was generated by Appraisal
+
+source "https://rubygems.org"
+
+gem "faraday", ">= 0.9", "< 0.13"
+gem "net-http-persistent", "~> 3.0"
+
+gemspec path: "../"

data/lib/murmurhash/base.rb

@@ -0,0 +1,58 @@
+module Digest
+  ds = Struct.new(:digest_length, :seed_length)
+  s1 = ds.new(4, 4)
+  s2 = ds.new(8, 8)
+  s3 = ds.new(16, 4)
+  {
+    '1' => s1,
+    '2' => s1,
+    '2A' => s1,
+    '64A' => s2,
+    '64B' => s2,
+    'Aligned2' => s1,
+    'Neutral2' => s1,
+    '3_x86_32' => s1,
+    '3_x86_128' => s3,
+    '3_x64_128' => s3,
+  }.each do |name, s|
+    class_eval %Q{
+      class MurmurHashMRI#{name} < Digest::Class
+        DEFAULT_SEED = "#{"\x00" * s.seed_length}".b
+
+        def initialize
+          @buffer = ""
+          @seed = DEFAULT_SEED
+        end
+
+        def update(str)
+          @buffer << str
+          self
+        end
+        alias << update
+
+        def reset
+          @buffer.clear
+          @seed = DEFAULT_SEED
+          self
+        end
+
+        def seed
+          @seed
+        end
+
+        def seed=(s)
+          raise ArgumentError, "seed string should be #{s.seed_length} length" if #{s.seed_length} != s.length
+          @seed = s
+        end
+
+        def digest_length
+          #{s.digest_length}
+        end
+
+        def block_length
+          0
+        end
+      end
+    }
+  end
+end

data/lib/murmurhash/murmurhash_mri.rb

@@ -0,0 +1,3 @@
+require 'digest'
+require 'murmurhash/base'
+require 'murmurhash/murmurhash'

data/lib/splitclient-rb/cache/adapters/cache_adapter.rb

@@ -0,0 +1,130 @@
+require 'lru_redux'
+
+module SplitIoClient
+  module Cache
+    module Adapters
+      class CacheAdapter
+        extend Forwardable
+        def_delegators :@adapter, :initialize_set, :set_bool, :pipelined
+
+        def initialize(config)
+          @cache = LruRedux::TTL::ThreadSafeCache.new(config.max_cache_size, config.cache_ttl)
+          @adapter = config.cache_adapter
+        end
+
+        def delete(key)
+          @cache.delete(key)
+          @adapter.delete(key)
+        end
+
+        def clear(namespace_key)
+          @cache.clear
+        end
+
+        def string(key)
+          value = get(key)
+          return value if value
+          value = @adapter.string(key)
+          add(key, value)
+          value
+        end
+
+        def set_string(key, value)
+          add(key, value)
+          @adapter.set_string(key, value)
+        end
+
+        def multiple_strings(keys)
+          cached_values = keys.each_with_object({}) do |key, memo|
+             memo[key] = get(key)
+          end
+
+          non_cached_keys = []
+          cached_values.delete_if{ |k,v| v.nil? ? non_cached_keys << k : false }
+
+          if non_cached_keys.any?
+            new_values = @adapter.multiple_strings(non_cached_keys)
+
+            new_values.keys.each do |key, value|
+              add(key, value)
+            end
+
+            cached_values.merge!(new_values)
+          end
+
+          cached_values
+        end
+
+        def find_strings_by_prefix(prefix)
+          @adapter.find_strings_by_prefix(prefix)
+        end
+
+        def exists?(key)
+          cached_value = get(key)
+          if cached_value.nil?
+            @adapter.exists?(key)
+          else
+            true
+          end
+        end
+
+        def add_to_set(key, values)
+          if values.is_a? Array
+            values.each { |value| add_to_map(key, value, 1) }
+          else
+            add_to_map(key, values, 1)
+          end
+          @adapter.add_to_set(key, values)
+        end
+
+        def in_set?(key, field)
+          cached_value = get(key)
+          if cached_value.nil?
+            return @adapter.in_set?(key, field)
+          end
+          cached_value.key?(field)
+        end
+
+        def get_set(key)
+          cached_value = get(key)
+          if cached_value.nil?
+            return @adapter.get_set(key)
+          end
+          cached_value.keys
+        end
+
+        def delete_from_set(key, fields)
+          cached_value = get(key)
+          if cached_value
+            if fields.is_a? Array
+              fields.each { |field| cached_value.delete(field) }
+            else
+              cached_value.delete(fields)
+            end
+          end
+
+          @adapter.delete_from_set(key, fields)
+        end
+
+        def initialize_map(key)
+          @cache[key] = Concurrent::Map.new
+        end
+
+        private
+
+        def add_to_map(key, field, value)
+          initialize_map(key) unless get(key)
+          get(key).put(field.to_s, value.to_s)
+        end
+
+        def add(key, value)
+          @cache[key] = value.to_s unless value.nil?
+        end
+
+        def get(key)
+          @cache[key]
+        end
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/adapters/memory_adapter.rb

@@ -0,0 +1,12 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    module Adapters
+      # Memory adapter can have different implementations, this class is used as a delegator to
+      # this implementations
+      class MemoryAdapter < SimpleDelegator
+      end
+    end
+  end
+end

data/lib/splitclient-rb/cache/adapters/memory_adapters/map_adapter.rb

@@ -0,0 +1,137 @@
+require 'concurrent'
+
+module SplitIoClient
+  module Cache
+    module Adapters
+      module MemoryAdapters
+        # Memory adapter implementation, which stores everything inside thread-safe Map
+        class MapAdapter
+          def initialize
+            @map = Concurrent::Map.new
+          end
+
+          def clear(_ = nil)
+            initialize
+          end
+
+          # Map
+          def initialize_map(key)
+            @map[key] = Concurrent::Map.new
+          end
+
+          def add_to_map(key, field, value)
+            initialize_map(key) unless @map[key]
+
+            @map[key].put(field, value)
+          end
+
+          def find_in_map(key, field)
+            return nil if @map[key].nil?
+
+            @map[key].get(field)
+          end
+
+          def delete_from_map(key, fields)
+            if fields.is_a? Array
+              fields.each { |field| @map[key].delete(field) }
+            else
+              @map[key].delete(fields)
+            end
+          end
+
+          def in_map?(key, field)
+            return false if @map[key].nil?
+
+            @map[key].key?(field)
+          end
+
+          def map_keys(key)
+            @map[key].keys
+          end
+
+          def get_map(key)
+            @map[key]
+          end
+
+          # String
+          def string(key)
+            @map[key]
+          end
+
+          def set_string(key, str)
+            @map[key] = str
+          end
+
+          def find_strings_by_prefix(prefix)
+            @map.keys.select { |str| str.start_with? prefix }
+          end
+
+          def multiple_strings(keys)
+            keys.each_with_object({}) do |key, memo|
+              memo[key] = string(key)
+            end
+          end
+
+          # Bool
+          def set_bool(key, val)
+            @map[key] = val
+          end
+
+          def bool(key)
+            @map[key]
+          end
+
+          # Set
+          alias_method :initialize_set, :initialize_map
+          alias_method :get_set, :map_keys
+          alias_method :delete_from_set, :delete_from_map
+          alias_method :in_set?, :in_map?
+          alias_method :find_sets_by_prefix, :find_strings_by_prefix
+
+          def add_to_set(key, values)
+            if values.is_a? Array
+              values.each { |value| add_to_map(key, value, 1) }
+            else
+              add_to_map(key, values, 1)
+            end
+          end
+
+          def get_all_from_set(key)
+            @map[key].keys
+          end
+
+          def union_sets(set_keys)
+            array = set_keys.each_with_object([]) do |key, memo|
+              memo << get_set(key)
+            end.flatten
+
+            Set.new(array)
+          end
+
+          # General
+          def exists?(key)
+            !@map[key].nil?
+          end
+
+          def delete(key)
+            if key.is_a? Array
+              key.each { |k| @map.delete(k) }
+            else
+              @map.delete(key)
+            end
+          end
+
+          def empty?
+            @map.empty?
+          end
+
+          # This method is used in Redis adapter
+          # "stubbing" it here to keep the interface
+          def pipelined(&block)
+            block.call
+          end
+        end
+      end
+    end
+  end
+end