fog 1.42.1 → 2.0.0.pre.0

data/lib/fog/bin/internet_archive.rb

@@ -0,0 +1,32 @@
+class InternetArchive < Fog::Bin
+  class << self
+    def class_for(key)
+      case key
+      when :storage
+        Fog::Storage::InternetArchive
+      else
+        # @todo Replace most instances of ArgumentError with NotImplementedError
+        # @todo For a list of widely supported Exceptions, see:
+        # => http://www.zenspider.com/Languages/Ruby/QuickRef.html#35
+        raise ArgumentError, "Unsupported #{self} service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :storage
+          Fog::Logger.warning("InternetArchive[:storage] is not recommended, use Storage[:aws] for portability")
+          Fog::Storage.new(:provider => 'InternetArchive')
+        else
+          raise ArgumentError, "Unrecognized service: #{key.inspect}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::InternetArchive.services
+    end
+  end
+end

data/lib/fog/bin/joyent.rb

@@ -0,0 +1,33 @@
+class Joyent < Fog::Bin
+  class << self
+    def class_for(key)
+      case key
+      when :compute
+        Fog::Compute::Joyent
+      when :analytics
+        Fog::Joyent::Analytics
+      else
+        raise ArgumentError, "Unrecognized service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :compute
+          Fog::Logger.warning("Joyent[:compute] is not recommended, use Compute[:joyent] for portability")
+          Fog::Compute.new(:provider => 'Joyent')
+        when :analytics
+          Fog::Joyent::Analytics.new
+        else
+          raise ArgumentError, "Unrecognized service: #{key.inspect}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::Joyent.services
+    end
+  end
+end

data/lib/fog/bin/ninefold.rb

@@ -0,0 +1,34 @@
+class Ninefold < Fog::Bin
+  class << self
+    def class_for(key)
+      case key
+      when :compute
+        Fog::Compute::Ninefold
+      when :storage
+        Fog::Storage::Ninefold
+      else
+        raise ArgumentError, "Unsupported #{self} service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :compute
+          Fog::Logger.warning("Ninefold[:compute] is not recommended, use Compute[:ninefold] for portability")
+          Fog::Compute.new(:provider => 'Ninefold')
+        when :storage
+          Fog::Logger.warning("Ninefold[:storage] is not recommended, use Storage[:ninefold] for portability")
+          Fog::Storage.new(:provider => 'Ninefold')
+        else
+          raise ArgumentError, "Unrecognized service: #{service}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::Ninefold.services
+    end
+  end
+end

data/lib/fog/bin/ovirt.rb

@@ -0,0 +1,28 @@
+class Ovirt < Fog::Bin
+  class << self
+    def class_for(key)
+      case key
+      when :compute
+        Fog::Compute::Ovirt
+      else
+        raise ArgumentError, "Unrecognized service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+                    when :compute
+                      Fog::Compute.new(:provider => 'Ovirt')
+                    else
+                      raise ArgumentError, "Unrecognized service: #{key.inspect}"
+                    end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::Ovirt.services
+    end
+  end
+end

data/lib/fog/bin/vsphere.rb

@@ -0,0 +1,28 @@
+class Vsphere < Fog::Bin
+  class << self
+    def class_for(key)
+      case key
+      when :compute
+        Fog::Compute::Vsphere
+      else
+        raise ArgumentError, "Unrecognized service: #{key}"
+      end
+    end
+
+    def [](service)
+      @@connections ||= Hash.new do |hash, key|
+        hash[key] = case key
+        when :compute
+          Fog::Compute.new(:provider => 'Vsphere')
+        else
+          raise ArgumentError, "Unrecognized service: #{key.inspect}"
+        end
+      end
+      @@connections[service]
+    end
+
+    def services
+      Fog::Vsphere.services
+    end
+  end
+end

data/lib/fog/cloudsigma/compute.rb

@@ -18,15 +18,6 @@ module Fog
       request :update_volume
       request :delete_volume
       request :clone_volume
-      
-      model :snapshot
-      collection :snapshots
-      request :create_snapshot
-      request :get_snapshot
-      request :list_snapshots
-      request :update_snapshot
-      request :delete_snapshot
-      request :clone_snapshot
 
       model :lib_volume
       collection :lib_volumes

data/lib/fog/cloudsigma/models/server.rb

@@ -71,11 +71,6 @@ module Fog
           requires :identity
           service.stop_server(identity)
         end
-        
-        def shutdown
-          requires :identity
-          service.stop_server(identity, true)
-        end
 
         def ready?
           status == "running"

data/lib/fog/cloudsigma/models/volume.rb

@@ -1,5 +1,4 @@
 require 'fog/cloudsigma/nested_model'
