fog 1.25.0 → 2.0.0

data/lib/fog/digitalocean/core.rb

@@ -1,9 +0,0 @@
-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

@@ -1,106 +0,0 @@
-# Getting started: the compute service
-
-You'll need a DigitalOcean account and API key to use this provider.
-
-Get one from http://www.digitalocean.com.
-
-To generate the API key, login to the DigitalOcean web panel and go to
-'My Settings -> API Access -> Generate a new API key'.
-
-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
-})
-```
-
-## 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
-```
-
-

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

@@ -1,12 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class DigitalOcean
-      class Flavor < Fog::Model
-        identity  :id
-        attribute :name
-      end
-    end
-  end
-end

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

@@ -1,22 +0,0 @@
-require 'fog/core/collection'
-require 'fog/digitalocean/models/compute/flavor'
-
-module Fog
-  module Compute
-    class DigitalOcean
-      class Flavors < Fog::Collection
-        model Fog::Compute::DigitalOcean::Flavor
-
-        def all
-          load service.list_flavors.body['sizes']
-        end
-
-        def get(id)
-          all.find { |f| f.id == id }
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

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

@@ -1,13 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class DigitalOcean
-      class Image < Fog::Model
-        identity  :id
-        attribute :name
-        attribute :distribution
-      end
-    end
-  end
-end

data/lib/fog/digitalocean/models/compute/images.rb

@@ -1,22 +0,0 @@
-require 'fog/core/collection'
-require 'fog/digitalocean/models/compute/image'
-
-module Fog
-  module Compute
-    class DigitalOcean
-      class Images < Fog::Collection
-        model Fog::Compute::DigitalOcean::Image
-
-        def all
-          load service.list_images.body['images']
-        end
-
-        def get(id)
-          all.find { |f| f.id == id }
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/digitalocean/models/compute/region.rb

@@ -1,12 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module Compute
-    class DigitalOcean
-      class Region < Fog::Model
-        identity  :id
-        attribute :name
-      end
-    end
-  end
-end

data/lib/fog/digitalocean/models/compute/regions.rb

@@ -1,22 +0,0 @@
-require 'fog/core/collection'
-require 'fog/digitalocean/models/compute/region'
-
-module Fog
-  module Compute
-    class DigitalOcean
-      class Regions < Fog::Collection
-        model Fog::Compute::DigitalOcean::Region
-
-        def all
-          load service.list_regions.body['regions']
-        end
-
-        def get(id)
-          all.find { |f| f.id == id }
-        rescue Fog::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/digitalocean/models/compute/server.rb

