opod 0.0.1

data/COPYING

@@ -0,0 +1,36 @@
+Opod
+
+Copyright (c) 2007, George Moschovitis & Thomas Sawyer
+
+All rights reserved.
+
+This software is distributed under the terms of the BSD license.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions
+are met:
+
+* Redistributions of source code must retain the above copyright
+  notice, this list of conditions and the following disclaimer.
+
+* Redistributions in binary form must reproduce the above
+  copyright notice, this list of conditions and the following
+  disclaimer in the documentation and/or other materials provided
+  with the distribution.
+
+* Neither the name of the copyright holders nor the names of
+  contributors may be used to endorse or promote products derived
+  from this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
+TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR
+PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF
+LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING
+NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+

data/README

@@ -0,0 +1,29 @@
+= Opod
+
+Opod is a adaptive cache system for Ruby. It can persist data to
+a variety of static sources --in memory, to file, or via database.
+
+
+== Installation
+
+Installing via RubyGems:
+
+  gem install opod
+
+Manual install:
+
+  $ unzip opod-0.0.1.zip
+  $ cd opod-0.0.1.zip
+  $ sudo task/setup
+
+Windows users the last line will be 'ruby task/setup'.
+
+
+== Copying
+
+Copyright (c) 2005-2007 Thomas Sawyer, George Moschovitis
+
+All rights reserved.
+
+BSD License
+

data/lib/opod/cache.rb

@@ -0,0 +1,24 @@
+# TITLE:
+#   Cache
+#
+# SUMMARY:
+#   Base classes for all cache adapters.
+#   However it is not used yet.
+
+module Opod
+
+  # A general cache key.
+
+  class CacheKey
+  end
+
+  # A general cache mechanism.
+  #
+  # This cache system was originaly developed for Nitro. It is
+  # used to cache fragments, og objects (entities), sessions,
+  # application scoped variables and more.
+
+  class Cache
+  end
+
+end

data/lib/opod/drb.rb

@@ -0,0 +1,51 @@
+require "drb"
+require "facets/settings"
+require "nemo/memory"
+
+module Opod
+
+  # A cached backed in a DRb server.
+  #
+  # === Example
+  #
+  # This cache needs a corresponding DRb server. Here is how you
+  # can setup the standard Nitro Drb server to keep a DrbCache:
+  #
+  # require 'glue/cache/memory'
+  #
+  # class MyDrbServer < Nitro::DrbServer
+  #   def setup_drb_objects
+  #     ..
+  #     @my_cache = SyncHash.new
+  #     DRb.start_service("druby://#{my_drb_address}:#{my_drb_port}", @my_cache)
+  #     ..
+  #   end
+  # end
+  #
+  # MyDrbServer.start
+
+  class DrbCache < MemoryCache
+
+    # Initialize the cache.
+    #
+    # === Options
+    #
+    # :address = The address of the DRb cache object.
+    # :port = The port of the DRb cache object.
+
+    # The address of the Session cache / store (if distibuted).
+
+    setting :address, :default => '127.0.0.1', :doc => 'The address of the Session cache'
+
+    # The port of the Session DRb cache / store (if distributed).
+
+    setting :port, :default => 9069, :doc => 'The port of the Session cache'
+
+
+    def initialize(address = DrbCache.address, port = DrbCache.port)
+      @hash = DRbObject.new(nil, "druby://#{address}:#{port}")
+    end
+
+  end
+
+end

data/lib/opod/file.rb

