cuboid 0.0.0 → 0.0.3

data/lib/cuboid/support/buffer/base.rb

@@ -0,0 +1,91 @@
+module Cuboid
+module Support::Buffer
+
+#
+# Base buffer class to be extended by more specialised implementation.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+#
+class Base
+    include Support::Mixins::Observable
+
+    # @!method on_push( &block )
+    #   @param    [Block] block   block to call on {#push}
+    advertise :on_push
+
+    # @!method on_batch_push( &block )
+    #   @param    [Block] block   block to call on {#batch_push}
+    advertise :on_batch_push
+
+    # @!method on_flush( &block )
+    #   @param    [Block] block   block to call on {#flush}
+    advertise :on_flush
+
+    # @return   [Integer]   Maximum buffer size.
+    attr_reader :max_size
+
+    # @param    [Integer]  max_size
+    #   Maximum buffer size -- won't be enforced.
+    # @param    [#<<, #|, #clear, #size, #empty?]   type
+    #   Internal storage class to use.
+    def initialize( max_size = nil, type = Array )
+        super()
+        @buffer    = type.new
+        @max_size  = max_size
+    end
+
+    # @note Calls {#on_push} blocks with the given object and pushes an object
+    #   to the buffer.
+    #
+    # @param    [Object]    obj
+    #   Object to push.
+    def <<( obj )
+        notify_on_push obj
+        @buffer << obj
+        self
+    end
+    alias :push :<<
+
+    # @note Calls {#on_batch_push} blocks with the given list and merges the
+    #   buffer with the contents of a list.
+    #
+    # @param    [#|]    list
+    #   List of objects
+    def batch_push( list )
+        notify_on_batch_push list
+        @buffer |= list
+        self
+    end
+
+    # @return   [Integer]
+    #   Number of object in the buffer.
+    def size
+        @buffer.size
+    end
+
+    # @return   [Bool]
+    #   `true` if the buffer is empty, `false` otherwise.
+    def empty?
+        @buffer.empty?
+    end
+
+    # @return   [Bool]
+    #   `true` if the buffer is full, `false` otherwise.
+    def full?
+        !!(max_size && size >= max_size)
+    end
+
+    # @note Calls {#on_flush} blocks with the buffer and then empties it.
+    #
+    # @return   current buffer
+    def flush
+        buffer = @buffer.dup
+        notify_on_flush buffer
+        buffer
+    ensure
+        @buffer.clear
+    end
+
+end
+end
+end

data/lib/cuboid/support/buffer.rb

@@ -0,0 +1,3 @@
+buffers = Cuboid::Options.paths.support + 'buffer/'
+require buffers + 'base'
+require buffers + 'autoflush'

data/lib/cuboid/support/cache/base.rb

