fog-external 0.0.1

data/.gitignore

@@ -0,0 +1,5 @@
+*.gem
+.bundle
+Gemfile.lock
+pkg/*
+examples/ernie.pid

data/.travis.yml

@@ -0,0 +1 @@
+rvm: 1.9.2

data/Gemfile

@@ -0,0 +1,6 @@
+source "http://rubygems.org"
+
+# Specify your gem's dependencies in fog-bertrpc.gemspec
+gemspec
+
+gem "bertrpc"

data/README.md

@@ -0,0 +1,32 @@
+# Fog-External
+With `fog-external`, you can use arbitrary Ruby objects as backend for `Fog::Storage`. This can mean a custom-written local-storage backend, or, without any more configuration, a BERT-RPC (or any other RPC implementation) remote call.
+
+## Installation
+    gem install fog-external
+
+## Usage
+    require 'fog/external/storage'
+    
+    storage = Fog::Storage.new({
+      :provider   => 'External',
+      :delegate   => BERTRPC::Service.new('localhost', 9999).call.fog
+    })
+
+You can then use `storage` just like any other Fog::Storage object, see [the Fog docs](http://fog.io/1.1.1/storage/) for what's possible.. The API is compatible to the one of `Fog::Local`.
+
+The delegate must respond to a number of backend methods. The delegate in the above-example uses [BERT-RPC][1] to call a server on localhost:9999, using the `fog` module name.
+See `examples/example.rb` for a complete example *including a Ernie-powered BERT-RPC backend*.
+
+## Copyright
+
+(The MIT License)
+
+Copyright © 2011 Jonas Schneider
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
+
+  [1]: https://github.com/mojombo/bertrpc

data/Rakefile

@@ -0,0 +1,11 @@
+require 'rubygems'
+require 'bundler/gem_tasks'
+
+task :default => [:spec]
+
+require 'rspec/core/rake_task'
+desc "Run specs"
+RSpec::Core::RakeTask.new do |t|
+  t.pattern    = FileList['spec/**/*_spec.rb']
+  t.rspec_opts = %w(-fp --color)
+end

data/Watchrfile

@@ -0,0 +1,37 @@
+# vim:set filetype=ruby:
+def run(cmd)
+  puts cmd
+  system cmd
+end
+
+def run_spec(args)
+  run("spin push #{args}")
+  #run("bundle exec rspec --fail-fast #{args}")
+end
+
+def spec(file)
+  if File.exists?(file)
+    run_spec(file)
+  else
+    puts("Spec: #{file} does not exist.")
+  end
+end
+
+watch("spec/.*/*_spec\.rb") do |match|
+  puts(match[0])
+  spec(match[0])
+end
+
+watch("lib/(.*/*)\.rb") do |match|
+  puts(match[0])
+  if File.exists?(p = "spec/"+match[1]+"_spec.rb")
+    spec(p)
+  else
+    spec("spec/fog/external/storage_spec.rb")
+  end
+end
+
+watch("spec/service_mock\.rb") do |match|
+  puts(match[0])
+  spec("spec/fog/external/storage_spec.rb")
+end

data/examples/ernie.conf

@@ -0,0 +1,4 @@
+[{module, fog},
+ {type, external},
+ {command, "ruby examples/fog.rb"},
+ {count, 1}].

data/examples/example.rb

@@ -0,0 +1,36 @@
+require 'rubygems'
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'fog/external/storage'
+require "bertrpc"
+
+ROOT = '/tmp/fog-external-example-root'
+Dir.chdir File.join(File.dirname(__FILE__), '..')
+
+Dir.mkdir(ROOT) unless File.exists?(ROOT)
+
+def run(cmd)
+  puts "=> #{cmd}"
+  system cmd
+end
+
+puts "Starting ernie on localhost:8000"
+run "ernie -d -c examples/ernie.conf -P examples/ernie.pid -a /tmp/ernie.log"
+
+puts "Ernie running."
+
+storage = Fog::Storage.new({
+  :provider   => 'External',
+  :delegate   => BERTRPC::Service.new('localhost', 8000).call.fog
+})
+
+puts "Known directories: "
+puts storage.directories.all.inspect
+
+puts "Creating directory mydir/ ..."
+puts storage.directories.create(key: 'mydir').save
+
+puts "Known directories: "
+puts storage.directories.all.inspect
+
+puts "Stopping ernie on localhost:8000"
+run "kill `cat examples/ernie.pid`"

