cuboid 0.0.0 → 0.0.1alpha

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/crypto.rb

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

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/database.rb

@@ -0,0 +1,5 @@
+lib = Cuboid::Options.paths.support + '/database/'
+require lib + 'base'
+require lib + 'queue'
+require lib + 'categorized_queue'
+require lib + 'hash'

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

@@ -0,0 +1,177 @@
+module Cuboid
+module Support::Database
+
+# Base class for Database data structures
+#
+# Provides helper methods for data structures to be implemented related to
+# objecting dumping, loading, unique filename generation, etc.
+#
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+#
+# @abstract
+class Base
+
+    DISK_SPACE_FILE = 'Database_disk_space'
+
+    class <<self
+
+        def reset
+            @@disk_space = 0
+            set_disk_space @@disk_space
+        end
+
+        def increment_disk_space( int )
+            set_disk_space @@disk_space + int
+        end
+
+        def decrement_disk_space( int )
+            set_disk_space @@disk_space - int
+        end
+
+        def disk_space
+            @@disk_space
+        end
+
+        def disk_directory
+            Options.paths.tmpdir
+        end
+
+        def disk_space_file
+            disk_space_file_for Process.pid
+        end
+
+        def disk_space_for( pid )
+            return 0 if !Dir.exists?( Options.paths.tmp_dir_for( pid ) )
+
+            IO.read( disk_space_file_for( pid ) ).to_i
+        end
+
+        def disk_space_file_for( pid )
+            "#{Options.paths.tmp_dir_for( pid )}/#{DISK_SPACE_FILE}"
+        end
+
+        private
+
+        def set_disk_space( int )
+            if !File.exist?( disk_directory )
+                # Could be caught in #at_exit callbacks, the tmpdir has already
+                # been deleted.
+                return
+            end
+
+            synchronize do
+                @@disk_space = int
+                IO.write( disk_space_file, @@disk_space.to_s )
+            end
+        end
+
+        def synchronize( &block )
+            (@@mutex ||= Mutex.new).synchronize( &block )
+        end
+
+    end
+    reset
+
+    # @param    [Hash]    options
+    #   Any object that responds to 'dump' and 'load'.
+    def initialize( options = {} )
+        @options = options.dup
+
+        @options[:dumper] ||= Marshal
+        @options[:loader] ||= @options[:dumper]
+
+        @filename_counter = 0
+
+        at_exit do
+            clear
+        end
+    end
+
+    def serialize( obj )
+        compress(
+            @options[:dumper].respond_to?( :dump ) ?
+                @options[:dumper].dump( obj ) :
+                @options[:dumper].call( obj )
+        )
+    end
+
+    def unserialize( data )
+        data = decompress( data )
+
+        @options[:loader].respond_to?( :load ) ?
+            @options[:loader].load( data ) :
+            @options[:loader].call( data )
+    end
+
+    private
+
+    # Dumps the object to a unique file and returns its path.
+    #
+    # The path can be used as a reference to the original value
+    # by way of passing it to load().
+    #
+    # @param    [Object]    obj
+    #
+    # @return   [String]
+    #   Filepath
+    def dump( obj, &block )
+        File.open( get_unique_filename, 'wb' ) do |f|
+            serialized = serialize( obj )
+            self.class.increment_disk_space f.write( serialized )
+
+            block.call( serialized ) if block_given?
+
+            f.path
+        end
+    end
+
+    # Loads the object stored in filepath.
+    #
+    # @param    [String]    filepath
+    #
+    # @return   [Object]
+    def load( filepath )
+        unserialize( IO.binread( filepath ) )
+    end
+
+    # Deletes a file.
+    #
+    # @param    [String]    filepath
+    def delete_file( filepath )
+        return if !File.exist?( filepath )
+
+        self.class.decrement_disk_space File.size( filepath )
+        File.delete( filepath )
+    end
+
+    # Loads the object in file and then removes it from the file-system.
+    #
+    # @param    [String]    filepath
+    #
+    # @return   [Object]
+    def load_and_delete_file( filepath )
+        obj = load( filepath )
+        delete_file( filepath )
+        obj
+    end
+
+    def compress( string )
+        Zlib::Deflate.deflate string
+    end
+
+    def decompress( string )
+        Zlib::Inflate.inflate string
+    end
+
+    def get_unique_filename
+        # Should be unique enough...
+        ("#{self.class.disk_directory}/#{self.class.name}_#{object_id}_" <<
+            @filename_counter.to_s).gsub( '::', '_' )
+    ensure
+        @filename_counter += 1
+    end
+
+end
+
+end
+end

data/lib/cuboid/support/database/categorized_queue.rb