@@ -0,0 +1,226 @@
+module Cuboid
+module Support::Cache
+
+# Base cache implementation -- stores, retrieves and removes entries.
+#
+# The cache will be pruned (call {#prune}) upon storage operations, removing
+# old entries to make room for new ones.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+# @abstract
+class Base
+    include Support::Mixins::Profiler
+
+    # @return    [Integer]
+    #   Maximum cache size.
+    attr_reader :max_size
+
+    # @param    [Hash]  options
+    # @option   options [Integer, nil]    :size
+    #   Maximum size of the cache (must be > 0, `nil` means unlimited).
+    #   Once the size of the cache is about to exceed `max_size`, the pruning
+    #   phase will be initiated.
+    # # @option   options [true, false]    :freeze    (true)
+    #   Whether or not to freeze stored items.
+    def initialize( options = {} )
+        super()
+
+        @options      = options
+        @freeze       = @options[:freeze].nil? ? true : @options[:freeze]
+        self.max_size = @options[:size]
+
+        @cache    = {}
+        @hits     = 0
+        @misses   = 0
+        @prunings = 0
+    end
+
+    def statistics
+        lookups = @hits + @misses
+
+        {
+            lookups:    lookups,
+            hits:       @hits,
+            hit_ratio:  @hits   == 0 ? 0.0 : @hits   / Float( lookups ),
+            misses:     @misses,
+            miss_ratio: @misses == 0 ? 0.0 : @misses / Float( lookups ),
+            prunings:   @prunings,
+            size:       size,
+            max_size:   max_size
+        }
+    end
+
+    def max_size=( max )
+        @max_size = if !max
+            nil
+        else
+            fail( 'Maximum size must be greater than 0.' ) if max <= 0
+            max
+        end
+    end
+
+    # @return   [Bool]
+    #   `true` is there is no size limit, `false` otherwise
+    def uncapped?
+        !capped?
+    end
+
+    # @return   [Bool]
+    #   `true` is there is a size limit, `false`` otherwise
+    def capped?
+        !!max_size
+    end
+
+    # Uncaps the cache {#max_size} limit
+    def uncap
+        @max_size = nil
+    end
+
+    # @return   [Integer]
+    #   Number of entries in the cache.
+    def size
+        @cache.size
+    end
+
+    # Storage method.
+    #
+    # @param    [Object]    k
+    #   Entry key.
+    # @param    [Object]    v
+    #   Object to store.
+    #
+    # @return   [Object]    `v`
+    def store( k, v )
+        store_with_internal_key( make_key( k ), v )
+    end
+
+    # @see #store
+    def []=( k, v )
+        store( k, v )
+    end
+
+    # Retrieving method.
+    #
+    # @param    [Object]    k
+    #   Entry key.
+    #
+    # @return   [Object, nil]
+    #   Value for key `k`, `nil` if there is no key `k`.
+    def []( k )
+        get_with_internal_key( make_key( k ) )
+    end
+
+    # @note If key `k` exists, its corresponding value will be returned.
+    #   If not, the return value of `block` will be assigned to key `k` and that
+    #   value will be returned.
+    #
+    # @param    [Object]    k
+    #   Entry key.
+    #
+    # @return   [Object]
+    #   Value for key `k` or `block.call` if key `k` does not exist.
+    def fetch( k, &block )
+        k = make_key( k )
+
+        if @cache.include?( k )
+            get_with_internal_key( k )
+        else
+            @misses += 1
+            store_with_internal_key( k, profile_proc( &block ) )
+        end
+    end
+
+    # @return   [Bool]
+    #   `true` if cache includes an entry for key `k`, false otherwise.
+    def include?( k )
+        @cache.include?( make_key( k ) )
+    end
+
+    # @return   [Bool]
+    #   `true` if cache is empty, false otherwise.
+    def empty?
+        @cache.empty?
+    end
+
+    # @return   [Bool]
+    #   `true` if cache is not empty, `false` otherwise.
+    def any?
+        !empty?
+    end
+
+    # Removes entry with key `k` from the cache.
+    #
+    # @param    [Object]    k
+    #   Key.
+    #
+    # @return   [Object, nil]
+    #   Value for key `k`, `nil` if there is no key `k`.
+    def delete( k )
+        @cache.delete( make_key( k ) )
+    end
+
+    # Clears/empties the cache.
+    def clear
+        @cache.clear
+    end
+
+    def ==( other )
+        hash == other.hash
+    end
+
+    def hash
+        @cache.hash
+    end
+
+    def dup
+        self.class.new( @options.dup ).tap { |h| h.cache = @cache.dup }
+    end
+
+    protected
+
+    def cache=( c )
+        @cache = c
+    end
+
+    private
+
+    def store_with_internal_key( k, v )
+        while capped? && (size > max_size - 1)
+            prune
+            @prunings += 1
+        end
+
+        _store( k, v )
+    end
+
+    def _store( k, v )
+        @cache[k] = @freeze ? v.freeze : v
+    end
+
+    def get_with_internal_key( k )
+        if (r = @cache[k])
+            @hits += 1
+        else
+            @misses += 1
+        end
+        r
+    end
+
+    def make_key( k )
+        k.hash
+    end
+
+    def cache
+        @cache
+    end
+
+    # Called to make room when the cache is about to reach its maximum size.
+    #
+    # @abstract
+    def prune
+        fail NotImplementedError
+    end
+
+end
+end
+end