@@ -0,0 +1,79 @@
+require "uri"
+require "fileutils"
+require "tmpdir"
+
+module Opod
+
+  class FileCache
+
+    setting :basedir, :default => "#{Dir.tmpdir}/nitro_file_cache", :doc => "The directory to store files"
+
+    def initialize(name = "cache", keepalive = nil)
+      @path = File.join(FileCache.basedir, name)
+      @keepalive = keepalive
+
+      FileUtils.mkdir_p(@path, :mode => 0700)
+    end
+
+    def []=(k,v)
+      fn = File.join(@path, escape_filename(k.to_s) )
+      encode_file(fn, v)
+    end
+    alias_method :set, :[]=
+
+    def [](k)
+      fn = File.join(@path, escape_filename(k.to_s) )
+      return nil unless File.exists?(fn)
+      decode_file(fn)
+    end
+    alias_method :get, :[]
+
+    def delete(k)
+      f = File.join(@path, escape_filename(k.to_s))
+      File.delete(f) if File.exists?(f)
+    end
+
+    def gc!
+      return unless @keepalive
+
+      now = Time.now
+      all.each do |fn|
+        expire_time = File.stat(fn).atime + @keepalive
+        File.delete(fn) if now > expire_time
+      end
+    end
+
+    def all
+      Dir.glob( File.join(@path, '*' ) )
+    end
+
+    private
+
+    def decode_file(fn)
+      val = nil
+      File.open(fn,"rb") do |f|
+        f.flock(File::LOCK_EX)
+        val = Marshal.load( f.read )
+        f.flock(File::LOCK_UN)
+      end
+      return val
+    end
+
+    def encode_file(fn, value)
+      File.open(fn, "wb") do |f|
+        f.flock(File::LOCK_EX)
+        f.chmod(0600)
+        f.write(Marshal.dump(value))
+        f.flock(File::LOCK_UN)
+      end
+    end
+
+    # need this for fat filesystems
+    def escape_filename(fn)
+      URI.escape(fn, /["\/:;|=,\[\]]/)
+    end
+
+  end
+
+end
+

data/lib/opod/memcached.rb

@@ -0,0 +1,69 @@
+# specifications:
+# http://cvs.danga.com/browse.cgi/wcmtools/memcached/doc/protocol.txt?rev=HEAD&content-type=text/plain
+#
+# very simple (= very fast) client for memcached
+#
+# i found the Ruby-MemCache library a little bit buggy and complicated, so i made my own before
+# fixing it ;)
+#
+# TODO socket disconnection handling
+# TODO error handling
+# TODO multiple servers connections
+
+require "socket"
+
+module Opod
+
+  class MemCached
+
+    setting :address, :default => "localhost", :doc => "Server address"
+    setting :port, :default => 11211, :doc => "Server port"
+
+    def initialize(name = "cache", keepalive = nil)
+      @sock = TCPSocket.new(MemCached.address, MemCached.port)
+      @name = name
+      @keepalive = keepalive
+    end
+
+    def []=(k,v)
+      if @keepalive
+        exptime = (Time.now + @keepalive).to_i
+      else
+        exptime = 0
+      end
+
+      data = Marshal.dump(v)
+      @sock.print("set #{@name}:#{k} 0 #{exptime} #{data.size}\r\n#{data}\r\n")
+      response = @sock.gets # "STORED\r\n"
+      v
+    end
+    alias_method :set, :[]=
+
+    def [](k)
+      @sock.print("get #{@name}:#{k}\r\n")
+      resp = @sock.gets
+      if resp == "END\r\n"
+        return nil
+      end
+
+      #dummy, key, flags, size
+      size = resp.split(/ /).last.to_i
+      raw_data = @sock.read(size)
+      @sock.gets # \r\n
+      @sock.gets # END\r\n
+      Marshal.load( raw_data )
+    end
+    alias_method :get, :[]
+
+    def delete(k)
+      @sock.print("delete #{@name}:#{k}\r\n")
+      @sock.gets # "DELETED\r\n"
+    end
+
+    def gc!
+      # garbage collection is handled by the memcache server
+    end
+
+  end
+
+end

data/lib/opod/memory.rb

@@ -0,0 +1,83 @@
+require 'facets/synchash'
+
+module Opod
+
+  # A cache backed in memory.
+  #--
+  # This implementation is also the base for the Drb Cache.
+  #++
+
+  class MemoryCache
+    attr :hash
+
+    def initialize(options = {})
+      if options[:sync]
+        @hash = SyncHash
+      else
+        @hash = {}
+      end
+    end
+
+    # Was orig. in Cache.
+
+    def update(hash)
+      hash.each { |key, value| self[key] = value }
+    end
+
+    # Get an object from the cache.
+
+    def get(key, options = nil)
+      @hash[key]
+    end
+    alias_method :read, :get
+    alias_method :[], :get
+
+    # Put an object in the cache.
+
+    def set(key, value = nil, options = nil)
+      @hash[key] = value
+    end
+    alias_method :put, :set
+    alias_method :write, :set
+    alias_method :[]=, :set
+
+    # Delete an object from the cache.
+
+    def delete(key, options = nil)
+      @hash.delete(key)
+    end
+    alias_method :remove, :delete
+
+    def delete_if(&block)
+      @hash.delete_if(&block)
+    end
+
+    # Perform session garbage collection. Typically this method
+    # is called from a cron like mechanism.
+
+    def gc!
+      delete_if { |key, s| s.expired? }
+    end
+
+    # Return the mapping.
+
+    def mapping
+      @hash
+    end
+
+    # Return all keys in the cache.
+
+    def keys
+      @hash.keys
+    end
+
+    # Return all objects in the cache.
+
+    def all
+      @hash.values
+    end
+    alias_method :values, :all
+
+  end
+
+end

data/lib/opod/og.rb

@@ -0,0 +1,61 @@
+require 'og'
+require 'base64'
+
+module Opod
+
+  class OgCached
+    include Og::EntityMixin
+
+    property :unique_id, String, :sql => 'PRIMARY KEY'
+    property :expires, Time
+    property :cache_name, String
+    property :content, String
+
+    set_primary_key :unique_id, String
+  end
+
+  class OgCache
+
+    def initialize(cache_name, keepalive = nil)
+      @cache_name = cache_name
+      @keepalive = keepalive
+    end
+
+    def []=(k,v)
+      unless s = OgCached.find_by_unique_id_and_cache_name(k.to_s, @cache_name)
+        s = OgCached.new
+        s.cache_name = @cache_name
+        s.expires = Time.now + @keepalive if @keepalive
+        s.unique_id = k.to_s
+      end
+      #s.content = v.to_yaml
+      s.content = encode(v)
+      s.insert
+    end
+
+    def [](k)
+      s = OgCached.find_by_unique_id_and_cache_name(k.to_s, @cache_name)
+      decode(s.content) if s
+    end
+
+    def gc!
+      OgCached.find(:condition => ["expires < ? AND cache_name = ?", Time.now, @cache_name]).each {|s| s.delete }
+    end
+
+    def all
+      OgCached.find_by_cache_name(@cache_name)
+    end
+
+    private
+
+    def encode(c)
+      Base64.encode64(Marshal.dump(c))
+    end
+
+    def decode(c)
+      Marshal::load(Base64.decode64(c))
+      #s.content = YAML::load(s.content)
+    end
+
+  end
+end

data/lib/opod/pstore.rb

@@ -0,0 +1,187 @@
+require 'fileutils'
+require 'pstore'
+require 'tmpdir'
+
+module Opod
+
+  class PStoreCache
+
+    setting :basedir, :default => File.join(Dir.tmpdir, 'nitro_file_cache'),
+      :doc => 'Base directory for cache files'
+
+    setting :max_tries, :default => 5, :doc => 'Maximum number of tries for cache operations'
+
+    setting :tokens, :default => '0123456789ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz',
+      :doc => 'Tokens used when generating cache file names'
+
+    def initialize(keepalive = nil)
+      @keepalive = keepalive
+      initialize_store
+    end
+
+    # Return the object stored under <i>key</i> from the cache.
+    # If the object isn't present in the cache <b>nil</b> is returned.
+
+    def [](key)
+      current_try = 0
+      begin
+        current_try += 1
+        @store.transaction(true) do
+          @store.fetch(key, nil)[1]
+        end
+      rescue PStore::Error
+        # Unable to return the requested object from the cache.
+        # Create a new store and retry.
+        initialize_store
+        unless current_try > PStoreCache.max_tries
+          retry
+        else
+          raise Exception.new("Unable to read from cache file #{@store.path}!")
+        end
+      end
+    end
+
+    # Store <i>obj</i> under <i>key</i> in the cache.
+
+    def []=(key, obj)
+      current_try = 0
+      begin
+        current_try += 1
+        @store.transaction(false) do
+          if @keepalive
+            @store[key] = [Time.now + @keepalive, obj]
+          else
+            @store[key] = [nil, obj]
+          end
+        end
+      rescue PStore::Error
+        # Unable to store object.
+        # Create a new store and retry.
+        initialize_store
+        unless current_try > PStoreCache.max_tries
+          retry
+        else
+          raise Exception.new("Unable to write to cache file #{@store.path}!")
+        end
+      end
+    end
+
+    # Return all objects stored in the cache.
+
+    def all
+      current_try = 0
+      begin
+        current_try += 1
+        @store.transaction(true) do
+          @store.roots.inject([]) do |result, current|
+            result << @store[current][1]
+          end
+        end
+      rescue PStore::Error
+        # Unable to return stored objects from cache.
+        # Create a new store and retry.
+        initialize_store
+        unless current_try > PStoreCache.max_tries
+          retry
+        else
+          raise Exception.new("Unable to read from cache file #{@store.path}!")
+        end
+      end
+    end
+
+    # Delete the object stored under <i>key</i> in the cache.
+
+    def delete(key)
+      begin
+        @store.transaction(false) do
+          @store.delete(key)
+        end
+      rescue PStore::Error
+        # Unable to delete object from the cache.
+        # Create a new store.
+        initialize_store
+      end
+    end
+
+    # Remove all expired objects from the cache.
+
+    def gc!
+      return unless @keepalive
+      begin
+        now = Time.now
+        @store.transaction(false) do
+          @store.roots.each do |r|
+            @store.delete(r) if now > @store[r][0]
+          end
+        end
+      rescue PStore::Error
+        # Unable to delete object from the cache.
+        # Create a new store.
+        initialize_store
+      end
+    end
+
+    alias get []
+
+    alias put []=
+
+    alias read []
+
+    alias values all
+
+    alias write []=
+
+    private
+
+    # Generate a random filename using <i>tokens</i> and <i>length</i> as constraints.
+
+    def generate_random_filename(tokens = PStoreCache.tokens, length = 16)
+      filename = ''
+      1.upto(length) do
+        filename << tokens[rand(tokens.length)]
+      end
+      filename
+    end
+
+    # Initialize store with a random filename.
+    # If no suitable filename can be found, raise an exception.
+
+    def initialize_store
+      # Create cache directory (if needed)
+      unless File.exists?(PStoreCache.basedir) && File.directory?(PStoreCache.basedir)
+        begin
+          FileUtils.mkdir_p(PStoreCache.basedir)
+        rescue Exception
+          raise Exception.new("Unable to create cache directory #{PStoreCache.basedir}!")
+        end
+      end
+
+      # Check whether the current_process has sufficient privilieges for reading/writing files to the cache directory
+
+      unless File.readable?(PStoreCache.basedir) && File.writable?(PStoreCache.basedir)
+        raise Exception.new("Insuffient priviligies for cache directory #{PStoreCache.basedir}!")
+      end
+
+      # generate a new random filename for the cache file
+
+      current_try = 0
+
+      begin
+        current_try += 1
+        filename = generate_random_filename
+      end while File.exists?(File.join(PStoreCache.basedir, filename)) && current_try < PStoreCache.max_tries
+
+      if current_try <= PStoreCache.max_tries
+        begin
+          @store = PStore.new(File.join(PStoreCache.basedir, filename))
+        rescue Exception
+          raise Exception.new('Unable to create cache file!')
+        end
+      else
+        raise Exception.new('Unable to create cache file!')
+      end
+    end
+
+  end
+
+end

data/meta/MANIFEST

@@ -0,0 +1,21 @@
+# -x doc -x dev -x pkg
+COPYING
+README
+lib
+lib/opod
+lib/opod/cache.rb
+lib/opod/drb.rb
+lib/opod/file.rb
+lib/opod/memcached.rb
+lib/opod/memory.rb
+lib/opod/og.rb
+lib/opod/pstore.rb
+log
+meta
+meta/MANIFEST
+meta/opod-0.0.1.roll
+task
+task/config.yaml
+task/publish
+task/rdoc
+test

data/meta/opod-0.0.1.roll

@@ -0,0 +1,21 @@
+---
+title    : Opod
+author   : George Moschovitis
+contact  : Thomas Sawyer
+email    : transfire@gmail.com
+homepage : "http://opod.rubyforge.org"
+status   : beta
+
+summary: Obejct Pods are places to keep digital stuff.
+
+description: >
+  Object storage through various adapters.
+
+dependency:
+  - [ facets, ">= 2.1.0" ]
+
+formats: [ gem, zip ]
+
+lib_path:
+  - lib/opod
+

data/task/config.yaml

@@ -0,0 +1,9 @@
+rdoc:
+  op: doc/rdoc
+  title: OPOD
+
+publish:
+  source: doc/web
+  project: opod
+  username: transami
+

data/task/publish

@@ -0,0 +1,44 @@
+#!/usr/bin/env ratch
+
+# publish website to rubyforge
+
+# This task publishes the source dir (deafult doc/)
+# to a rubyforge website.
+
+config = configuration['publish']
+
+project     = config['project']
+subdir      = config['subdir']
+source      = config['source']
+username    = ENV['RUBYFORGE_USERNAME'] || config['username']
+protect     = %w{usage statcvs statsvn robot.txt wiki}
+exclude     = %w{.svn}
+
+abort("no project name") unless project
+abort("no username")     unless username
+abort("no source dir")   unless source
+
+if subdir
+  destination = File.join(project, subdir)
+else
+  destination = project
+end
+
+dir = source.chomp('/') + '/'
+url = "#{username}@rubyforge.org:/var/www/gforge-projects/#{destination}"
+
+# maybe -p ?
+op = ['-rLvz', '--delete']
+if File.file?(File.join(source,'.rsync-filter'))
+  op << "--filter='dir-merge #{source}/.rsync-filter'"
+else
+  op.concat exclude.map{|e| "--filter='- #{e}'"}
+  op.concat protect.map{|e| "--filter='P #{e}'"}
+end
+
+args = op + [dir, url]
+
+#cd source do
+  rsync *args
+#end
+

data/task/rdoc

@@ -0,0 +1,40 @@
+#!/usr/bin/env ratch
+
+# generate rdocs
+
+# Generate Rdoc documentation. Settings are
+# the same as the rdoc command's options.
+
+main :rdoc do
+  # Load rdoc configuration.
+
+  config = configuration['rdoc']
+
+  config = {
+    'template'       => 'html',
+    'op'             => 'doc/rdoc',
+    'merge'          => true,
+    'inline-source'  => true,
+    'exclude'        => %w{InstalledFiles Manifest Project dev util},
+    'include'        => %w{[A-Z]* lib}
+  }.update(config)
+
+  output = config['op']
+
+  # Check for 'doc' directory.
+  # (Helps to ensure we're in the right place.)
+
+  dir!(File.dirname(output))
+
+  # Prepare command arguments.
+
+  vector = config.command_vector('include')
+
+  # Remove old rdocs, if any.
+
+  rm_r(output) if File.exist?(output)
+
+  # Document.
+
+  rdoc(*vector)
+end

metadata

@@ -0,0 +1,81 @@
+--- !ruby/object:Gem::Specification 
+rubygems_version: 0.9.4.6
+specification_version: 2
+name: opod
+version: !ruby/object:Gem::Version 
+  version: 0.0.1
+date: 2007-11-14 00:00:00 -05:00
+summary: Obejct Pods are places to keep digital stuff.
+require_paths: 
+- lib
+email: transfire@gmail.com
+homepage: http://opod.rubyforge.org
+rubyforge_project: 
+description: Object storage through various adapters.
+autorequire: 
+default_executable: 
+bindir: bin
+has_rdoc: 
+required_ruby_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      version: "0"
+  version: 
+platform: ruby
+signing_key: 
+cert_chain: []
+
+post_install_message: 
+extensions_fallback: 
+authors: 
+- George Moschovitis
+files: 
+- COPYING
+- README
+- lib
+- lib/opod
+- lib/opod/cache.rb
+- lib/opod/drb.rb
+- lib/opod/file.rb
+- lib/opod/memcached.rb
+- lib/opod/memory.rb
+- lib/opod/og.rb
+- lib/opod/pstore.rb
+- log
+- meta
+- meta/MANIFEST
+- meta/opod-0.0.1.roll
+- task
+- task/config.yaml
+- task/publish
+- task/rdoc
+- test
+test_files: []
+
+rdoc_options: []
+
+extra_rdoc_files: []
+
+executables: []
+
+extensions: []
+
+requirements: []
+
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: facets
+  version_requirement: 
+  version_requirements: !ruby/object:Gem::Requirement 
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        version: 2.1.0
+    version: