fog-atmos 0.0.1

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

@@ -0,0 +1,41 @@
+module Fog
+  module Storage
+    class Atmos
+      class Directories < Fog::Collection
+        model Fog::Storage::Atmos::Directory
+
+        attribute :directory
+
+        def all
+          directory ? ns = directory.key : ns = ''
+          ns = ns + '/' unless ns =~ /\/$/
+          data = service.get_namespace(ns).body[:DirectoryList]
+          data = {:DirectoryEntry => []} if data.kind_of? String
+          data[:DirectoryEntry] = [data[:DirectoryEntry]] if data[:DirectoryEntry].kind_of? Hash
+          dirs = data[:DirectoryEntry].select {|de| de[:FileType] == 'directory'}
+          dirs.each do |d|
+            d[:Filename] = ns + d[:Filename] if directory
+            d[:Filename] += '/' unless d[:Filename] =~ /\/$/
+          end
+          load(dirs)
+        end
+
+        def get(key, _options = {})
+          return nil if key == '' # Root dir shouldn't be retrieved like this.
+          key =~ /\/$/ ? ns = key : ns = key + '/'
+          res = service.get_namespace ns
+          emc_meta = res.headers['x-emc-meta']
+          obj_id = emc_meta.scan(/objectid=(\w+),/).flatten[0]
+          new(:objectid => obj_id, :key => ns)
+        rescue Fog::Storage::Atmos::NotFound
+          nil
+        end
+
+        def new(attributes ={})
+          attributes = {:directory => directory}.merge(attributes) if directory
+          super(attributes)
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,46 @@
+module Fog
+  module Storage
+    class Atmos
+      class Directory < Fog::Model
+        identity :key, :aliases => :Filename
+        attribute :objectid, :aliases => :ObjectID
+
+        def files
+          @files ||= begin
+                       Fog::Storage::Atmos::Files.new(
+                         :directory => self,
+                         :service   => service
+                       )
+                     end
+        end
+
+        def directories
+          @directories ||= begin
+                             Fog::Storage::Atmos::Directories.new(
+                               :directory => self,
+                               :service   => service
+                             )
+                           end
+        end
+
+        def save
+          self.key = attributes[:directory].key + key if attributes[:directory]
+          self.key = key + '/' unless key =~ /\/$/
+          res = service.post_namespace key
+          reload
+        end
+
+        def destroy(opts={})
+          if opts[:recursive]
+            files.each {|f| f.destroy }
+            directories.each do |d|
+              d.files.each {|f| f.destroy }
+              d.destroy(opts)
+            end
+          end
+          service.delete_namespace key
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+module Fog
+  module Storage
+    class Atmos
+      class File < Fog::Model
+        identity  :key,             :aliases => :Filename
+
+        attribute :content_length,  :aliases => ['bytes', 'Content-Length'], :type => :integer
+        attribute :content_type,    :aliases => ['content_type', 'Content-Type']
+        attribute :objectid,        :aliases => :ObjectID
+        attribute :created_at,      :aliases => :ctime
+
+        def body
+          attributes[:body] ||= if objectid
+            collection.get(identity).body
+          else
+            ''
+          end
+        end
+
+        def body=(new_body)
+          attributes[:body] = new_body
+        end
+
+        def directory
+          @directory
+        end
+
+        def copy(target_directory_key, target_file_key, options={})
+          target_directory = service.directories.new(:key => target_directory_key)
+          target_directory.files.create(
+            :key => target_file_key,
+            :body => body
+          )
+        end
+
+        def destroy
+          requires :directory, :key
+          service.delete_namespace([directory.key, key].join('/'))
+          true
+        end
+
+        def meta_data
+         requires :directory, :key
+          service.get_namespace([directory.key, key].join('/') + "?metadata/system")
+        end
+
+        def file_size
+          data = meta_data
+          meta_data.headers["x-emc-meta"].match(/size=\d+/).to_s.gsub(/size=/,"")
+        end
+
+        def public=(new_public)
+          # NOOP - we don't need to flag files as public, getting the public URL for a file handles it.
+        end
+
+        # By default, expire in 5 years
+        def public_url(expires = (Time.now + 5 * 365 * 24 * 60 * 60))
+          file = directory.files.head(key)
+          self.objectid = if file && file.to_s.strip != "" then file.attributes['x-emc-meta'].scan(/objectid=(\w+),/).flatten[0] else nil end
+          if self.objectid && self.objectid.to_s.strip != ""
+            klass = service.ssl? ? URI::HTTPS : URI::HTTP
+            uri = klass.build(:host => service.host, :port => service.port.to_i, :path => "/rest/objects/#{self.objectid}" )
+
+            sb = "GET\n"
+            sb += uri.path.downcase + "\n"
+            sb += service.uid + "\n"
+            sb += String(expires.to_i())
+
+            signature = service.sign( sb )
+            uri.query = "uid=#{CGI::escape(service.uid)}&expires=#{expires.to_i()}&signature=#{CGI::escape(signature)}"
+            uri.to_s
+          else
+            nil
+          end
+        end
+
+        def save(options = {})
+          requires :body, :directory, :key
+          directory.kind_of?(Directory) ? ns = directory.key : ns = directory
+          ns += key
+          options[:headers] ||= {}
+          options[:headers]['Content-Type'] = content_type if content_type
+          options[:body] = body
+          begin
+            data = service.post_namespace(ns, options)
+            self.objectid = data.headers['location'].split('/')[-1]
+          rescue => error
+            if error.message =~ /The resource you are trying to create already exists./
+              data = service.put_namespace(ns, options)
+            else
+              raise error
+            end
+          end
+          # merge_attributes(data.headers)
+          true
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+      end
+    end
+  end
+end

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

