tecnh-fog 0.2.23.vpc

data/lib/fog/rackspace/files.rb

@@ -0,0 +1,134 @@
+module Fog
+  module Rackspace
+    module Files
+      extend Fog::Service
+
+      requires :rackspace_api_key, :rackspace_username
+
+      model_path 'fog/rackspace/models/files'
+      model 'directory'
+      model 'directories'
+      model 'file'
+      model 'files'
+
+      request_path 'fog/rackspace/requests/files'
+      request 'delete_container'
+      request 'delete_object'
+      request 'get_container'
+      request 'get_containers'
+      request 'get_object'
+      request 'head_container'
+      request 'head_containers'
+      request 'head_object'
+      request 'put_container'
+      request 'put_object'
+
+      module Utils
+
+        def parse_data(data)
+          metadata = {
+            :body => nil,
+            :headers => {}
+          }
+
+          if data.is_a?(String)
+            metadata[:body] = data
+            metadata[:headers]['Content-Length'] = metadata[:body].size.to_s
+          else
+            filename = ::File.basename(data.path)
+            unless (mime_types = MIME::Types.of(filename)).empty?
+              metadata[:headers]['Content-Type'] = mime_types.first.content_type
+            end
+            metadata[:body] = data.read
+            metadata[:headers]['Content-Length'] = ::File.size(data.path).to_s
+          end
+          # metadata[:headers]['Content-MD5'] = Base64.encode64(Digest::MD5.digest(metadata[:body])).strip
+          metadata
+        end
+
+      end
+
+      class Mock
+        include Collections
+        include Utils
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          end
+        end
+
+        def self.reset_data(keys=data.keys)
+          for key in [*keys]
+            data.delete(key)
+          end
+        end
+
+        def initialize(options={})
+          @rackspace_username = options[:rackspace_username]
+          @data = self.class.data[@rackspace_username]
+        end
+
+      end
+
+      class Real
+        include Collections
+        include Utils
+
+        def initialize(options={})
+          credentials = Fog::Rackspace.authenticate(options)
+          @auth_token = credentials['X-Auth-Token']
+
+          cdn_uri = URI.parse(credentials['X-CDN-Management-Url'])
+          @cdn_host   = cdn_uri.host
+          @cdn_path   = cdn_uri.path
+          @cdn_port   = cdn_uri.port
+          @cdn_scheme = cdn_uri.scheme
+          @cdn_connection = Fog::Connection.new("#{@cdn_scheme}://#{@cdn_host}:#{@cdn_port}", options[:persistent])
+
+          storage_uri = URI.parse(credentials['X-Storage-Url'])
+          @storage_host   = storage_uri.host
+          @storage_path   = storage_uri.path
+          @storage_port   = storage_uri.port
+          @storage_scheme = storage_uri.scheme
+          @storage_connection = Fog::Connection.new("#{@storage_scheme}://#{@storage_host}:#{@storage_port}", options[:persistent])
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def cdn_request(params)
+          response = @cdn_connection.request(params.merge!({
+            :headers  => {
+              'Content-Type' => 'application/json',
+              'X-Auth-Token' => @auth_token
+            }.merge!(params[:headers] || {}),
+            :host     => @cdn_host,
+            :path     => "#{@cdn_path}/#{params[:path]}",
+          }))
+          if !response.body.empty? && parse_json && response.headers['Content-Type'] =~ %r{application/json}
+            response.body = JSON.parse(response.body)
+          end
+          response
+        end
+
+        def storage_request(params, parse_json = true, &block)
+          response = @storage_connection.request(params.merge!({
+            :headers  => {
+              'Content-Type' => 'application/json',
+              'X-Auth-Token' => @auth_token
+            }.merge!(params[:headers] || {}),
+            :host     => @storage_host,
+            :path     => "#{@storage_path}/#{params[:path]}",
+          }), &block)
+          if !response.body.empty? && parse_json && response.headers['Content-Type'] =~ %r{application/json}
+            response.body = JSON.parse(response.body)
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

data/lib/fog/rackspace/models/files/directories.rb

@@ -0,0 +1,40 @@
+require 'fog/collection'
+require 'fog/rackspace/models/files/directory'
+
+module Fog
+  module Rackspace
+    module Files
+
+      module Collections
+        def directories
+          Fog::Rackspace::Files::Directories.new(:connection => self)
+        end
+      end
+
+      class Directories < Fog::Collection
+
+        model Fog::Rackspace::Files::Directory
+
+        def all
+          data = connection.get_containers.body
+          load(data)
+        end
+
+        def get(key, options = {})
+          data = connection.get_container(key, options).body
+          directory = new(:key => key)
+          directory.files.merge_attributes(options)
+          directory.files.instance_variable_set(:@loaded, true)
+          data.each do |file|
+            directory.files << directory.files.new(file)
+          end
+          directory
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/rackspace/models/files/directory.rb