data/examples/fog.rb

@@ -0,0 +1,102 @@
+require 'ernie'
+ROOT = '/tmp/fog-external-example-root'
+# ported from Fog's Local storage
+
+module Fog
+  def create_directory(key)
+    if ::File.directory?(path_to(key))
+      false
+    else
+      Dir.mkdir path_to(key)
+    end
+  end
+  
+  def list_directories
+    data = Dir.entries(ROOT).select do |entry|
+      entry[0...1] != '.' && ::File.directory?(path_to(entry))
+    end.map do |entry|
+      {:key => entry}
+    end
+  end
+  
+  def get_directory(key)
+    if ::File.directory?(path_to(key))
+      { key: key }
+    else
+      nil
+    end
+  end
+  
+  def destroy_directory(key)
+    if ::File.directory?(path_to(key))
+      Dir.rmdir(path_to(key))
+      true
+    else
+      false
+    end
+  end
+  
+  
+  def list_files(dir_key)
+    Dir.chdir(path_to(dir_key)) do
+      data = Dir.glob('**/*').reject do |file|
+        ::File.directory?(file)
+      end.map do |key|
+        path = file_path(key)
+        {
+          :content_length => ::File.size(path),
+          :key            => key,
+          :last_modified  => ::File.mtime(path)
+        }
+      end
+    end
+    data
+  end
+  
+  def get_file(key)
+    path = path_to(key)
+    if ::File.exists?(path)
+      {
+        :content_length => ::File.size(path),
+        :key            => key,
+        :last_modified  => ::File.mtime(path),
+        :body           => ::File.read(path)
+      }
+    else
+      nil
+    end
+  end
+  
+  def destroy_file(key)
+    path = path_to(key)
+    
+    if ::File.exists?(path)
+      ::File.delete(path)
+      true
+    else
+      false
+    end
+  end
+  
+  def save_file(key, body)
+    file = ::File.new(path, 'wb')
+    if body.is_a?(String)
+      file.write(body)
+    else
+      file.write(body.read)
+    end
+    file.close
+    
+    ::File.mtime(path)
+  rescue
+    false
+  end
+  
+  private
+  
+  def path_to(entry)
+    ::File.join(ROOT, entry)
+  end
+end
+
+Ernie.expose(:fog, Fog)

data/fog-external.gemspec

@@ -0,0 +1,24 @@
+# -*- encoding: utf-8 -*-
+$:.push File.expand_path("../lib", __FILE__)
+
+Gem::Specification.new do |s|
+  s.name        = "fog-external"
+  s.version     = "0.0.1"
+  s.authors     = ["Jonas Schneider"]
+  s.email       = ["mail@jonasschneider.com"]
+  s.homepage    = ""
+  s.summary     = %q{Fog::Storage with a consistent API}
+  s.description = %q{Use a custom backend (such as BERTRPC) with Fog:Storage.}
+
+
+  s.files         = `git ls-files`.split("\n")
+  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  s.require_paths = ["lib"]
+
+  # specify any dependencies here; for example:
+  s.add_development_dependency('rake')
+  s.add_development_dependency "rspec"
+  
+  s.add_runtime_dependency "fog"
+end

data/lib/fog/external/models/storage/directories.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/external/models/storage/directory'
+
+module Fog
+  module Storage
+    class External
+
+      class Directories < Fog::Collection
+        model Fog::Storage::External::Directory
+  
+        def all
+          load(connection.remote.list_directories)
+        end
+  
+        def get(id)
+          data = connection.remote.get_directory(id)
+          if data
+            new(data)
+          else
+            nil
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/external/models/storage/directory.rb