@@ -0,0 +1,71 @@
+module Fog
+  module Storage
+    class Atmos
+      class Files < Fog::Collection
+        attribute :directory
+        attribute :limit
+        attribute :marker
+        attribute :path
+        attribute :prefix
+
+        model Fog::Storage::Atmos::File
+
+        def all(options = {})
+          requires :directory
+          directory ? ns = directory.key : ns = ''
+          ns = ns + '/' unless ns =~ /\/$/
+          data = service.get_namespace(ns).body[:DirectoryList]
+          data = {:DirectoryEntry => []} if data.kind_of? String
+          data[:DirectoryEntry] = [data[:DirectoryEntry]] if data[:DirectoryEntry].kind_of? Hash
+          files = data[:DirectoryEntry].select {|de| de[:FileType] == 'regular'}
+          files.each do |s|
+            data = service.head_namespace(directory.key + s[:Filename], :parse => false)
+            headers = Hash[data.headers["x-emc-meta"].split(", ").map{|s|s.split("=")}]
+            s[:content_length] = data.headers["Content-Length"]
+            s[:content_type] = data.headers["Content-Type"]
+            s[:created_at] = headers["ctime"]
+            s[:directory] = directory
+          end
+          # TODO - Load additional file meta?
+          load(files)
+        end
+
+        def get(key, &block)
+          requires :directory
+          data = service.get_namespace(directory.key + key, :parse => false, &block)
+          file_data = data.headers.merge({
+            :body => data.body,
+            :key  => key
+          })
+          new(file_data)
+        rescue Fog::Storage::Atmos::NotFound
+          nil
+        end
+
+        def get_url(key)
+          requires :directory
+          if self.directory.public_url
+            "#{self.directory.public_url}/#{key}"
+          end
+        end
+
+        def head(key, options = {})
+          requires :directory
+          data = service.head_namespace(directory.key + key, :parse => false)
+          file_data = data.headers.merge({
+            :body => data.body,
+            :key => key
+          })
+          new(file_data)
+        rescue Fog::Storage::Atmos::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          requires :directory
+          super({ :directory => directory }.merge!(attributes))
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/atmos/requests/delete_namespace.rb

@@ -0,0 +1,17 @@
+module Fog
+  module Storage
+    class Atmos
+      class Real
+        def delete_namespace(namespace = '', options = {})
+          options = options.reject {|key, value| value.nil?}
+          request({
+                    :expects  => 204,
+                    :method   => 'DELETE',
+                    :path     => "namespace/" + namespace,
+                    :query    => options
+                  }.merge(options))
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/atmos/requests/get_namespace.rb

@@ -0,0 +1,23 @@
+module Fog
+  module Storage
+    class Atmos
+      class Real
+        def get_namespace(namespace = '', options = {}, &block)
+          options = options.reject {|key, value| value.nil?}
+
+          if block_given?
+            options[:response_block] = Proc.new
+          end
+
+          request({
+                    :expects  => 200,
+                    :method   => 'GET',
+                    :path     => "namespace/" + URI.escape(namespace),
+                    :query    => {},
+                    :parse => true
+                  }.merge(options))
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/atmos/requests/head_namespace.rb

@@ -0,0 +1,18 @@
+module Fog
+  module Storage
+    class Atmos
+      class Real
+        def head_namespace(namespace = '', options = {})
+          options = options.reject {|key, value| value.nil?}
+          request({
+                    :expects  => 200,
+                    :method   => 'HEAD',
+                    :path     => "namespace/" + URI.escape(namespace),
+                    :query    => {},
+                    :parse => true
+                  }.merge(options))
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/atmos/requests/post_namespace.rb

