juno 0.3.1 → 0.4.0

data/lib/juno/adapters/cassandra.rb

@@ -1,89 +0,0 @@
-# Copyright: 2011 TMX Credit
-# Author: Potapov Sergey (aka Blake)
-
-require 'cassandra'
-
-module Juno
-  module Adapters
-    # Cassandra backend
-    # @api public
-    class Cassandra < Base
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :keyspace - Cassandra keyspace (default 'juno')
-      # * :column_family - Cassandra column family (default 'juno')
-      # * :host - Server host name (default 127.0.0.1)
-      # * :port - Server port (default 9160)
-      def initialize(options = {})
-        options[:host] ||= '127.0.0.1'
-        options[:port] ||=  9160
-        keyspace = (options[:keyspace] ||= 'juno')
-        @cf = (options[:column_family] || 'juno').to_sym
-        @client = ::Cassandra.new('system', "#{options[:host]}:#{options[:port]}")
-        unless @client.keyspaces.include?(keyspace)
-          cf_def = ::Cassandra::ColumnFamily.new(:keyspace => keyspace, :name => @cf.to_s)
-          ks_def = ::Cassandra::Keyspace.new(:name => keyspace,
-                                             :strategy_class => 'SimpleStrategy',
-                                             :strategy_options => { 'replication_factor' => '1' },
-                                             :replication_factor => 1,
-                                             :cf_defs => [cf_def])
-          # Wait for keyspace to be created (issue #24)
-          10.times do
-            begin
-              @client.add_keyspace(ks_def)
-            rescue Exception => ex
-              puts "Cassandra: #{ex.message}"
-            end
-            break if @client.keyspaces.include?(keyspace)
-            sleep 0.1
-          end
-        end
-        @client.keyspace = keyspace
-      end
-
-      def key?(key, options = {})
-        if @client.exists?(@cf, key)
-          if options.include?(:expires) && (value = load(key))
-            store(key, value, options)
-          end
-          true
-        else
-          false
-        end
-      end
-
-      def load(key, options = {})
-        value = @client.get(@cf, key)
-        if value
-          if options.include?(:expires)
-            store(key, value['value'], options)
-          else
-            value['value']
-          end
-        end
-      end
-
-      def delete(key, options = {})
-        if value = load(key, options)
-          @client.remove(@cf, key)
-          value
-        end
-      end
-
-      def store(key, value, options = {})
-        @client.insert(@cf, key, {'value' => value}, :ttl => options[:expires])
-        value
-      end
-
-      def clear(options = {})
-        @client.each_key(@cf) do |key|
-          delete(key)
-        end
-        self
-      end
-    end
-  end
-end

data/lib/juno/adapters/cookie.rb

@@ -1,35 +0,0 @@
-module Juno
-  module Adapters
-    class Cookie < Memory
-      attr_reader :cookies
-
-      def initialize(options = {})
-        super
-        @options, @cookies = options, {}
-      end
-
-      def store(key, value, options = {})
-        cookie = @options.merge(options)
-        cookie[:value] = value
-        cookie[:expires] += Time.now.to_i if cookie[:expires]
-        @cookies[key] = cookie
-        super
-      end
-
-      def delete(key, options = {})
-        @cookies[key] = nil
-        super
-      end
-
-      def clear(options = {})
-        @memory.each_key { |key| @cookies[key] = nil }
-        super
-        self
-      end
-
-      def reset(cookies)
-        @cookies, @memory = {}, cookies
-      end
-    end
-  end
-end

data/lib/juno/adapters/couch.rb

@@ -1,57 +0,0 @@
-require 'couchrest'
-
-module Juno
-  module Adapters
-    # CouchDB backend
-    # @api public
-    class Couch < Base
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :db - Couch database
-      def initialize(options = {})
-        raise ArgumentError, 'Option :db is required' unless options[:db]
-        @db = ::CouchRest.database!(options[:db])
-      end
-
-      def key?(key, options = {})
-        @db.get(key) != nil
-      rescue RestClient::ResourceNotFound
-        false
-      end
-
-      def load(key, options = {})
-        @db.get(key)['value']
-      rescue RestClient::ResourceNotFound
-        nil
-      end
-
-      def store(key, value, options = {})
-        doc = {'_id' => key, 'value' => value}
-        begin
-          doc['_rev'] = @db.get(key)['_rev']
-        rescue RestClient::ResourceNotFound
-        end
-        @db.save_doc(doc)
-        value
-      rescue RestClient::RequestFailed
-        value
-      end
-
-      def delete(key, options = {})
-        value = @db.get(key)
-        @db.delete_doc('_id' => value['_id'], '_rev' => value['_rev'])
-        value['value']
-      rescue RestClient::ResourceNotFound
-        nil
-      end
-
-      def clear(options = {})
-        @db.recreate!
-        self
-      end
-    end
-  end
-end

data/lib/juno/adapters/datamapper.rb

@@ -1,76 +0,0 @@
-require 'dm-core'
-require 'dm-migrations'
-
-module Juno
-  module Adapters
-    # Datamapper backend
-    # @api public
-    class DataMapper < Base
-      class Store
-        include ::DataMapper::Resource
-        property :k, Text, :key => true
-        property :v, Text, :lazy => false
-      end
-
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :setup - Datamapper setup string
-      # * :repository - Repository name (default :juno)
-      # * :table - Table name (default :juno)
-      def initialize(options = {})
-        raise ArgumentError, 'Option :setup is required' unless options[:setup]
-        @repository = options.delete(:repository) || :juno
-        Store.storage_names[@repository] = (options.delete(:table) || :juno).to_s
-        ::DataMapper.setup(@repository, options[:setup])
-        context { Store.auto_upgrade! }
-      end
-
-      def key?(key, options = {})
-        context { Store.get(key) != nil }
-      end
-
-      def load(key, options = {})
-        context do
-          record = Store.get(key)
-          record ? record.v : nil
-        end
-      end
-
-      def store(key, value, options = {})
-        context do
-          record = Store.get(key)
-          if record
-            record.update(:k => key, :v => value)
-          else
-            Store.create(:k => key, :v => value)
-          end
-          value
-        end
-      end
-
-      def delete(key, options = {})
-        context do
-          if record = Store.get(key)
-            value = record.v
-            record.destroy!
-            value
-          end
-        end
-      end
-
-      def clear(options = {})
-        context { Store.all.destroy! }
-        self
-      end
-
-      private
-
-      def context
-        ::DataMapper.repository(@repository) { yield }
-      end
-    end
-  end
-end

data/lib/juno/adapters/dbm.rb

@@ -1,25 +0,0 @@
-require 'dbm'
-
-module Juno
-  module Adapters
-    # DBM backend (Berkeley DB)
-    # @api public
-    class DBM < Memory
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :file - Database file
-      def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        @memory = ::DBM.new(options[:file])
-      end
-
-      def close
-        @memory.close
-        nil
-      end
-    end
-  end
-end

data/lib/juno/adapters/file.rb

@@ -1,60 +0,0 @@
-require 'fileutils'
-
-module Juno
-  module Adapters
-    # Filesystem backend
-    # @api public
-    class File < Base
-      def initialize(options = {})
-        raise ArgumentError, 'Option :dir is required' unless @dir = options[:dir]
-        FileUtils.mkpath(@dir)
-        raise "#{@dir} is not a directory" unless ::File.directory?(@dir)
-      end
-
-      def key?(key, options = {})
-        ::File.exist?(store_path(key))
-      end
-
-      def load(key, options = {})
-        ::File.read(store_path(key))
-      rescue Errno::ENOENT
-      end
-
-      def store(key, value, options = {})
-        path = store_path(key)
-        temp_file = ::File.join(@dir, "value-#{$$}-#{Thread.current.object_id}")
-        FileUtils.mkpath(::File.dirname(path))
-        ::File.open(temp_file, 'wb') {|file| file.write(value) }
-        ::File.unlink(path) if ::File.exist?(path)
-        ::File.rename(temp_file, path)
-        value
-      rescue Errno::ENOENT
-        ::File.unlink(temp_file) rescue nil
-        value
-      end
-
-      def delete(key, options = {})
-        value = load(key, options)
-        ::File.unlink(store_path(key))
-        value
-      rescue Errno::ENOENT
-      end
-
-      def clear(options = {})
-        temp_dir = "#{@dir}-#{$$}-#{Thread.current.object_id}"
-        ::File.rename(@dir, temp_dir)
-        FileUtils.mkpath(@dir)
-        FileUtils.rm_rf(temp_dir)
-        self
-      rescue Errno::ENOENT
-        self
-      end
-
-      protected
-
-      def store_path(key)
-        ::File.join(@dir, key)
-      end
-    end
-  end
-end