@@ -0,0 +1,44 @@
+require 'fog/core/model'
+require 'fog/external/models/storage/files'
+
+module Fog
+  module Storage
+    class External
+      
+      class Directory < Fog::Model
+        identity  :key
+  
+        def destroy
+          requires :key
+          
+          connection.remote.destroy_directory(identity)
+          true
+        end
+        
+        def files
+          @files ||= begin
+            Fog::Storage::External::Files.new(
+              :directory    => self,
+              :connection   => connection
+            )
+          end
+        end
+        
+        def public=(new_public)
+          new_public
+        end
+        
+        def public_url
+          nil
+        end
+  
+        def save
+          requires :key
+          
+          connection.remote.create_directory(identity)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/external/models/storage/file.rb

@@ -0,0 +1,79 @@
+require 'fog/core/model'
+
+module Fog
+  module Storage
+    class External
+      
+      class File < Fog::Model
+        identity  :key,             :aliases => 'Key'
+
+        attribute :content_length,  :aliases => 'Content-Length', :type => :integer
+        attribute :last_modified,   :aliases => 'Last-Modified'
+        
+        def directory
+          @directory
+        end
+        
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+        
+        def content_type
+          @content_type ||= begin
+            unless (mime_types = ::MIME::Types.of(key)).empty?
+              mime_types.first.content_type
+            end
+          end
+        end
+        
+        def body
+          attributes[:body] ||= if last_modified
+            directory.files.get(identity).body
+          else
+            ''
+          end
+        end
+        
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+        
+        def destroy
+          requires :key, :directory
+          
+          connection.remote.destroy_file(full_key)
+          true
+        end
+        
+        def public=(new_public)
+          new_public
+        end
+        
+        def public_url
+          nil
+        end
+  
+        def save
+          requires :body, :directory, :key
+          
+          if res = connection.remote.save_file(full_key, body)
+            merge_attributes(
+              :content_length => Fog::Storage.get_body_size(body),
+              :last_modified  => res
+            )
+            true
+          else
+            false
+          end
+        end
+        
+        private
+        
+        def full_key
+          ::File.join(directory.key, key)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/external/models/storage/files.rb

@@ -0,0 +1,54 @@
+require 'fog/core/collection'
+require 'fog/external/models/storage/file'
+
+module Fog
+  module Storage
+    class External
+
+      class Files < Fog::Collection
+        attribute :directory
+        model Fog::Storage::External::File
+  
+        def all
+          requires :directory
+          
+          load(connection.remote.list_files(directory.key))
+        end
+  
+        def get(id)
+          requires :directory
+          
+          data = connection.remote.get_file(file_key(id))
+          if data
+            new(data)
+          else
+            nil
+          end
+        end
+        
+        def head(id) # hackish!
+          requires :directory
+          real_key = file_key(id)
+          if data = connection.remote.list_files(directory.key).detect{|c|c[:key] == real_key}
+            new(data)
+          else
+            nil
+          end
+        end
+        
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge!(attributes))
+        end
+      
+        
+        private
+        
+        def file_key(id)
+          ::File.join(directory.key, id)
+        end
+      end
+
+    end
+  end
+end

data/lib/fog/external/storage.rb

@@ -0,0 +1,31 @@
+require 'fog'
+require 'fog/storage'
+
+require 'fog-external'
+
+module Fog
+  module Storage
+    class External < Fog::Service
+
+      requires :delegate
+
+      model_path 'fog/external/models/storage'
+      collection  :directories
+      model       :directory
+      collection  :files
+      model       :file
+
+      class Real
+        def initialize(options={})
+          require 'mime/types'
+          @delegate = options[:delegate]
+        end
+        
+        def remote
+          @delegate
+        end
+      end
+
+    end
+  end
+end

data/lib/fog-external.rb

@@ -0,0 +1,29 @@
+module Fog
+  module Storage
+     def self.new(attributes) # monkey patch to add :external
+      attributes = attributes.dup # prevent delete from having side effects
+      case provider = attributes.delete(:provider).to_s.downcase.to_sym
+      when :aws
+        require 'fog/aws/storage'
+        Fog::Storage::AWS.new(attributes)
+      when :google
+        require 'fog/google/storage'
+        Fog::Storage::Google.new(attributes)
+      when :local
+        require 'fog/local/storage'
+        Fog::Storage::Local.new(attributes)
+      when :ninefold
+        require 'fog/ninefold/storage'
+        Fog::Storage::Ninefold.new(attributes)
+      when :rackspace
+        require 'fog/rackspace/storage'
+        Fog::Storage::Rackspace.new(attributes)
+      when :external
+        require 'fog/external/storage'
+        Fog::Storage::External.new(attributes)
+      else
+        raise ArgumentError.new("#{provider} is not a recognized storage provider")
+      end
+    end
+  end
+end

