fog-digitalocean 0.1.0

data/bin/fog

@@ -0,0 +1,78 @@
+#!/usr/bin/env ruby
+
+require File.expand_path(File.join(File.dirname(__FILE__), '..', 'lib', 'fog'))
+require 'optparse'
+require 'irb'
+require 'yaml'
+
+options = OptionParser.new do |opts|
+  opts.banner = 'usage: fog [options] CREDENTIAL'
+
+  opts.on('-C', '--credentials-path FILE', 'Path to the credentials file') do |file|
+    Fog.credentials_path = file
+  end
+
+  opts.on_tail('-v', '--version', 'Prints the version') do
+    puts Fog::VERSION
+    exit
+  end
+
+  opts.on_tail('-h', '--help', 'Prints this message') do
+    puts opts
+    exit
+  end
+end
+options.parse!
+
+Fog.credential = ARGV.first ? ARGV.first.to_sym : nil
+Fog.mock! if ENV['FOG_MOCK']
+if Fog.credentials.empty?
+  begin
+    Fog::Errors.missing_credentials
+  rescue Fog::Errors::LoadError => error
+    abort error.message
+  end
+end
+
+require 'fog/bin'
+
+providers = Fog.available_providers
+providers = if providers.length > 1
+  providers[0...-1].join(', ') << ' and ' << providers[-1]
+else
+  providers.first
+end
+
+if ARGV.length > 1
+
+  result = instance_eval(ARGV[1..-1].join(' '))
+  puts(Fog::JSON.encode(result))
+
+else
+
+  ARGV.clear # Avoid passing args to IRB
+  IRB.setup(nil)
+  @irb = IRB::Irb.new(nil)
+  IRB.conf[:MAIN_CONTEXT] = @irb.context
+  IRB.conf[:PROMPT][:FOG] = IRB.conf[:PROMPT][:SIMPLE].dup
+  IRB.conf[:PROMPT][:FOG][:RETURN] = "%s\n"
+  @irb.context.prompt_mode = :FOG
+  @irb.context.workspace = IRB::WorkSpace.new(binding)
+
+  trap 'INT' do
+    @irb.signal_handle
+  end
+
+  Fog::Formatador.display_line('Welcome to fog interactive!')
+  Fog::Formatador.display_line(":#{Fog.credential} provides #{providers}")
+  providers = Fog.providers
+
+  # FIXME: hacks until we can `include Fog` in bin
+  CDN     = Fog::CDN
+  Compute = Fog::Compute
+  DNS     = Fog::DNS
+  Storage = Fog::Storage
+
+  catch(:IRB_EXIT) { @irb.eval_input }
+
+end

data/fog-digitalocean.gemspec