-require 'fog/cloudsigma/models/snapshot'
 
 module Fog
   module Compute
@@ -20,7 +19,6 @@ module Fog
         attribute :affinities, :type => :array
         attribute :size, :type => :integer
         attribute :resource_uri, :type => :string
-        model_attribute_array :snapshots, Snapshot
 
         def save
           if persisted?
@@ -65,19 +63,6 @@ module Fog
 
           self.class.new(response.body['objects'].first)
         end
-        
-        def create_snapshot(snapshot_params={})
-          requires :identity
-          snapshot_params[:drive] = identity
-          response = service.create_snapshot(snapshot_params)
-
-          Snapshot.new(response.body['objects'].first)
-        end
-        
-        def available?
-          status == 'unmounted'
-        end
-        
       end
     end
   end

data/lib/fog/cloudsigma/requests/stop_server.rb

@@ -2,24 +2,23 @@ module Fog
   module Compute
     class CloudSigma
       class Real
-        def stop_server(server_id, graceful_acpi = false)
-          action = graceful_acpi ? :shutdown : :stop
+        def stop_server(server_id)
           request(:path => "servers/#{server_id}/action/",
                   :method => 'POST',
-                  :query => {:do => action},
+                  :query => {:do => :stop},
                   :expects => [200, 202])
         end
       end
 
       class Mock
-        def stop_server(server_id, graceful_acpi = false)
+        def stop_server(server_id)
           server = self.data[:servers][server_id]
           server['status'] = 'stopped'
 
           response = Excon::Response.new
           response.status = 200
           response.body = {
-              'action' => graceful_acpi ? 'shutdown' : 'stop',
+              'action' => 'stop',
               'result' => 'success',
               'uuid' => server_id
           }

data/lib/fog/cloudstack/core.rb

@@ -13,8 +13,6 @@ module Fog
     def self.escape(string)
       string = CGI::escape(string)
       string = string.gsub("+","%20")
-      # Escaped asterisk will cause malformed request
-      string = string.gsub("%2A","*")
       string
     end
 

data/lib/fog/digitalocean.rb

@@ -0,0 +1 @@
+require 'fog/digitalocean/compute'

data/lib/fog/digitalocean/CHANGELOG.md

@@ -0,0 +1,6 @@
+# 1.10.1 2013/04/04
+
+* Initial release
+
+  Getting started example: https://github.com/fog/fog/blob/master/lib/fog/digitalocean/examples/getting_started.md
+

data/lib/fog/digitalocean/compute.rb

@@ -0,0 +1,130 @@
+require 'fog/digitalocean/core'
+
+module Fog
+  module Compute
+    class DigitalOcean < Fog::Service
+      requires     :digitalocean_api_key
+      requires     :digitalocean_client_id
+
+      recognizes   :digitalocean_api_url
+
+      model_path   'fog/digitalocean/models/compute'
+      model        :server
+      collection   :servers
+      model        :flavor
+      collection   :flavors
+      model        :image
+      collection   :images
+      model        :region
+      collection   :regions
+      model        :ssh_key
+      collection   :ssh_keys
+
+      request_path 'fog/digitalocean/requests/compute'
+      request      :list_servers
+      request      :list_images
+      request      :list_regions
+      request      :list_flavors
+      request      :get_server_details
+      request      :create_server
+      request      :destroy_server
+      request      :reboot_server
+      request      :power_cycle_server
+      request      :power_off_server
+      request      :power_on_server
+      request      :shutdown_server
+      request      :list_ssh_keys
+      request      :create_ssh_key
+      request      :get_ssh_key
+      request      :destroy_ssh_key
+
+      # request :digitalocean_resize
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :servers => [],
+              :ssh_keys => []
+            }
+          end
+        end
+
+        def self.reset
+          @data = nil
+        end
+
+        def initialize(options={})
+          @digitalocean_api_key = options[:digitalocean_api_key]
+        end
+
+        def data
+          self.class.data[@digitalocean_api_key]
+        end
+
+        def reset_data
+          self.class.data.delete(@digitalocean_api_key)
+        end
+      end
+
+      class Real
+        def initialize(options={})
+          @digitalocean_api_key   = options[:digitalocean_api_key]
+          @digitalocean_client_id = options[:digitalocean_client_id]
+          @digitalocean_api_url   = options[:digitalocean_api_url] || \
+                                            "https://api.digitalocean.com"
+          @connection             = Fog::XML::Connection.new(@digitalocean_api_url)
+        end
+
+        def reload
+          @connection.reset
+        end
+
+        def request(params)
+          params[:query] ||= {}
+          params[:query].merge!(:api_key   => @digitalocean_api_key)
+          params[:query].merge!(:client_id => @digitalocean_client_id)
+
+          response = retry_event_lock { parse @connection.request(params) }
+
+          unless response.body.empty?
+            if response.body['status'] != 'OK'
+              case response.body['error_message']
+              when /No Droplets Found/
+                raise Fog::Errors::NotFound.new
+              else
+                raise Fog::Errors::Error.new response.body.to_s
+              end
+            end
+          end
+          response
+        end
+
+        private
+
+        def parse(response)
+          return response if response.body.empty?
+          response.body = Fog::JSON.decode(response.body)
+          response
+        end
+
+        def retry_event_lock
+          count   = 0
+          response = nil
+          while count < 5
+            response = yield
+
+            if response.body && response.body['error_message'] =~ /There is already a pending event for the droplet/
+              count += 1
+              sleep count ** 3
+            else
+              break
+            end
+          end
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/core.rb