data/spec/boot.rb

@@ -0,0 +1,9 @@
+require 'pp'
+require 'rubygems'
+require 'bundler'
+Bundler.setup :default, :development
+
+require "rspec"
+
+project_root = File.expand_path(File.join(File.dirname(__FILE__), '..'))
+$:.unshift File.join(project_root, 'lib')

data/spec/fog/external/storage_spec.rb

@@ -0,0 +1,157 @@
+require File.expand_path(File.join(File.dirname(__FILE__), '..', '..', 'spec_helper'))
+
+require 'fog/external/storage'
+
+describe "fog-external" do
+  let(:storage) do
+    storage = Fog::Storage.new({
+      :provider   => 'External',
+      :delegate   => service_mock
+    })
+  end
+  
+  let(:service_mock) do
+    ServiceMock.new
+  end
+  
+  describe "#directories" do
+    it "#create creates a directory" do
+      service_mock.should_receive(:create_directory).with('mykey')
+      directory = storage.directories.create key: 'mykey'
+    end
+    
+    it "#all lists directories" do
+      service_mock.should_receive(:list_directories) { [{:key => 'mykey'}] }
+      storage.directories.all.first.key.should == 'mykey'
+    end
+    
+    describe "#get" do
+      it "gets a directory" do
+        service_mock.should_receive(:get_directory).with('mykey') { {:key => 'mykey'} }
+        x = storage.directories.get('mykey')
+        x.should be_kind_of(Fog::Storage::External::Directory)
+        x.key.should == 'mykey'
+      end
+      
+      it "returns nil for unknown directory keys" do
+        service_mock.should_receive(:get_directory).with('something_strange') { nil }
+        x = storage.directories.get('something_strange')
+        x.should be_nil
+      end
+    end
+  end
+  
+  describe "::Directory" do
+    let(:dir) { Fog::Storage::External::Directory.new connection: storage, key: 'mykey' }
+    
+    it "#files" do
+      dir.files.should be_kind_of(Fog::Storage::External::Files)
+      dir.files.directory.should == dir
+      dir.files.connection.should == storage
+    end
+    
+    it "#destroy" do
+      service_mock.should_receive(:destroy_directory).with('mykey')
+      dir.destroy
+    end
+    
+    it "#public=" do
+      (dir.public = :a).should == :a
+    end
+    
+    it "#public_url" do
+      dir.public_url.should be_nil
+    end
+    
+    it "#save" do
+      service_mock.should_receive(:create_directory).with('mykey')
+      dir.save
+    end
+  end
+  
+  describe "::Files" do
+    let(:dir) { Fog::Storage::External::Directory.new connection: storage, key: 'mykey' }
+    let(:files) { dir.files }
+    
+    it "#all" do
+      service_mock.should_receive(:list_files).with("mykey") { [{:key => 'mykey/a'}] }
+      res = files.all
+      res.first.key.should == 'mykey/a'
+    end
+    
+    it "#get" do
+      data = {:key => 'mykey/a', :content_length => 5, :last_modified => Time.now, :body => 'asdf' }
+      service_mock.should_receive(:get_file).with("mykey/a") { data }
+      res = files.get('a')
+      
+      res.key.should == 'mykey/a'
+      res.content_length.should == 5
+      res.body.should == 'asdf'
+    end
+    
+    it "#head" do
+      service_mock.should_receive(:list_files).twice.with("mykey") { [{:key => 'mykey/a'}] }
+      
+      res = files.head('a')
+      
+      res.key.should == 'mykey/a'
+      res.content_length.should be_nil
+      
+      files.head('b').should be_nil
+    end
+    
+    it "#new" do
+      files.new(:key => 'hai').directory.should == dir
+      files.new(:key => 'hai').key.should == 'hai'
+    end
+  end
+  
+  describe "::Files" do
+    let(:dir) { Fog::Storage::External::Directory.new connection: storage, key: 'mykey' }
+    let(:file) { Fog::Storage::External::File.new connection: storage, last_modified: Time.now, key: 'a', directory: dir }
+    
+    it "#body when the body is not set" do
+      data = {:key => 'mykey/a', :content_length => 5, :last_modified => Time.now, :body => 'asdf' }
+      service_mock.should_receive(:get_file).with("mykey/a") { data }
+      file.body.should == 'asdf'
+    end
+      
+    it "#body when the body is set" do
+      file = Fog::Storage::External::File.new connection: storage, key: 'a', directory: dir, body: 'b'
+      file.body.should == 'b'
+    end
+    
+    it "#body= sets the body" do
+      file.body = 'new'
+      file.body.should == 'new'
+    end
+    
+    it "#directory" do
+      file.directory.should == dir
+    end
+    
+    it "#content_type" do
+      file.key = 'a.txt'
+      file.content_type.should == 'text/plain'
+    end
+    
+    it "#destroy" do
+      service_mock.should_receive(:destroy_file).with("mykey/a")
+      file.destroy
+    end
+    
+    it "#public=" do
+      (file.public = :a).should == :a
+    end
+    
+    it "#public_url" do
+      file.public_url.should be_nil
+    end
+    
+    it "#save" do
+      service_mock.should_receive(:save_file).with("mykey/a", "test")
+      file.body = "test"
+      file.save
+    end
+  end
+end