@@ -0,0 +1,18 @@
+module Fog
+  module Storage
+    class Atmos
+      class Real
+        def post_namespace(namespace = '', options = {})
+          options = options.reject {|key, value| value.nil?}
+          request({
+                    :expects  => 201,
+                    :method   => 'POST',
+                    :path     => "namespace/" + namespace,
+                    :query    => {},
+                    :parse => true
+                  }.merge(options))
+        end
+      end
+    end
+  end
+end

data/lib/fog/storage/atmos/requests/put_namespace.rb

@@ -0,0 +1,18 @@
+module Fog
+  module Storage
+    class Atmos
+      class Real
+        def put_namespace(namespace = '', options = {})
+          options = options.reject {|key, value| value.nil?}
+          request({
+                    :expects  => 200,
+                    :method   => 'PUT',
+                    :path     => "namespace/" + namespace,
+                    :query    => {},
+                    :parse => true
+                  }.merge(options))
+        end
+      end
+    end
+  end
+end

data/tests/helper.rb

@@ -0,0 +1,36 @@
+require 'excon'
+
+if ENV['COVERAGE']
+  require 'coveralls'
+  require 'simplecov'
+
+  SimpleCov.start do
+    add_filter '/spec/'
+    add_filter '/test/'
+  end
+end
+
+require File.expand_path(File.join(File.dirname(__FILE__), '../lib/fog/atmos'))
+
+Coveralls.wear! if ENV['COVERAGE']
+
+Excon.defaults.merge!(:debug_request => true, :debug_response => true)
+
+require File.expand_path(File.join(File.dirname(__FILE__), 'helpers', 'mock_helper'))
+
+# This overrides the default 600 seconds timeout during live test runs
+if Fog.mocking?
+  FOG_TESTING_TIMEOUT = ENV['FOG_TEST_TIMEOUT'] || 2000
+  Fog.timeout = 2000
+  Fog::Logger.warning "Setting default fog timeout to #{Fog.timeout} seconds"
+else
+  FOG_TESTING_TIMEOUT = Fog.timeout
+end
+
+def lorem_file
+  File.open(File.dirname(__FILE__) + '/lorem.txt', 'r')
+end
+
+def array_differences(array_a, array_b)
+  (array_a - array_b) | (array_b - array_a)
+end

data/tests/helpers/collection_helper.rb

@@ -0,0 +1,97 @@
+def collection_tests(collection, params = {}, mocks_implemented = true)
+  tests('success') do
+
+    tests("#new(#{params.inspect})").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.new(params)
+    end
+
+    tests("#create(#{params.inspect})").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      @instance = collection.create(params)
+    end
+    # FIXME: work around for timing issue on AWS describe_instances mocks
+
+    if Fog.mocking? && @instance.respond_to?(:ready?)
+      @instance.wait_for { ready? }
+    end
+
+    tests("#all").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.all
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @identity = @instance.identity
+    end
+
+    tests("#get(#{@identity})").succeeds do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.get(@identity)
+    end
+
+    tests('Enumerable') do
+      pending if Fog.mocking? && !mocks_implemented
+
+      methods = [
+        'all?', 'any?', 'find',  'detect', 'collect', 'map',
+        'find_index', 'flat_map', 'collect_concat', 'group_by',
+        'none?', 'one?'
+      ]
+
+      # JRuby 1.7.5+ issue causes a SystemStackError: stack level too deep
+      # https://github.com/jruby/jruby/issues/1265
+      if RUBY_PLATFORM == "java" and JRUBY_VERSION =~ /1\.7\.[5-8]/
+        methods.delete('all?')
+      end
+
+      methods.each do |enum_method|
+        if collection.respond_to?(enum_method)
+          tests("##{enum_method}").succeeds do
+            block_called = false
+            collection.send(enum_method) {|x| block_called = true }
+            block_called
+          end
+        end
+      end
+
+      [
+        'max_by','min_by'
+      ].each do |enum_method|
+        if collection.respond_to?(enum_method)
+          tests("##{enum_method}").succeeds do
+            block_called = false
+            collection.send(enum_method) {|x| block_called = true; 0 }
+            block_called
+          end
+        end
+
+      end
+
+    end
+
+    if block_given?
+      yield(@instance)
+    end
+
+    if !Fog.mocking? || mocks_implemented
+      @instance.destroy
+    end
+  end
+
+  tests('failure') do
+
+    if !Fog.mocking? || mocks_implemented
+      @identity = @identity.to_s
+      @identity = @identity.gsub(/[a-zA-Z]/) { Fog::Mock.random_letters(1) }
+      @identity = @identity.gsub(/\d/)       { Fog::Mock.random_numbers(1) }
+      @identity
+    end
+
+    tests("#get('#{@identity}')").returns(nil) do
+      pending if Fog.mocking? && !mocks_implemented
+      collection.get(@identity)
+    end
+
+  end
+end