fog 0.3.17 → 0.3.18

data/lib/fog/aws/requests/storage/upload_part.rb

@@ -0,0 +1,51 @@
+module Fog
+  module AWS
+    class Storage
+      class Real
+
+        # Upload a part for a multipart upload
+        #
+        # ==== Parameters
+        # * bucket_name<~String> - Name of bucket to add part to
+        # * object_name<~String> - Name of object to add part to
+        # * upload_id<~String> - Id of upload to add part to
+        # * part_number<~String> - Index of part in upload
+        # * data<~File||String> - Content for part
+        # * options<~Hash>:
+        #   * 'Content-MD5'<~String> - Base64 encoded 128-bit MD5 digest of message
+        #
+        # ==== Returns
+        # * response<~Excon::Response>:
+        #   * headers<~Hash>:
+        #     * 'ETag'<~String> - etag of new object (will be needed to complete upload)
+        #
+        # ==== See Also
+        # http://docs.amazonwebservices.com/AmazonS3/latest/API/mpUploadUploadPart.html
+        #
+        def upload_part(bucket_name, object_name, upload_id, part_number, data, options = {})
+          data = parse_data(data)
+          headers = options
+          headers['Content-Length'] = data[:headers]['Content-Length']
+          request({
+            :body       => data[:body],
+            :expects    => 200,
+            :headers    => headers,
+            :host       => "#{bucket_name}.#{@host}",
+            :method     => 'PUT',
+            :path       => CGI.escape(object_name),
+            :query      => {'uploadId' => upload_id, 'partNumber' => part_number}
+          })
+        end
+
+      end # Real
+
+      class Mock # :nodoc:all
+
+        def upload_part(bucket_name, object_name, upload_id, part_number, data, options = {})
+          Fog::Mock.not_implemented
+        end
+
+      end # Mock
+    end # Storage
+  end # AWS
+end # Fog

data/lib/fog/aws/storage.rb

@@ -11,6 +11,8 @@ module Fog
       model       :file
 
       request_path 'fog/aws/requests/storage'
+      request :abort_multipart_upload
+      request :complete_multipart_upload
       request :copy_object
       request :delete_bucket
       request :delete_object
@@ -27,6 +29,9 @@ module Fog
       request :get_request_payment
       request :get_service
       request :head_object
+      request :initiate_multipart_upload
+      request :list_multipart_uploads
+      request :list_parts
       request :post_object_hidden_fields
       request :put_bucket
       request :put_bucket_acl
@@ -35,6 +40,7 @@ module Fog
       request :put_object
       request :put_object_url
       request :put_request_payment
+      request :upload_part
 
       module Utils
 
@@ -219,7 +225,7 @@ DATA
           for key, value in amz_headers
             canonical_amz_headers << "#{key}:#{value}\n"
           end
-          string_to_sign << "#{canonical_amz_headers}"
+          string_to_sign << canonical_amz_headers
 
           subdomain = params[:host].split(".#{@host}").first
           unless subdomain =~ /^(?:[a-z]|\d(?!\d{0,2}(?:\.\d{1,3}){3}$))(?:[a-z0-9]|\.(?![\.\-])|\-(?![\.])){1,61}[a-z0-9]$/
@@ -228,7 +234,7 @@ DATA
             if params[:path]
               params[:path] = "#{subdomain}/#{params[:path]}"
             else
-              params[:path] = "#{subdomain}"
+              params[:path] = subdomain
             end
             subdomain = nil
           end
@@ -237,15 +243,15 @@ DATA
           unless subdomain.nil? || subdomain == @host
             canonical_resource << "#{CGI.escape(subdomain).downcase}/"
           end
-          canonical_resource << "#{params[:path]}"
+          canonical_resource << params[:path].to_s
           canonical_resource << '?'
           for key in (params[:query] || {}).keys
-            if ['acl', 'location', 'logging', 'requestPayment', 'torrent', 'versions', 'versioning'].include?(key)
-              canonical_resource << "#{key}&"
+            if %w{acl location logging notification partNumber policy requestPayment torrent uploadId uploads versionId versioning versions}.include?(key)
+              canonical_resource << "#{key}#{"=#{params[:query][key]}" unless params[:query][key].nil?}&"
             end
           end
           canonical_resource.chop!