data/lib/cuboid/support/cache/least_cost_replacement.rb

@@ -0,0 +1,77 @@
+module Cuboid
+module Support::Cache
+
+# Least Cost Replacement cache implementation.
+#
+# Maintains 3 cost classes (low, medium, high) ) and discards entries from the
+# lowest cost classes in order to make room for new ones.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class LeastCostReplacement < Base
+
+    VALID_COSTS = [ :low, :medium, :high ]
+
+    # @see Cuboid::Cache::Base#initialize
+    def initialize( * )
+        super
+        reset_costs
+    end
+
+    # Storage method
+    #
+    # @param    [Object]    k
+    #   Entry key.
+    # @param    [Object]    v
+    #   Object to store.
+    # @param    [Symbol]    cost
+    #
+    # @return   [Object]    `v`
+    #
+    # @see VALID_COSTS
+    def store( k, v, cost = :low )
+        fail( "invalid cost: #{cost}" ) if !valid_cost?( cost )
+
+        super( k, v )
+    ensure
+        @costs[cost] << k
+    end
+
+    # @see Cuboid::Cache::Base#clear
+    def clear
+        super
+    ensure
+        reset_costs
+    end
+
+    private
+
+    def reset_costs
+        @costs = {}
+        VALID_COSTS.each { |c| @costs[c] = [] }
+    end
+
+    def valid_cost?( cost )
+        VALID_COSTS.include?( cost )
+    end
+
+    def candidate_from_cost_class( cost_class )
+        return if (costs = @costs[cost_class]).empty?
+        costs.delete_at( rand( costs.size ) )
+    end
+
+    def prune_candidate
+        VALID_COSTS.each do |cost|
+            if c = candidate_from_cost_class( cost )
+                return c
+            end
+        end
+    end
+
+    def prune
+        delete( prune_candidate )
+    end
+
+end
+
+end
+end

data/lib/cuboid/support/cache/least_recently_pushed.rb

@@ -0,0 +1,21 @@
+module Cuboid
+module Support::Cache
+
+# Least Recently Pushed cache implementation.
+#
+# Discards the least recently pushed entries, in order to make room for newer ones.
+#
+# This is the cache with best performance across the board.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class LeastRecentlyPushed < Base
+
+    private
+
+    def prune
+        @cache.delete( @cache.first.first )
+    end
+
+end
+end
+end

data/lib/cuboid/support/cache/least_recently_used.rb

@@ -0,0 +1,31 @@
+module Cuboid
+module Support::Cache
+
+# Least Recently Used cache implementation.
+#
+# Generally, the most desired mode under most circumstances.
+# Discards the least recently used entries in order to make room for newer ones.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class LeastRecentlyUsed < LeastRecentlyPushed
+
+    private
+
+    def get_with_internal_key( k )
+        if !@cache.include? k
+            @misses += 1
+            return
+        end
+
+        renew( k )
+
+        super k
+    end
+
+    def renew( internal_key )
+        @cache[internal_key] = @cache.delete( internal_key )
+    end
+
+end
+end
+end

data/lib/cuboid/support/cache/preference.rb

@@ -0,0 +1,31 @@
+module Cuboid
+module Support::Cache
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class Preference < Base
+
+    def prefer( &block )
+        @preference = block
+    end
+
+    private
+
+    def store_with_internal_key( k, v )
+        prune if capped? && (size > max_size - 1)
+
+        _store( k, v )
+    end
+
+    def find_preference
+        @preference.call
+    end
+
+    def prune
+        preferred = find_preference
+        delete( preferred ) if preferred
+    end
+
+end
+
+end
+end

