fog 1.10.1 → 1.11.0

data/lib/fog/cloudstack/requests/compute/delete_snapshot.rb

@@ -3,9 +3,9 @@ module Fog
     class Cloudstack
       class Real
 
-        # Deletes a specified user.
+        # Deletes a specified snapshot.
         #
-        # {CloudStack API Reference}[http://download.cloud.com/releases/2.2.0/api_2.2.4/global_admin/deleteSnapshot.html]
+        # {CloudStack API Reference}[http://cloudstack.apache.org/docs/api/apidocs-4.0.0/user/deleteSnapshot.html]
         def delete_snapshot(options={})
           options.merge!(
             'command' => 'deleteSnapshot'
@@ -15,6 +15,48 @@ module Fog
         end
 
       end
+
+       class Mock
+
+        # Deletes a specified snapashot.
+        #
+        # {CloudStack API Reference}[http://cloudstack.apache.org/docs/api/apidocs-4.0.0/user/deleteSnapshot.html]
+        def delete_snapshot(options={})
+          snapshot_id = options['id']
+          snapshots = self.data[:snapshots]
+
+          if snapshots[snapshot_id]
+
+            snapshots.delete(snapshot_id)
+            job_id = add_delete_snapshot_job(snapshot_id)
+
+            {'deletesnapshotresponse' => {'jobid' => job_id}}
+          end
+          # TODO add cases for empty or wrong id
+        end
+
+        def add_delete_snapshot_job(snapshot_id)
+          job_id = Fog::Cloudstack.uuid
+
+          job = {
+            'id' => job_id,
+            'user_id' => self.data[:users].first, # TODO use current user
+            'account_id' => self.data[:accounts].first, # TODO use current user
+            'cmd' => 'com.cloud.api.commands.DeleteSnapshotCmd',
+            'job_status'=> 1,
+            'job_result_type' => nil,
+            'job_result_code' => 0,
+            'job_proc_status' => 0,
+            'created_at' => Time.now.iso8601,
+            'job_result' => { "success" => true }
+          }
+
+          self.data[:jobs][job_id] = job
+          job_id
+        end
+
+      end
+           
     end
   end
 end

data/lib/fog/cloudstack/requests/compute/list_disk_offerings.rb

@@ -15,6 +15,15 @@ module Fog
         end
 
       end
+
+      class Mock
+        # TODO: add id, name filters and paging params
+        def list_disk_offerings(options={})
+          disk_offerings = self.data[:disk_offerings]
+          { "listdiskofferingsresponse" => { "count"=> disk_offerings.count, "diskoffering"=> disk_offerings.values } }
+        end
+
+      end
     end
   end
 end

data/lib/fog/cloudstack/requests/compute/list_os_types.rb

@@ -15,6 +15,15 @@ module Fog
         end
 
       end
+
+      class Mock
+        # TODO: add id, category_id filters and paging params
+        def list_os_types(options={})
+          os_types = self.data[:os_types]
+          { "listostypesresponse" => { "count"=> os_types.count, "ostype"=> os_types.values } }
+        end
+
+      end
     end
   end
 end

data/lib/fog/cloudstack/requests/compute/list_snapshots.rb

@@ -15,6 +15,27 @@ module Fog
         end
 
       end
+
+      class Mock
+
+        def list_snapshots(options={})
+          snapshot_id = options.delete('id')
+          if snapshot_id
+            snapshots = [self.data[:snapshots][snapshot_id]]
+          else
+            snapshots = self.data[:snapshots].values
+          end
+
+          {
+            'listsnapshotsresponse' => {
+              'count' => snapshots.size,
+              'snapshot' => snapshots
+            }
+          }
+        end
+
+      end
+
     end
   end
 end

data/lib/fog/core/errors.rb

@@ -46,6 +46,9 @@ An alternate file may be used by placing its path in the FOG_RC environment vari
   :clodo_username:
   :go_grid_api_key:
   :go_grid_shared_secret:
+  :google_client_email:
+  :google_key_location:
+  :google_project:
   :google_storage_access_key_id:
   :google_storage_secret_access_key:
   :hp_access_key:

data/lib/fog/core/json.rb

@@ -1,7 +1,51 @@
-require 'multi_json'
+require 'singleton'
+require 'fog/core/logger'
 
 module Fog
-  module JSON
+  class JSON
+    include Singleton
+
+    class LoadError < StandardError
+      attr_reader :data
+      def initialize(message='', backtrace=[], data='')
+        super(message)
+        self.set_backtrace(backtrace)
+        @data = data
+      end
+    end
+
+    module LegacyJSON
+      def encode(obj)
+        ::JSON.generate(obj)
+      end
+
+      def decode(obj)
+        ::JSON.parse(obj)
+      rescue ::JSON::ParserError => e
+        raise LoadError.new(e.message, e.backtrace, obj)
+      end
+    end
+
+    module NewJSON
+      def encode(obj)
+        ::MultiJson.encode(obj)
+      end
+
+      def decode(obj)
+        ::MultiJson.decode(obj)
+      rescue MultiJson::LoadError => e
+        raise LoadError.new(e.message, e.backtrace, obj)
+      end
+    end
+
+    begin
+      require 'multi_json'
+      include NewJSON
+    rescue Exception
+      Fog::Logger.deprecation "Defaulting to json library for json parsing. Please consider using multi_json library for the greatest performance/flexibility."
+      require 'json'
+      include LegacyJSON
+    end
 
     def self.sanitize(data)
       case data
@@ -20,15 +64,12 @@ module Fog
 
     # Do the MultiJson introspection at this level so we can define our encode/decode methods and perform
     # the introspection only once rather than once per call.
-
     def self.encode(obj)
-      MultiJson.encode(obj)
+      Fog::JSON.instance.encode(obj)
     end
 
     def self.decode(obj)
-      MultiJson.decode(obj)
+      Fog::JSON.instance.decode(obj)
     end
-
-
   end
 end

data/lib/fog/core/model.rb

@@ -60,18 +60,19 @@ module Fog
     end
 
     def wait_for(timeout=Fog.timeout, interval=1, &block)
-      reload
-      retries = 3
-      Fog.wait_for(timeout, interval) do
+      reload_has_succeeded = false
+      duration = Fog.wait_for(timeout, interval) do # Note that duration = false if it times out
         if reload
-          retries = 3
-        elsif retries > 0
-          retries -= 1
-          sleep(1)
-        elsif retries == 0
-          raise Fog::Errors::Error.new("Reload failed, #{self.class} #{self.identity} went away.")
+          reload_has_succeeded = true
+          instance_eval(&block)
+        else
+          false
         end
-        instance_eval(&block)
+      end
+      if reload_has_succeeded
+        return duration # false if timeout; otherwise {:duration => elapsed time }
+      else
+        raise Fog::Errors::Error.new("Reload failed, #{self.class} #{self.identity} not present.")
       end
     end
 

data/lib/fog/core/service.rb

@@ -72,7 +72,7 @@ module Fog
       def fetch_credentials(options)
         # attempt to load credentials from config file
         begin
-          default_credentials = Fog.credentials.reject {|key, value| !(recognized | requirements).include?(key)}
+          Fog.credentials.reject {|key, value| !(recognized | requirements).include?(key)}
         rescue LoadError
           # if there are no configured credentials, do nothing
           {}

data/lib/fog/digitalocean/CHANGELOG.md

@@ -1,4 +1,4 @@
-# 1.11.0 2013/04/04
+# 1.10.1 2013/04/04
 
 * Initial release
 

data/lib/fog/dreamhost/dns.rb

@@ -47,8 +47,6 @@ module Fog
       class Real
 
         def initialize(options={})
-          require 'multi_json'
-
           @dreamhost_api_key  = options[:dreamhost_api_key]
           if options[:dreamhost_url]
             uri = URI.parse(options[:dreamhost_url])
@@ -73,7 +71,7 @@ module Fog
           response = @connection.request(params)
 
           unless response.body.empty?
-            response.body = MultiJson.decode(response.body)
+            response.body = Fog::JSON.decode(response.body)
           end
           if response.body['result'] != 'success'
             raise response.body['data']

data/lib/fog/google.rb

@@ -5,6 +5,7 @@ module Fog
 
     extend Fog::Provider
 
+    service(:compute, 'google/compute', 'Compute')
     service(:storage, 'google/storage', 'Storage')
 
     class Mock

data/lib/fog/google/compute.rb

@@ -0,0 +1,131 @@
+require 'fog/google'
+require 'fog/compute'
+require 'google/api_client'
+
+module Fog
+  module Compute
+    class Google < Fog::Service
+
+      requires :google_project
+      requires :google_client_email
+      requires :google_key_location
+
+      request_path 'fog/google/requests/compute'
+      request :list_servers
+      request :list_disks
+      request :list_firewalls
+      request :list_images
+      request :list_machine_types
+      request :list_networks
+      request :list_zones
+      request :list_global_operations
+      request :list_zone_operations
+
+      request :get_server
+      request :get_disk
+      request :get_firewall
+      request :get_image
+      request :get_machine_type
+      request :get_network
+      request :get_zone
+
+      request :delete_disk
+      request :delete_firewall
+      request :delete_image
+      request :delete_network
+      request :delete_operation
+      request :delete_server
+
+      request :insert_disk
+      request :insert_firewall
+      request :insert_image
+      request :insert_network
+      request :insert_server
+
+      model_path 'fog/google/models/compute'
+      model :server
+      collection :servers
+
+      model :image
+      collection :images
+
+      model :flavor
+      collection :flavors
+
+      class Mock
+        include Collections
+
+        def initialize(options)
+          Fog::Mock::not_implemented
+        end
+
+      end
+
+      class Real
+        include Collections
+
+        attr_reader :project
+
+        def initialize(options)
+          base_url = 'https://www.googleapis.com/compute/'
+          api_version = 'v1beta14'
+          api_scope_url = 'https://www.googleapis.com/auth/compute'
+
+          @project = options[:google_project]
+          google_client_email = options[:google_client_email]
+          @api_url = base_url + api_version + '/projects/'
+          key = ::Google::APIClient::KeyUtils.load_from_pkcs12(File.expand_path(options[:google_key_location]), 'notasecret')
+
+          @client = ::Google::APIClient.new({
+            :application_name => "fog",
+            :application_version => Fog::VERSION,
+          })
+          @client.authorization = Signet::OAuth2::Client.new({
+            :audience => 'https://accounts.google.com/o/oauth2/token',
+            :auth_provider_x509_cert_url => "https://www.googleapis.com/oauth2/v1/certs",
+            :client_x509_cert_url => "https://www.googleapis.com/robot/v1/metadata/x509/#{google_client_email}",
+            :issuer => google_client_email,
+            :scope => api_scope_url,
+            :signing_key => key,
+            :token_credential_uri => 'https://accounts.google.com/o/oauth2/token',
+          })
+          @client.authorization.fetch_access_token!
+
+          @compute = @client.discovered_api('compute', api_version)
+          @default_network = 'default'
+        end
+
+        def build_result(api_method, parameters, body_object=nil)
+          if body_object
+            #p api_method, parameters
+            result = @client.execute(
+              :api_method => api_method,
+              :parameters => parameters,
+              :body_object => body_object
+            )
+          else
+            result = @client.execute(
+              :api_method => api_method,
+              :parameters => parameters
+            )
+          end
+        end
+
+        def build_response(result)
+          response = Excon::Response.new
+          response.body = Fog::JSON.decode(result.body)
+          if response.body["error"]
+            response.status = response.body["error"]["code"]
+          else
+            response.status = 200
+          end
+          response
+        end
+
+      end
+
+      RUNNING_STATE = 'RUNNING'
+
+    end
+  end
+end

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

@@ -0,0 +1,24 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Google
+
+      class Flavor < Fog::Model
+
+        identity :name
+
+        attribute :description
+        attribute :guest_cpus, :aliases => 'guestCpus'
+        attribute :memory_mb, :aliases => 'memoryMb'
+        attribute :image_space_gb, :aliases => 'imageSpaceGb'
+        attribute :maximum_persistent_disks,
+          :aliases => 'maximumPersistentDisks'
+        attribute :maximum_persistent_disks_size,
+          :aliases => 'maximumPersistentDisksSizeGb'
+
+      end
+
+    end
+  end
+end

data/lib/fog/google/models/compute/flavors.rb

@@ -0,0 +1,28 @@
+require 'fog/core/collection'
+require 'fog/google/models/compute/flavor'
+
+module Fog
+  module Compute
+    class Google
+
+      class Flavors < Fog::Collection
+
+        model Fog::Compute::Google::Flavor
+
+        def all
+          data = connection.list_machine_types.body["items"]
+          load(data)
+        end
+
+        def get(identity)
+          data = connection.get_machine_type(identity).body
+          new(data)
+        rescue Excon::Errors::NotFound
+          nil
+        end
+
+      end
+
+    end
+  end
+end