-          string_to_sign << "#{canonical_resource}"
+          string_to_sign << canonical_resource
 
           signed_string = @hmac.sign(string_to_sign)
           signature = Base64.encode64(signed_string).chomp!

data/lib/fog/brightbox.rb

@@ -0,0 +1,7 @@
+module Fog
+  module Brightbox
+    extend Fog::Provider
+    service_path 'fog/brightbox'
+    service 'compute'
+  end
+end

data/lib/fog/brightbox/bin.rb

@@ -0,0 +1,23 @@
+class Brightbox < Fog::Bin
+  class << self
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :compute
+          Fog::Brightbox::Compute.new
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      [:compute]
+    end
+
+    def account
+      @@connections[:compute].account
+    end
+
+  end
+end

data/lib/fog/brightbox/compute.rb

@@ -0,0 +1,134 @@
+module Fog
+  module Brightbox
+    class Compute < Fog::Service
+
+      API_URL = "https://api.gb1.brightbox.com/"
+
+      requires :brightbox_client_id, :brightbox_secret
+
+      model_path 'fog/brightbox/models/compute'
+      model :account # Singular resource, no collection
+      collection :servers
+      model :server
+      collection :flavors
+      model :flavor
+      collection :images
+      model :image
+      collection :zones
+      model :zone
+      collection :cloud_ips
+      model :cloud_ip
+      collection :users
+      model :user
+
+      request_path 'fog/brightbox/requests/compute'
+      request :create_api_client
+      request :create_cloud_ip
+      request :create_image
+      request :create_server
+      request :destroy_api_client
+      request :destroy_cloud_ip
+      request :destroy_image
+      request :destroy_server
+      request :get_account
+      request :get_api_client
+      request :get_cloud_ip
+      request :get_image
+      request :get_interface
+      request :get_server
+      request :get_server_type
+      request :get_user
+      request :get_zone
+      request :list_api_clients
+      request :list_cloud_ips
+      request :list_images
+      request :list_server_types
+      request :list_servers
+      request :list_users
+      request :list_zones
+      request :map_cloud_ip
+      request :reset_ftp_password_account
+      request :resize_server
+      request :shutdown_server
+      request :snapshot_server
+      request :start_server
+      request :stop_server
+      request :unmap_cloud_ip
+      request :update_account
+      request :update_api_client
+      request :update_image
+      request :update_server
+      request :update_user
+
+      class Mock
+
+        def initialize(options)
+          @brightbox_client_id = options[:brightbox_client_id] || Fog.credentials[:brightbox_client_id]
+          @brightbox_secret = options[:brightbox_secret] || Fog.credentials[:brightbox_secret]
+        end
+
+        def request(options)
+          raise "Not implemented"
+        end
+      end
+
+      class Real
+
+        def initialize(options)
+          require "json"
+          # Currently authentication and api endpoints are the same but may change
+          @auth_url = options[:brightbox_auth_url] || Fog.credentials[:brightbox_auth_url] || API_URL
+          @api_url = options[:brightbox_api_url] || Fog.credentials[:brightbox_api_url] || API_URL
+          @brightbox_client_id = options[:brightbox_client_id] || Fog.credentials[:brightbox_client_id]
+          @brightbox_secret = options[:brightbox_secret] || Fog.credentials[:brightbox_secret]
+          @connection = Fog::Connection.new(@api_url)
+        end
+
+        def request(params)
+          begin
+            get_oauth_token if @oauth_token.nil?
+            response = authenticated_request(params)
+          rescue Excon::Errors::Unauthorized => e
+            get_oauth_token
+            response = authenticated_request(params)
+          end
+          unless response.body.empty?
+            response = JSON.parse(response.body)
+          end
+        end
+
+        def account
+          Fog::Brightbox::Compute::Account.new(get_account)
+        end
+
+      private
+        def get_oauth_token(options = {})
+          auth_url = options[:brightbox_auth_url] || @auth_url
+
+          connection = Fog::Connection.new(auth_url)
+          @authentication_body = {'client_id' => @brightbox_client_id, 'grant_type' => 'none'}.to_json
+
+          response = connection.request({
+            :path => "/token",
+            :expects  => 200,
+            :headers  => {
+              'Authorization' => "Basic " + Base64.encode64("#{@brightbox_client_id}:#{@brightbox_secret}").chomp,
+              'Content-Type' => 'application/json'
+            },
+            :method   => 'POST',
+            :body     => @authentication_body
+          })
+          @oauth_token = JSON.parse(response.body)["access_token"]
+          return @oauth_token
+        end
+
+        def authenticated_request(options)
+          headers = options[:headers] || {}
+          headers.merge!("Authorization" => "OAuth #{@oauth_token}")
+          options[:headers] = headers
+          @connection.request(options)
+        end
+      end
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/account.rb