@@ -0,0 +1,195 @@
+module Cuboid
+module Support::Database
+
+# @author Tasos "Zapotek" Laskos <tasos.laskos@gmail.com>
+class CategorizedQueue < Base
+
+    # Default {#max_buffer_size}.
+    DEFAULT_MAX_BUFFER_SIZE = 100
+
+    # @return   [Integer]
+    #   How many entries to keep in memory before starting to off-load to disk.
+    attr_accessor :max_buffer_size
+
+    attr_accessor :prefer
+
+    # @see Cuboid::Database::Base#initialize
+    def initialize( options = {}, &block )
+        super( options )
+
+        @prefer = block
+        @max_buffer_size = options[:max_buffer_size] || DEFAULT_MAX_BUFFER_SIZE
+
+        @categories ||= {}
+        @waiting = []
+        @mutex   = Mutex.new
+
+        @buffer_size = 0
+        @disk_size   = 0
+    end
+
+    # @note Defaults to {DEFAULT_MAX_BUFFER_SIZE}.
+    #
+    # @return   [Integer]
+    #   How many entries to keep in memory before starting to off-load to disk.
+    def max_buffer_size
+        @max_buffer_size
+    end
+
+    def categories
+        @categories.keys
+    end
+
+    def data_for( category )
+        @categories[category.to_s] ||= {
+            disk:   [],
+            buffer: []
+        }
+    end
+
+    def insert_to_disk( category, path )
+        data_for( category )[:disk] << path
+        @disk_size += 1
+    end
+
+    # @param    [Object]    obj
+    #   Object to add to the queue.
+    #   Must respond to #category.
+    def <<( obj )
+        fail ArgumentError, 'Missing #prefer block.' if !@prefer
+
+        if !obj.respond_to?( :category )
+            fail ArgumentError, "#{obj.class} does not respond to #category."
+        end
+
+        synchronize do
+            data = data_for( obj.category )
+
+            if data[:buffer].size < max_buffer_size
+                @buffer_size += 1
+                data[:buffer] << obj
+            else
+                @disk_size += 1
+                data[:disk] << dump( obj )
+            end
+
+            begin
+                t = @waiting.shift
+                t.wakeup if t
+            rescue ThreadError
+                retry
+            end
+        end
+    end
+    alias :push :<<
+    alias :enq :<<
+
+    # @return   [Object]
+    #   Removes an object from the queue and returns it.
+    def pop( non_block = false )
+        fail ArgumentError, 'Missing #prefer block.' if !@prefer
+
+        synchronize do
+            loop do
+                if internal_empty?
+                    raise ThreadError, 'queue empty' if non_block
+                    @waiting.push Thread.current
+                    @mutex.sleep
+                else
+                    # Get preferred category, hopefully there'll be some data
+                    # for it.
+                    category = @prefer.call( @categories.keys )
+
+                    # Get all other available categories just in case the
+                    # preferred one is empty.
+                    categories = @categories.keys
+                    categories.delete category
+
+                    data = nil
+                    # Check if our category has data and pick another if not.
+                    loop do
+                        data = data_for( category )
+                        if data[:buffer].any? || data[:disk].any?
+                            break
+                        end
+
+                        category = categories.pop
+                    end
+
+                    if data[:buffer].any?
+                        @buffer_size -= 1
+                        return data[:buffer].shift
+                    end
+
+                    @disk_size -= 1
+                    return load_and_delete_file( data[:disk].shift )
+                end
+            end
+        end
+    end
+    alias :deq :pop
+    alias :shift :pop
+
+    # @return   [Integer]
+    #   Size of the queue, the number of objects it currently holds.
+    def size
+        buffer_size + disk_size
+    end
+    alias :length :size
+
+    def free_buffer_size
+        max_buffer_size - buffer_size
+    end
+
+    def buffer_size
+        @buffer_size
+    end
+
+    def disk_size
+        @disk_size
+    end
+
+    # @return   [Bool]
+    #   `true` if the queue if empty, `false` otherwise.
+    def empty?
+        synchronize do
+            internal_empty?
+        end
+    end
+
+    # Removes all objects from the queue.
+    def clear
+        synchronize do
+            @categories.values.each do |data|
+                data[:buffer].clear
+
+                while !data[:disk].empty?
+                    path = data[:disk].pop
+                    next if !path
+                    delete_file path
+                end
+            end
+
+            @buffer_size = 0
+            @disk_size   = 0
+        end
+    end
+
+    def num_waiting
+        @waiting.size
+    end
+
+    private
+
+    def internal_empty?
+        @buffer_size == 0 && @disk_size == 0
+    end
+
+    def synchronize( &block )
+        @mutex.synchronize( &block )
+    end
+
+end
+
+end
+end