fog 1.5.0 → 1.6.0

data/lib/fog/rackspace/requests/compute_v2/list_flavors.rb

@@ -0,0 +1,15 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        def list_flavors
+          request(
+            :expects => [200, 203],
+            :method => 'GET',
+            :path => 'flavors'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/compute_v2/list_images.rb

@@ -0,0 +1,15 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        def list_images
+          request(
+            :expects => [200, 203],
+            :method => 'GET',
+            :path => 'images'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/compute_v2/list_servers.rb

@@ -0,0 +1,15 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        def list_servers
+          request(
+            :expects => [200, 203, 300],
+            :method => 'GET',
+            :path => 'servers'
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/compute_v2/reboot_server.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        def reboot_server(server_id, type)
+          data = {
+            'reboot' => {
+              'type' => type
+            }
+          }
+
+          request(
+            :body => Fog::JSON.encode(data),
+            :expects => [202],
+            :method => 'POST',
+            :path => "servers/#{server_id}/action"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/compute_v2/rebuild_server.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        def rebuild_server(server_id, image_id)
+          data = {
+            'rebuild' => {
+              'imageRef' => image_id
+            }
+          }
+
+          request(
+            :body => Fog::JSON.encode(data),
+            :expects => [202],
+            :method => 'POST',
+            :path => "servers/#{server_id}/action"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/compute_v2/resize_server.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        def resize_server(server_id, flavor_id)
+          data = {
+            'resize' => {
+              'flavorRef' => flavor_id
+            }
+          }
+
+          request(
+            :body => Fog::JSON.encode(data),
+            :expects => [202],
+            :method => 'POST',
+            :path => "servers/#{server_id}/action"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/compute_v2/revert_resize_server.rb

@@ -0,0 +1,20 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        def revert_resize_server(server_id)
+          data = {
+            'revertResize' => nil
+          }
+
+          request(
+            :body => Fog::JSON.encode(data),
+            :expects => [202],
+            :method => 'POST',
+            :path => "servers/#{server_id}/action"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/compute_v2/update_server.rb

@@ -0,0 +1,22 @@
+module Fog
+  module Compute
+    class RackspaceV2
+      class Real
+        def update_server(server_id, name)
+          data = {
+            'server' => {
+              'name' => name
+            }
+          }
+
+          request(
+            :body => Fog::JSON.encode(data),
+            :expects => [200],
+            :method => 'PUT',
+            :path => "servers/#{server_id}"
+          )
+        end
+      end
+    end
+  end
+end

data/lib/fog/rackspace/requests/storage/delete_object.rb

@@ -3,7 +3,7 @@ module Fog
     class Rackspace
       class Real
 
-        # Delete an existing container
+        # Delete an existing object
         #
         # ==== Parameters
         # * container<~String> - Name of container to delete

data/lib/fog/rackspace/requests/storage/get_object_https_url.rb

@@ -0,0 +1,51 @@
+module Fog
+  module Storage
+    class Rackspace
+
+      class Real
+
+        # Get an expiring object https url from Cloud Files
+        #
+        # ==== Parameters
+        # * container<~String> - Name of container containing object
+        # * object<~String> - Name of object to get expiring url for
+        # * expires<~Time> - An expiry time for this url
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * body<~String> - url for object
+        #
+        # ==== See Also
+        # http://docs.rackspace.com/files/api/v1/cf-devguide/content/Create_TempURL-d1a444.html
+        def get_object_https_url(container, object, expires, options = {})
+          if @rackspace_temp_url_key.nil?
+            raise ArgumentError, "Storage must my instantiated with the :rackspace_temp_url_key option"
+          end
+
+          method         = 'GET'
+          expires        = expires.to_i
+          object_path_escaped   = "#{@path}/#{Fog::Rackspace.escape(container)}/#{Fog::Rackspace.escape(object,"/")}"
+          object_path_unescaped = "#{@path}/#{Fog::Rackspace.escape(container)}/#{object}"
+          string_to_sign = "#{method}\n#{expires}\n#{object_path_unescaped}"
+
+          hmac = Fog::HMAC.new('sha1', @rackspace_temp_url_key)
+          sig  = sig_to_hex(hmac.sign(string_to_sign))
+
+          "https://#{@host}#{object_path_escaped}?temp_url_sig=#{sig}&temp_url_expires=#{expires}"
+        end
+
+        private
+
+        def sig_to_hex(str)
+          str.unpack("C*").map { |c|
+            c.to_s(16)
+          }.map { |h|
+            h.size == 1 ? "0#{h}" : h
+          }.join
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/rackspace/requests/storage/post_set_meta_temp_url_key.rb

@@ -0,0 +1,37 @@
+module Fog
+  module Storage
+    class Rackspace
+
+      class Real
+
+        # Set the account wide Temp URL Key. This is a secret key that's
+        # used to generate signed expiring URLs.
+        #
+        # Once the key has been set with this request you should create new
+        # Storage objects with the :rackspace_temp_url_key option then use
+        # the get_object_https_url method to generate expirign URLs.
+        #
+        # *** CAUTION *** changing this secret key will invalidate any expiring
+        # URLS generated with old keys.
+        #
+        # ==== Parameters
+        # * key<~String> - The new Temp URL Key
+        #
+        # ==== Returns
+        # * response<~Excon::Response>
+        #
+        # ==== See Also
+        # http://docs.rackspace.com/files/api/v1/cf-devguide/content/Set_Account_Metadata-d1a4460.html
+        def post_set_meta_temp_url_key(key)
+          request(
+            :expects  => [201, 202, 204],
+            :method   => 'POST',
+            :headers  => {'X-Account-Meta-Temp-Url-Key' => key}
+          )
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/rackspace/storage.rb

@@ -7,6 +7,7 @@ module Fog
 
       requires :rackspace_api_key, :rackspace_username
       recognizes :rackspace_auth_url, :rackspace_servicenet, :rackspace_cdn_ssl, :persistent
+      recognizes :rackspace_temp_url_key
 
       model_path 'fog/rackspace/models/storage'
       model       :directory
@@ -21,12 +22,14 @@ module Fog
       request :get_container
       request :get_containers
       request :get_object
+      request :get_object_https_url
       request :head_container
       request :head_containers
       request :head_object
       request :put_container
       request :put_object
       request :put_object_manifest
+      request :post_set_meta_temp_url_key
 
       module Utils
 
@@ -86,6 +89,7 @@ module Fog
           @rackspace_servicenet = options[:rackspace_servicenet]
           @rackspace_auth_token = options[:rackspace_auth_token]
           @rackspace_storage_url = options[:rackspace_storage_url]
+          @rackspace_temp_url_key = options[:rackspace_temp_url_key]
           @rackspace_must_reauthenticate = false
           @connection_options     = options[:connection_options] || {}
           authenticate

data/lib/fog/serverlove.rb

@@ -0,0 +1,10 @@
+require(File.expand_path(File.join(File.dirname(__FILE__), 'core')))
+
+module Fog
+  module Serverlove
+    extend Fog::Provider
+
+    service(:compute, 'serverlove/compute', 'Compute')
+
+  end
+end

data/lib/fog/serverlove/compute.rb

@@ -0,0 +1,97 @@
+module Fog
+  module Compute
+    class Serverlove < Fog::Service
+      
+      API_HOST = "api.z1-man.serverlove.com"
+      
+      requires :serverlove_uuid, :serverlove_api_key
+      
+      recognizes :serverlove_api_url
+      
+      request_path 'fog/serverlove/requests/compute'
+      
+      # Image
+      request :get_image
+      request :get_images
+      request :destroy_image
+      request :create_image
+      request :update_image
+      request :load_standard_image
+
+      # Server
+      request :get_servers
+      request :get_server
+      request :destroy_server
+      request :create_server
+      request :update_server
+      request :start_server
+      request :stop_server
+      request :shutdown_server
+      request :reset_server
+      
+      model_path 'fog/serverlove/models/compute'
+      
+      model       :image
+      collection  :images
+      
+      model       :server
+      collection  :servers
+
+      class Mock
+        
+        def initialize(options)
+          @serverlove_uuid = options[:serverlove_uuid] || Fog.credentials[:serverlove_uuid]
+          @serverlove_api_key = options[:serverlove_api_key] || Fog.credentials[:serverlove_api_key]
+        end
+        
+        def request(options)
+          raise "Not implemented"
+        end
+        
+      end
+      
+      class Real
+        
+        def initialize(options)
+          @api_uuid = options[:serverlove_uuid] || Fog.credentials[:serverlove_uuid]
+          @api_key = options[:serverlove_api_key] || Fog.credentials[:serverlove_api_key]
+          @api_host = options[:serverlove_api_url] || Fog.credentials[:serverlove_api_url] || API_HOST
+          
+          @connection = Fog::Connection.new("https://#{@api_uuid}:#{@api_key}@#{@api_host}")
+        end
+        
+        def request(params)
+          params = params.merge!(
+            :headers => {
+              "Accept" => "application/json"
+            }
+          )
+          params[:body] = encode_pairs(params[:options]) unless params[:options].nil?
+          response = @connection.request(params)
+          
+          raise_if_error!(response)
+          
+          response.body = Fog::JSON.decode(response.body) if response.body && response.body.length > 0
+          
+          response
+        end
+        
+        def encode_pairs(params)
+          params.keys.collect do |key|
+            "#{key} #{params[key]}"
+          end.join("\n")
+        end
+
+        # TODO
+        def raise_if_error!(response)
+          case response.status
+          when 400 then 
+            raise 'omg'
+          end
+        end
+        
+      end
+            
+    end
+  end
+end

data/lib/fog/serverlove/models/compute/image.rb

@@ -0,0 +1,57 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Serverlove
+
+      class Image < Fog::Model
+
+        identity :id, :aliases => 'drive'
+
+        attribute :name   
+        attribute :user
+        attribute :size
+        attribute :claimed
+        attribute :status
+        attribute :imaging
+        attribute :encryption_cipher, :aliases => 'encryption:cipher'
+        
+        def save
+          attributes = {}
+          
+          if(identity)
+            attributes = connection.update_image(identity, allowed_attributes).body
+          else
+            requires :name
+            requires :size
+            attributes = connection.create_image(allowed_attributes).body
+          end
+          
+          merge_attributes(attributes)
+          self
+        end
+        
+        def load_standard_image(standard_image_uuid)
+          requires :identity
+          connection.load_standard_image(identity, standard_image_uuid)
+        end
+        
+        def ready?
+          status.upcase == 'ACTIVE'
+        end
+
+        def destroy
+          requires :identity
+          connection.destroy_image(identity)
+          self
+        end
+        
+        def allowed_attributes
+          allowed = [:name, :size]
+          attributes.select {|k,v| allowed.include? k}
+        end
+
+      end
+    end
+  end
+end