data/lib/juno/adapters/fog.rb

@@ -1,51 +0,0 @@
-require 'fog'
-
-module Juno
-  module Adapters
-    # Fog backend (Cloud storage services)
-    # @api public
-    class Fog < Base
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :dir - Fog directory
-      # * Other options passed to Fog::Storage#new
-      def initialize(options = {})
-        raise ArgumentError, 'Option :dir is required' unless dir = options.delete(:dir)
-        storage = ::Fog::Storage.new(options)
-        @directory = storage.directories.create(:key => dir)
-      end
-
-      def key?(key, options = {})
-        @directory.files.head(key) != nil
-      end
-
-      def load(key, options = {})
-        value = @directory.files.get(key)
-        value ? value.body : nil
-      end
-
-      def delete(key, options = {})
-        if value = @directory.files.get(key)
-          body = value.body
-          value.destroy
-          body
-        end
-      end
-
-      def store(key, value, options = {})
-        @directory.files.create(:key => key, :body => value)
-        value
-      end
-
-      def clear(options = {})
-        @directory.files.all.each do |file|
-          file.destroy
-        end
-        self
-      end
-    end
-  end
-end

data/lib/juno/adapters/gdbm.rb

@@ -1,25 +0,0 @@
-require 'gdbm'
-
-module Juno
-  module Adapters
-    # GDBM backend
-    # @api public
-    class GDBM < Memory
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :file - Database file
-      def initialize(options = {})
-        raise ArgumentError, 'Option :file is required' unless options[:file]
-        @memory = ::GDBM.new(options[:file])
-      end
-
-      def close
-        @memory.close
-        nil
-      end
-    end
-  end
-end

data/lib/juno/adapters/hbase.rb

@@ -1,64 +0,0 @@
-require 'hbaserb'
-
-module Juno
-  module Adapters
-    # HBase thrift backend
-    # @api public
-    class HBase < Base
-      # Constructor
-      #
-      # @param [Hash] options
-      #
-      # Options:
-      # * :host - Server host name (default 127.0.0.1)
-      # * :port - Server port (default 9090)
-      # * :table - Table name (default juno)
-      # * :column_family - Column family (default juno)
-      # * :column - Column (default value)
-      def initialize(options = {})
-        options[:host] ||= '127.0.0.1'
-        options[:port] ||= '9090'
-        options[:table] ||= 'juno'
-        options[:column] ||= 'value'
-        cf = (options[:column_family] || 'juno')
-        @db = HBaseRb::Client.new(options[:host], options[:port])
-        @db.create_table(options[:table], cf) unless @db.has_table?(options[:table])
-        @table = @db.get_table(options[:table])
-        @column = "#{cf}:#{options[:column]}"
-      end
-
-      def key?(key, options = {})
-        @table.get(key, @column).first != nil
-      end
-
-      def load(key, options = {})
-        value = @table.get(key, @column).first
-        value ? value.value : nil
-      end
-
-      def delete(key, options = {})
-        if value = load(key, options)
-          @table.delete_row(key)
-          value
-        end
-      end
-
-      def store(key, value, options = {})
-        @table.mutate_row(key, @column => value)
-        value
-      end
-
-      def clear(options = {})
-        @table.create_scanner do |row|
-          @table.delete_row(row.row)
-        end
-        self
-      end
-
-      def close
-        @db.close
-        nil
-      end
-    end
-  end
-end