data/lib/cuboid/support/cache/random_replacement.rb

@@ -0,0 +1,20 @@
+module Cuboid
+module Support::Cache
+
+# Random Replacement cache implementation.
+#
+# Discards entries at random in order to make room for new ones.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class RandomReplacement < Base
+
+    private
+
+    def prune
+        @cache.delete( @cache.keys.sample )
+    end
+
+end
+
+end
+end

data/lib/cuboid/support/cache.rb

@@ -0,0 +1,7 @@
+lib = Cuboid::Options.paths.support + 'cache/'
+require lib + 'base'
+require lib + 'least_recently_pushed'
+require lib + 'least_recently_used'
+require lib + 'random_replacement'
+require lib + 'least_cost_replacement'
+require lib + 'preference'

data/lib/cuboid/support/crypto/rsa_aes_cbc.rb

@@ -0,0 +1,86 @@
+require 'openssl'
+require "base64"
+
+module Cuboid
+module Support::Crypto
+
+# Simple hybrid crypto class using RSA for public key encryption and AES with CBC
+# for bulk data encryption/decryption.
+#
+# RSA is used to encrypt the AES primitives which are used to encrypt the plaintext.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class RSA_AES_CBC
+
+    # If only encryption is required the private key parameter can be omitted.
+    #
+    # @param  [String]  public_pem
+    #   Location of the Public key in PEM format.
+    # @param  [String]  private_pem
+    #   Location of the Private key in PEM format.
+    def initialize( public_pem, private_pem = nil )
+        @public_pem  = public_pem
+        @private_pem = private_pem
+    end
+
+    # Encrypts data and returns a Base64 representation of the ciphertext
+    # and AES CBC primitives encrypted using the public key.
+    #
+    # @param  [String]  data
+    #
+    # @return  [String]
+    #   Base64 representation of the ciphertext and AES CBC primitives encrypted
+    #   using the public key.
+    def encrypt( data )
+        rsa = OpenSSL::PKey::RSA.new( File.read( @public_pem ) )
+
+        # encrypt with 256 bit AES with CBC
+        aes = OpenSSL::Cipher::Cipher.new( 'aes-256-cbc' )
+        aes.encrypt
+
+        # use random key and IV
+        aes.key = key = aes.random_key
+        aes.iv  = iv  = aes.random_iv
+
+        # this will hold all primitives and ciphertext
+        primitives = {}
+
+        primitives['ciphertext'] = aes.update( data )
+        primitives['ciphertext'] << aes.final
+
+        primitives['key'] = rsa.public_encrypt( key )
+        primitives['iv']  = rsa.public_encrypt( iv )
+
+        # serialize everything and base64 encode it
+        Base64.encode64( primitives.to_yaml )
+    end
+
+    # Decrypts data.
+    #
+    # @param  [String]  data
+    #
+    # @return  [String]
+    #   Plaintext.
+    def decrypt( data )
+        rsa = OpenSSL::PKey::RSA.new( File.read( @private_pem ) )
+
+        # decrypt with 256 bit AES with CBC
+        aes = OpenSSL::Cipher::Cipher.new( 'aes-256-cbc' )
+        aes.decrypt
+
+        # unencode and unserialize to get the primitives and ciphertext
+        primitives = YAML::load( Base64.decode64( data ) )
+
+        aes.key = rsa.private_decrypt( primitives['key'] )
+        aes.iv  = rsa.private_decrypt( primitives['iv'] )
+
+        plaintext = aes.update( primitives['ciphertext'] )
+        plaintext << aes.final
+
+        plaintext
+    end
+
+end
+
+end
+end

data/lib/cuboid/support/crypto.rb

@@ -0,0 +1,2 @@
+lib = Cuboid::Options.paths.support + 'crypto/'
+require lib + 'rsa_aes_cbc'