@@ -1,180 +0,0 @@
-require 'fog/compute/models/server'
-
-module Fog
-  module Compute
-    class DigitalOcean
-      # A DigitalOcean Droplet
-      #
-      class Server < Fog::Compute::Server
-        identity  :id
-        attribute :name
-        attribute :state, :aliases => 'status'
-        attribute :image_id
-        attribute :region_id
-        attribute :flavor_id, :aliases => 'size_id'
-        # Not documented in their API, but
-        # available nevertheless
-        attribute :public_ip_address, :aliases => 'ip_address'
-        attribute :private_ip_address
-        attribute :backups_active
-        attribute :created_at
-
-        attr_writer :ssh_keys
-
-        # Deprecated: Use public_ip_address instead.
-        def ip_address
-          Fog::Logger.warning("ip_address has been deprecated. Use public_ip_address instead")
-          public_ip_address
-        end
-
-        # Reboot the server (soft reboot).
-        #
-        # The preferred method of rebooting a server.
-        def reboot
-          requires :id
-          service.reboot_server self.id
-        end
-
-        # Reboot the server (hard reboot).
-        #
-        # Powers the server off and then powers it on again.
-        def power_cycle
-          requires :id
-          service.power_cycle_server self.id
-        end
-
-        # Shutdown the server
-        #
-        # Sends a shutdown signal to the operating system.
-        # The server consumes resources while powered off
-        # so you are still charged.
-        #
-        # @see https://www.digitalocean.com/community/questions/am-i-charged-while-my-droplet-is-in-a-powered-off-state
-        def shutdown
-          requires :id
-          service.shutdown_server self.id
-        end
-
-        # Power off the server
-        #
-        # Works as a power switch.
-        # The server consumes resources while powered off
-        # so you are still charged.
-        #
-        # @see https://www.digitalocean.com/community/questions/am-i-charged-while-my-droplet-is-in-a-powered-off-state
-        def stop
-          requires :id
-          service.power_off_server self.id
-        end
-
-        # Power on the server.
-        #
-        # The server consumes resources while powered on
-        # so you will be charged.
-        #
-        # Each time a server is spun up, even if for a few seconds,
-        # it is charged for an hour.
-        #
-        def start
-          requires :id
-          service.power_on_server self.id
-        end
-
-        def setup(credentials = {})
-          requires :ssh_ip_address
-          require 'net/ssh'
-
-          commands = [
-            %{mkdir .ssh},
-            %{passwd -l #{username}},
-            %{echo "#{Fog::JSON.encode(Fog::JSON.sanitize(attributes))}" >> ~/attributes.json}
-          ]
-          if public_key
-            commands << %{echo "#{public_key}" >> ~/.ssh/authorized_keys}
-          end
-
-          # wait for aws to be ready
-          wait_for { sshable?(credentials) }
-
-          Fog::SSH.new(ssh_ip_address, username, credentials).run(commands)
-        end
-
-        # Creates the server (not to be called directly).
-        #
-        # Usually called by Fog::Collection#create
-        #
-        #   docean = Fog::Compute.new({
-        #     :provider => 'DigitalOcean',
-        #     :digitalocean_api_key   => 'key-here',      # your API key here
-        #     :digitalocean_client_id => 'client-id-here' # your client key here
-        #   })
-        #   docean.servers.create :name => 'foobar',
-        #                     :image_id  => image_id_here,
-        #                     :flavor_id => flavor_id_here,
-        #                     :region_id => region_id_here
-        #
-        # @return [Boolean]
-        def save
-          raise Fog::Errors::Error.new('Resaving an existing object may create a duplicate') if persisted?
-          requires :name, :flavor_id, :image_id, :region_id
-
-          options = {}
-          if attributes[:ssh_key_ids]
-            options[:ssh_key_ids] = attributes[:ssh_key_ids]
-          elsif @ssh_keys
-            options[:ssh_key_ids] = @ssh_keys.map(&:id)
-          end
-
-          options[:private_networking] = !!attributes[:private_networking]
-
-          data = service.create_server name,
-                                       flavor_id,
-                                       image_id,
-                                       region_id,
-                                       options
-          merge_attributes(data.body['droplet'])
-          true
-        end
-
-        # Destroy the server, freeing up the resources.
-        #
-        # DigitalOcean will stop charging you for the resources
-        # the server was using.
-        #
-        # Once the server has been destroyed, there's no way
-        # to recover it so the data is irrecoverably lost.
-        #
-        # IMPORTANT: As of 2013/01/31, you should wait some time to
-        # destroy the server after creating it. If you try to destroy
-        # the server too fast, the destroy event may be lost and the
-        # server will remain running and consuming resources, so
-        # DigitalOcean will keep charging you.
-        # Double checked this with DigitalOcean staff and confirmed
-        # that it's the way it works right now.
-        #
-        # Double check the server has been destroyed!
-        def destroy
-          requires :id
-          service.destroy_server id
-        end
-
-        # Checks whether the server status is 'active'.
-        #
-        # The server transitions from 'new' to 'active' sixty to ninety
-        # seconds after creating it (time varies and may take more
-        # than 90 secs).
-        #
-        # @return [Boolean]
-        def ready?
-          state == 'active'
-        end
-
-        # DigitalOcean API does not support updating server state
-        def update
-          msg = 'DigitalOcean servers do not support updates'
-          raise NotImplementedError.new(msg)
-        end
-      end
-    end
-  end
-end

data/lib/fog/digitalocean/models/compute/servers.rb

@@ -1,65 +0,0 @@
-require 'fog/core/collection'
-require 'fog/digitalocean/models/compute/server'
-
-module Fog
-  module Compute
-    class DigitalOcean
-      class Servers < Fog::Collection
-        model Fog::Compute::DigitalOcean::Server
-
-        def all(filters = {})
-          data = service.list_servers.body['droplets']
-          load(data)
-        end
-
-        def bootstrap(new_attributes = {})
-          server = new(new_attributes)
-
-          check_keys(new_attributes)
-
-          credential = Fog.respond_to?(:credential) && Fog.credential || :default
-          name       = "fog_#{credential}"
-          ssh_key    = service.ssh_keys.find { |key| key.name == name }
-          if ssh_key.nil?
-            ssh_key = service.ssh_keys.create(
-              :name        => name,
-              :ssh_pub_key => (new_attributes[:public_key] || File.read(new_attributes[:public_key_path]))
-            )
-          end
-          server.ssh_keys = [ssh_key]
-
-          server.save
-          server.wait_for { ready? }
-
-          if new_attributes[:private_key]
-            server.setup :key_data => [new_attributes[:private_key]]
-          else
-            server.setup :keys => [new_attributes[:private_key_path]]
-          end
-
-          server
-        end
-
-        def get(id)
-          server = service.get_server_details(id).body['droplet']
-          new(server) if server
-        rescue Fog::Errors::NotFound
-          nil
-        end
-
-        protected
-
-        def check_keys(attributes)
-          check_key :public, attributes[:public_key], attributes[:public_key_path]
-          check_key :private, attributes[:private_key], attributes[:private_key_path]
-        end
-
-        def check_key(name, data, path)
-          if [data, path].all?(&:nil?)
-            raise ArgumentError, "either #{name}_key or #{name}_key_path is required to configure the server"
-          end
-        end
-      end
-    end
-  end
-end