cifrado 0.1

data/vendor/fog/lib/fog/core/time.rb

@@ -0,0 +1,32 @@
+require 'time'
+
+module Fog
+  class Time < ::Time
+
+    DAYS = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat']
+    MONTHS = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec']
+
+    def self.now
+      at((::Time.now - offset).to_i)
+    end
+
+    def self.now=(new_now)
+      old_now = ::Time.now
+      @offset = old_now - new_now
+      new_now
+    end
+
+    def self.offset
+      @offset ||= 0
+    end
+
+    def to_date_header
+      self.utc.strftime("#{DAYS[self.utc.wday]}, %d #{MONTHS[self.utc.month - 1]} %Y %H:%M:%S +0000")
+    end
+
+    def to_iso8601_basic
+      self.utc.strftime('%Y%m%dT%H%M%SZ')
+    end
+
+  end
+end

data/vendor/fog/lib/fog/core/timeout.rb

@@ -0,0 +1,11 @@
+module Fog
+  @timeout = 600
+  def self.timeout
+    @timeout
+  end
+
+  def self.timeout=(timeout)
+    raise ArgumentError, "timeout must be non-negative" unless timeout >= 0
+    @timeout = timeout
+  end
+end

data/vendor/fog/lib/fog/core/wait_for.rb

@@ -0,0 +1,15 @@
+module Fog
+  def self.wait_for(timeout=Fog.timeout, interval=1, &block)
+    duration = 0
+    start = Time.now
+    until yield || duration > timeout
+      sleep(interval.to_f)
+      duration = Time.now - start
+    end
+    if duration > timeout
+      raise Errors::TimeoutError.new("The specified wait_for timeout (#{timeout} seconds) was exceeded")
+    else
+      { :duration => duration }
+    end
+  end
+end

data/vendor/fog/lib/fog/digitalocean.rb

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

data/vendor/fog/lib/fog/digitalocean/compute.rb

@@ -0,0 +1,100 @@
+require 'fog/digitalocean'
+require 'fog/compute'
+
+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
+      
+      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 :digitalocean_resize      
+
+      class Mock
+
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {}
+          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::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 = @connection.request(params)
+
+          unless response.body.empty?
+            response.body = Fog::JSON.decode(response.body)
+            if response.body['status'] != 'OK'
+              raise Fog::Errors::Error.new
+            end
+          end
+          response
+        end
+
+      end
+    end
+  end
+end

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

@@ -0,0 +1,106 @@
+# 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'
+
+do = 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.status
+  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/vendor/fog/lib/fog/digitalocean/models/compute/flavor.rb

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

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

@@ -0,0 +1,25 @@
+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/vendor/fog/lib/fog/digitalocean/models/compute/image.rb

@@ -0,0 +1,15 @@
+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/vendor/fog/lib/fog/digitalocean/models/compute/images.rb

@@ -0,0 +1,25 @@
+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/vendor/fog/lib/fog/digitalocean/models/compute/region.rb

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

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

@@ -0,0 +1,25 @@
+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/vendor/fog/lib/fog/digitalocean/models/compute/server.rb

@@ -0,0 +1,150 @@
+require 'fog/compute/models/server'
+
+module Fog
+  module Compute
+    class DigitalOcean
+
+      # A DigitalOcean Droplet
+      #
+      class Server < Fog::Compute::Server
+        
+        identity  :id
+        attribute :name
+        attribute :status
+        attribute :image_id
+        attribute :region_id
+        attribute :flavor_id,         :aliases => :size_id
+        # Not documented in their API, but
+        # available nevertheless
+        attribute :ip_address
+        attribute :backups_active
+
+        # 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
+
+        # Creates the server (not to be called directly).
+        #
+        # Usually called by Fog::Collection#create
+        #
+        #   do = Fog::Compute.new({
+        #     :provider => 'DigitalOcean',
+        #     :digitalocean_api_key   => 'key-here',      # your API key here
+        #     :digitalocean_client_id => 'client-id-here' # your client key here
+        #   })
+        #   do.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] 
+          end
+          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?
+          status == '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