@@ -0,0 +1,9 @@
+require 'fog/core'
+require 'fog/json'
+
+module Fog
+  module DigitalOcean
+    extend Fog::Provider
+    service(:compute, 'Compute')
+  end
+end

data/lib/fog/digitalocean/examples/getting_started.md

@@ -0,0 +1,148 @@
+# Getting started: the compute service
+
+You'll need a DigitalOcean account and API key to use this provider.
+
+Get one from https://cloud.digitalocean.com/api_access (fog currently uses the v1 API)
+
+Write down the Client Key and API Key, you'll need both to use the service.
+
+
+## Connecting, retrieving and managing server objects
+
+Before we start, I guess it will be useful to the reader to know
+that Fog servers are 'droplets' in DigitalOcean's parlance.
+'Server' is the Fog way to name VMs, and we have
+respected that in the DigitalOcean's Fog provider.
+
+First, create a connection to the host:
+
+```ruby
+require 'fog'
+
+docean = Fog::Compute.new({
+  :provider => 'DigitalOcean',
+  :digitalocean_api_key   => 'poiuweoruwoeiuroiwuer', # your API key here
+  :digitalocean_client_id => 'lkjasoidfuoiu'          # your client key here
+})
+```
+
+## SSH Key Management
+
+Access to DigitalOcean servers can be managed with SSH keys. These can be assigned to servers at creation time so you can access them without having to use a password.
+
+Creating a key:
+
+```ruby
+docean.ssh_keys.create(
+  :name        => 'Default SSH Key',
+  :ssh_pub_key => File.read('~/.ssh/id_rsa.pub'))
+)
+```
+
+Listing all keys:
+
+```ruby
+docean.ssh_keys.each do | key |
+   key.name
+   key.ssh_pub_key
+end
+```
+
+Destroying a key:
+
+```ruby
+docean.ssh_keys.destroy(:id => '27100')
+```
+
+## Boostrapping a server
+
+Fog can be used to bootstrap a server, which will create an SSH key to be assigned to a server at boot.
+
+```ruby
+server = connection.servers.bootstrap({
+  :name => 'test',
+  :image_id => 1505447,
+  :size_id => 33,
+  :region_id => 4,
+  :flavor_id => 66,
+  :public_key_path => File.expand_path('~/.ssh/id_rsa.pub'),
+  :private_key_path => File.expand_path('~/.ssh/id_rsa'),
+})
+server.wait_for { ready? }
+```
+
+## Listing servers
+
+Listing servers and attributes:
+
+```ruby
+docean.servers.each do |server|
+  # remember, servers are droplets
+  server.id
+  server.name
+  server.state
+  server.backups_enabled
+  server.image_id
+  server.flavor_id # server 'size' in DigitalOcean's API parlance
+  server.region_id
+end
+```
+
+## Server creation and life-cycle management
+
+Creating a new server (droplet):
+
+```ruby
+server = docean.servers.create :name => 'foobar',
+                               # use the first image listed
+                               :image_id  => docean.images.first.id,
+                               # use the first flavor listed
+                               :flavor_id => docean.flavors.first.id,
+                               # use the first region listed
+                               :region_id => docean.regions.first.id
+```
+
+The server is automatically started after that.
+
+We didn't pay attention when choosing the flavor, image and region used
+but you can easily list them too, and then decide:
+
+```ruby
+docean.images.each do |image|
+  image.id
+  image.name
+  image.distribution
+end
+
+docean.flavors.each do |flavor|
+  flavor.id
+  flavor.name
+end
+
+docean.regions.each do |region|
+  region.id
+  region.name
+end
+
+```
+
+Rebooting a server:
+
+```ruby
+server = docean.servers.first
+server.reboot
+```
+
+Power cycle a server:
+
+```ruby
+server.power_cycle
+```
+
+Destroying the server:
+
+```ruby
+server.destroy
+```
+
+