@@ -0,0 +1,51 @@
+require 'fog/core/model'
+
+module Fog
+  module Brightbox
+    class Compute
+
+      class Account < Fog::Model
+
+        identity :id
+        attribute :resource_type
+        attribute :url
+        attribute :name
+        attribute :status
+        attribute :address_1
+        attribute :address_2
+        attribute :city
+        attribute :county
+        attribute :postcode
+        attribute :country_code
+        attribute :country_name
+        attribute :vat_registration_number
+        attribute :telephone_number
+        attribute :telephone_verified
+        attribute :ram_limit
+        attribute :ram_used
+        attribute :limits_cloudips
+        attribute :library_ftp_host
+        attribute :library_ftp_user
+        # This is always returned as null/nil unless performing a reset_ftp_password request
+        attribute :library_ftp_password
+        attribute :created_at, :type => :time
+
+
+
+        attribute :owner_id, :aliases => "owner", :squash => "id"
+        attribute :clients
+        attribute :images
+        attribute :servers
+        attribute :users
+        attribute :zones
+
+        def reset_ftp_password
+          requires :identity
+          connection.reset_ftp_password_account(identity)["library_ftp_password"]
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/cloud_ip.rb

@@ -0,0 +1,43 @@
+require 'fog/core/model'
+
+module Fog
+  module Brightbox
+    class Compute
+
+      class CloudIp < Fog::Model
+
+        identity :id
+
+        attribute :url
+        attribute :name
+        attribute :status
+        attribute :resource_type
+        attribute :description
+
+        attribute :reverse_dns
+        attribute :public_ip
+
+        attribute :account_id, :aliases => "account", :squash => "id"
+        attribute :interface_id, :aliases => "interface", :squash => "id"
+        attribute :server_id, :aliases => "server", :squash => "id"
+
+        def map(interface_to_map)
+          requires :identity
+          connection.map_cloud_ip(identity, :interface => interface_to_map)
+        end
+
+        def unmap
+          requires :identity
+          connection.unmap_cloud_ip(identity)
+        end
+
+        def destroy
+          requires :identity
+          connection.destroy_cloud_ip(identity)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/cloud_ips.rb

@@ -0,0 +1,34 @@
+require 'fog/core/collection'
+require 'fog/brightbox/models/compute/cloud_ip'
+
+module Fog
+  module Brightbox
+    class Compute
+
+      class CloudIps < Fog::Collection
+
+        model Fog::Brightbox::Compute::CloudIp
+
+        def all
+          data = connection.list_cloud_ips
+          load(data)
+        end
+
+        def get(identifier)
+          return nil if identifier.nil? || identifier == ""
+          data = connection.get_cloud_ip(identifier)
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+        def allocate
+          data = connection.create_cloud_ip
+          new(data)
+        end
+
+      end
+
+    end
+  end
+end

data/lib/fog/brightbox/models/compute/flavor.rb

@@ -0,0 +1,33 @@
+require 'fog/core/model'
+
+module Fog
+  module Brightbox
+    class Compute
+
+      class Flavor < Fog::Model
+
+        identity :id
+
+        attribute :url
+        attribute :name
+        attribute :status
+
+        attribute :handle
+
+        attribute :bits
+        attribute :cores
+        attribute :disk, :aliases => "disk_size"
+        attribute :ram
+
+        attribute :resource_type
+        attribute :description
+
+        def bits
+          0 # This is actually based on the Image type used. 32bit or 64bit Images are supported
+        end
+
+      end
+
+    end
+  end
+end