data/spec/service_mock.rb

@@ -0,0 +1,34 @@
+class ServiceMock
+  def create_directory(key)
+    true
+  end
+  
+  def list_directories
+    [{:key => 'mykey'}]
+  end
+  
+  def get_directory(key)
+    {:key => 'mykey'} || nil
+  end
+  
+  def destroy_directory(key)
+    true
+  end
+  
+  
+  def list_files(dir_key)
+    [{:key => 'mykey/a', :content_length => 5, :last_modified => Time.now}]
+  end
+  
+  def get_file(key)
+    {:key => 'mykey/a', :content_length => 5, :last_modified => Time.now, :body => 'asdf'} || nil
+  end
+  
+  def destroy_file(key)
+    true || false
+  end
+  
+  def save_file(key, body)
+    mtime || false
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,2 @@
+require File.expand_path(File.join(File.dirname(__FILE__), 'boot'))
+require File.expand_path(File.join(File.dirname(__FILE__), 'service_mock'))

metadata

@@ -0,0 +1,102 @@
+--- !ruby/object:Gem::Specification
+name: fog-external
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+  prerelease: 
+platform: ruby
+authors:
+- Jonas Schneider
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2011-12-03 00:00:00.000000000Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: &76776280 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *76776280
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: &76776070 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :development
+  prerelease: false
+  version_requirements: *76776070
+- !ruby/object:Gem::Dependency
+  name: fog
+  requirement: &76775860 !ruby/object:Gem::Requirement
+    none: false
+    requirements:
+    - - ! '>='
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: *76775860
+description: Use a custom backend (such as BERTRPC) with Fog:Storage.
+email:
+- mail@jonasschneider.com
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- .travis.yml
+- Gemfile
+- README.md
+- Rakefile
+- Watchrfile
+- examples/ernie.conf
+- examples/example.rb
+- examples/fog.rb
+- fog-external.gemspec
+- lib/fog-external.rb
+- lib/fog/external/models/storage/directories.rb
+- lib/fog/external/models/storage/directory.rb
+- lib/fog/external/models/storage/file.rb
+- lib/fog/external/models/storage/files.rb
+- lib/fog/external/storage.rb
+- spec/boot.rb
+- spec/fog/external/storage_spec.rb
+- spec/service_mock.rb
+- spec/spec_helper.rb
+homepage: ''
+licenses: []
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  none: false
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 1.8.10
+signing_key: 
+specification_version: 3
+summary: Fog::Storage with a consistent API
+test_files:
+- spec/boot.rb
+- spec/fog/external/storage_spec.rb
+- spec/service_mock.rb
+- spec/spec_helper.rb