@@ -0,0 +1,61 @@
+# coding: utf-8
+lib = File.expand_path("../lib", __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require "fog/digitalocean/version"
+
+Gem::Specification.new do |s|
+  s.specification_version = 2 if s.respond_to? :specification_version=
+  s.required_rubygems_version = Gem::Requirement.new(">= 0") if s.respond_to? :required_rubygems_version=
+
+  ## Leave these as is they will be modified for you by the rake gemspec task.
+  ## If your rubyforge_project name is different, then edit it and comment out
+  ## the sub! line in the Rakefile
+  s.name              = "fog-digitalocean"
+  s.version           = Fog::Digitalocean::VERSION
+  s.date              = "2016-03-30"
+
+  ## Make sure your summary is short. The description may be as long
+  ## as you like.
+  s.summary     = %q{DigitalOcean fog provider gem}
+  s.description = %q{DigitalOcean fog provider gem}
+
+  ## List the primary authors. If there are a bunch of authors, it's probably
+  ## better to set the email to an email list or something. If you don't have
+  ## a custom homepage, consider using your GitHub URL or the like.
+  s.authors  = ["JJ Asghar", "Suraj Shirvankar"]
+  s.email    = ["jj@chef.io", "surajshirvankar@gmail.com"]
+  s.homepage = "http://github.com/fog/fog-digitalocean"
+  s.license  = "MIT"
+
+  ## This sections is only necessary if you have C extensions.
+  # s.require_paths << 'ext'
+  # s.extensions = %w[ext/extconf.rb]
+
+  ## This gets added to the $LOAD_PATH so that 'lib/NAME.rb' can be required as
+  ## require 'NAME.rb' or'/lib/NAME/file.rb' can be as require 'NAME/file.rb'
+  s.require_paths = %w[lib]
+
+  ## If your gem includes any executables, list them here.
+  s.executables = ["fog"]
+
+  ## Specify any RDoc options here. You'll want to add your README and
+  ## LICENSE files to the extra_rdoc_files list.
+  s.rdoc_options = ["--charset=UTF-8"]
+  s.extra_rdoc_files = %w[README.md]
+
+  s.add_development_dependency 'bundler', '~> 1.6'
+  s.add_development_dependency 'rake',    '~> 10.0'
+  s.add_development_dependency 'shindo',  '~> 0.3'
+  s.add_development_dependency 'rubyzip', '~> 0.9.9'
+  s.add_development_dependency 'mime-types'
+  s.add_development_dependency 'mime-types-data'
+  s.add_development_dependency 'rubocop'
+
+  s.add_dependency 'fog-core',  '~> 1.42'
+  s.add_dependency 'fog-json',  '>= 1.0'
+  s.add_dependency 'fog-xml',   '>= 0.1'
+  s.add_dependency 'ipaddress', '>= 0.5'
+
+  s.files = `git ls-files`.split("\n")
+  s.test_files = `git ls-files -- {spec,tests}/*`.split("\n")
+end

data/gemfiles/Gemfile-edge

@@ -0,0 +1,14 @@
+source "https://rubygems.org"
+
+# Shared components
+gem "fog-core", :github => "fog/fog-core"
+gem "fog-json", :github => "fog/fog-json"
+
+group :development, :test do
+  # This is here because gemspec doesn"t support require: false
+  gem "coveralls", :require => false
+  gem "netrc", :require => false
+  gem "octokit", :require => false
+end
+
+gemspec :path => "../"

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,109 @@
+require 'fog/digitalocean/core'
+
+module Fog
+  module Compute
+    class DigitalOcean < Fog::Service
+      requires :digitalocean_token
+
+      model_path 'fog/digitalocean/models/compute'
+      model :server
+      collection :servers
+      model :image
+      collection :images
+      model :region
+      collection :regions
+      model :flavor
+      collection :flavors
+      model :ssh_key
+      collection :ssh_keys
+
+      request_path 'fog/digitalocean/requests/compute'
+      request :change_kernel
+      request :create_server
+      request :create_ssh_key
+      request :destroy_server
+      request :delete_ssh_key
+      request :disable_backups
+      request :enable_ipv6
+      request :enable_private_networking
+      request :get_droplet_action
+      request :get_image_details
+      request :get_server_details
+      request :get_ssh_key
+      request :list_droplet_actions
+      request :list_flavors
+      request :list_images
+      request :list_regions
+      request :list_servers
+      request :list_ssh_keys
+      request :password_reset
+      request :power_cycle
+      request :power_off
+      request :power_on
+      request :reboot_server
+      request :rebuild
+      request :rename
+      request :resize
+      request :restore
+      request :shutdown
+      request :snapshot
+      request :update_ssh_key
+      request :upgrade
+
+
+      class Mock
+        def self.data
+          @data ||= Hash.new do |hash, key|
+            hash[key] = {
+              :servers  => [],
+              :ssh_keys => []
+            }
+          end
+        end
+
+        def initialize(options={})
+          @digitalocean_token = options[:digitalocean_token]
+        end
+
+        def data
+          self.class.data[@digitalocean_token]
+        end
+
+        def reset_data
+          self.class.data.delete(@digitalocean_token)
+        end
+      end
+
+      class Real
+        def initialize(options={})
+          digitalocean_token = options[:digitalocean_token]
+          persistent         = false
+          options            = {
+            headers: {
+              'Authorization' => "Bearer #{digitalocean_token}",
+            }
+          }
+          @connection        = Fog::Core::Connection.new 'https://api.digitalocean.com', persistent, options
+        end
+
+        def request(params)
+          params[:headers] ||= {}
+          begin
+            response = @connection.request(params)
+          rescue Excon::Errors::HTTPStatusError => error
+            raise case error
+                    when Excon::Errors::NotFound
+                      NotFound.slurp(error)
+                    else
+                      error
+                  end
+          end
+          unless response.body.empty?
+            response.body = Fog::JSON.decode(response.body)
+          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,123 @@
+# Getting started: the compute service
+
+You'll need a DigitalOcean account and an API token to use this provider.
+
+Get one from https://cloud.digitalocean.com/settings/tokens/new
+
+Write down the Access Token.
+
+## 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/digitalocean'
+
+docean = Fog::Compute.new({
+  :provider => 'DigitalOcean',
+  :digitalocean_token   => 'poiuweoruwoeiuroiwuer', # your Access Token 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 |
+  puts key.name
+  puts key.public_key
+  puts key.id
+end
+```
+
+Destroying a key:
+
+```ruby
+docean.ssh_keys.destroy(:id => '27100')
+```
+## Listing servers
+
+Listing servers and attributes:
+
+```ruby
+docean.servers.each do |server|
+  # remember, servers are droplets
+  puts server.id
+  puts server.name
+  puts server.status
+  puts (server.image['slug'] || server.image['name']) # slug is only for public images, private images use name
+  puts server.size['slug']
+  puts server.region['slug']
+end
+```
+
+## Server creation and life-cycle management
+
+Creating a new server (droplet):
+
+```ruby
+server = docean.servers.create :name => 'foobar',
+                               # use the last image listed
+                               :image  => docean.images.last.id,
+                               # use the first flavor (aka size) listed
+                               :size => docean.flavors.first.slug,
+                               # use the first region listed
+                               :region => docean.regions.first.slug
+```
+
+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|
+  puts image.id
+  puts image.name
+  puts image.distribution
+end
+
+docean.flavors.each do |flavor|
+  puts flavor.slug
+end
+
+docean.regions.each do |region|
+  puts region.slug
+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

@@ -0,0 +1,17 @@
+module Fog
+  module Compute
+    class DigitalOcean
+      class Flavor < Fog::Model
+        identity  :slug
+        attribute :available
+        attribute :transfer
+        attribute :price_monthly
+        attribute :price_hourly
+        attribute :memory
+        attribute :vcpus
+        attribute :disk
+        attribute :regions
+      end
+    end
+  end
+end

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

@@ -0,0 +1,21 @@
+module Fog
+  module Compute
+    class DigitalOcean
+      class Flavors < Fog::Collection
+        model Fog::Compute::DigitalOcean::Flavor
+
+        # Retrieves flavours (aka. sizes)
+        # @return [Fog::Compute::DigitalOceanV2:Flavor]
+        # @raise [Fog::Compute::DigitalOceanV2::NotFound] - HTTP 404
+        # @raise [Fog::Compute::DigitalOceanV2::BadRequest] - HTTP 400
+        # @raise [Fog::Compute::DigitalOceanV2::InternalServerError] - HTTP 500
+        # @raise [Fog::Compute::DigitalOceanV2::ServiceError]
+        # @see https://developers.digitalocean.com/documentation/v2/#list-all-sizes
+        def all(filters = {})
+          data = service.list_flavors(filters).body["sizes"]
+          load(data)
+        end
+      end
+    end
+  end
+end