@@ -0,0 +1,45 @@
+require 'fog/model'
+require 'fog/rackspace/models/files/files'
+
+module Fog
+  module Rackspace
+    module Files
+
+      class Directory < Fog::Model
+        extend Fog::Deprecation
+        deprecate(:name, :key)
+        deprecate(:name=, :key=)
+
+        identity  :key, ['name']
+
+        attribute :bytes
+        attribute :count
+
+        def destroy
+          requires :key
+          connection.delete_container(key)
+          true
+        rescue Excon::Errors::NotFound
+          false
+        end
+
+        def files
+          @files ||= begin
+            Fog::Rackspace::Files::Files.new(
+              :directory    => self,
+              :connection   => connection
+            )
+          end
+        end
+
+        def save
+          requires :key
+          connection.put_container(key)
+          true
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/rackspace/models/files/file.rb

@@ -0,0 +1,61 @@
+require 'fog/model'
+
+module Fog
+  module Rackspace
+    module Files
+
+      class File < Fog::Model
+
+        identity  :key,             'Key'
+
+        attr_accessor :body
+        attribute :content_length,  'Content-Length'
+        attribute :content_type,    'Content-Type'
+        attribute :etag,            'Etag'
+        attribute :last_modified,   'Last-Modified'
+
+        def body
+          @body ||= if last_modified
+            collection.get(identity).body
+          else
+            ''
+          end
+        end
+
+        def directory
+          @directory
+        end
+
+        def destroy
+          requires :directory, :key
+          connection.delete_object(directory.name, @key)
+          true
+        end
+
+        def owner=(new_owner)
+          if new_owner
+            @owner = {
+              :display_name => new_owner['DisplayName'],
+              :id           => new_owner['ID']
+            }
+          end
+        end
+
+        def save
+          requires :body, :directory, :key
+          data = connection.put_object(directory.name, @key, @body)
+          @etag = data.headers['ETag']
+          true
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/rackspace/models/files/files.rb

@@ -0,0 +1,87 @@
+require 'fog/collection'
+require 'fog/rackspace/models/files/file'
+
+module Fog
+  module Rackspace
+    module Files
+
+      class Files < Fog::Collection
+
+        attribute :limit
+        attribute :marker
+        attribute :path
+        attribute :prefix
+
+        model Fog::Rackspace::Files::File
+
+        def all(options = {})
+          merge_attributes(options)
+          parent = directory.collection.get(
+            directory.key,
+            options
+          )
+          if parent
+            load(parent.files.map {|file| file.attributes})
+          else
+            nil
+          end
+        end
+
+        def directory
+          @directory
+        end
+
+        def get(key, options = {}, &block)
+          options = {
+            'limit'   => @limit,
+            'marker'  => @marker,
+            'path'    => @path,
+            'prefix'  => @prefix
+          }.merge!(options)
+          data = connection.get_object(directory.name, key, options, &block)
+          file_data = {
+            :body => data.body,
+            :key  => key
+          }
+          for key, value in data.headers
+            if ['Content-Length', 'Content-Type', 'ETag', 'Last-Modified'].include?(key)
+              file_data[key] = value
+            end
+          end
+          new(file_data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        def get_url(key, expires)
+          connection.get_object_url(directory.name, key, expires)
+        end
+
+        def head(key, options = {})
+          data = connection.head_object(directory.name, key, options)
+          file_data = { :key => key }
+          for key, value in data.headers
+            if ['Content-Length', 'Content-Type', 'ETag', 'Last-Modified'].include?(key)
+              file_data[key] = value
+            end
+          end
+          new(file_data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        def new(attributes = {})
+          super({ :directory => directory }.merge!(attributes))
+        end
+
+        private
+
+        def directory=(new_directory)
+          @directory = new_directory
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/rackspace/models/servers/flavor.rb

@@ -0,0 +1,45 @@
+require 'fog/model'
+
+module Fog
+  module Rackspace
+    module Servers
+
+      class Flavor < Fog::Model
+
+        identity :id
+
+        attribute :bits
+        attribute :cores
+        attribute :disk
+        attribute :name
+        attribute :ram
+
+        def bits
+          64
+        end
+
+        def cores
+          # 2 quad-cores >= 2Ghz = 8 cores
+          8 * case ram
+          when 256
+            1/64.0
+          when 512
+            1/32.0
+          when 1024
+            1/16.0
+          when 2048
+            1/8.0
+          when 4096
+            1/4.0
+          when 8192
+            1/2.0
+          when 15872
+            1
+          end
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/rackspace/models/servers/flavors.rb

@@ -0,0 +1,34 @@
+require 'fog/collection'
+require 'fog/rackspace/models/servers/flavor'
+
+module Fog
+  module Rackspace
+    module Servers
+
+      module Collections
+        def flavors
+          Fog::Rackspace::Servers::Flavors.new(:connection => self)
+        end
+      end
+
+      class Flavors < Fog::Collection
+
+        model Fog::Rackspace::Servers::Flavor
+
+        def all
+          data = connection.list_flavors_detail.body['flavors']
+          load(data)
+        end
+
+        def get(flavor_id)
+          data = connection.get_flavor_details(flavor_id).body['flavor']
+          new(data)
+        rescue Fog::Rackspace::Servers::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end