fog 1.31.0 → 1.37.0

data/lib/fog/digitalocean/requests/compute_v2/resize.rb

@@ -0,0 +1,48 @@
+module Fog
+  module Compute
+    class DigitalOceanV2
+      class Real
+        def resize(id, resize_disk, size)
+          body = {
+            :type => "resize",
+            :disk => resize_disk,
+            :size => size
+          }
+
+          encoded_body = Fog::JSON.encode(body)
+
+          request(
+            :expects => [201],
+            :headers => {
+              'Content-Type' => "application/json; charset=UTF-8",
+            },
+            :method  => 'POST',
+            :path    => "v2/droplets/#{id}/actions",
+            :body    => encoded_body,
+          )
+        end
+      end
+
+      class Mock
+        def resize(id, resize_disk, size)
+          response        = Excon::Response.new
+          response.status = 201
+          response.body   = {
+            'action' => {
+              'id'            => Fog::Mock.random_numbers(1).to_i,
+              'status'        => "in-progress",
+              'type'          => "resize",
+              'started_at'    => "2014-11-14T16:31:00Z",
+              'completed_at'  => null,
+              'resource_id'   => id,
+              'resource_type' => "droplet",
+              'region'        => "nyc3",
+              'region_slug'   => "nyc3"
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/requests/compute_v2/restore.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class DigitalOceanV2
+      class Real
+        def restore(id, image)
+          body = { :type => "restore", :image => image }
+
+          encoded_body = Fog::JSON.encode(body)
+
+          request(
+            :expects => [201],
+            :headers => {
+              'Content-Type' => "application/json; charset=UTF-8",
+            },
+            :method  => 'POST',
+            :path    => "v2/droplets/#{id}/actions",
+            :body    => encoded_body,
+          )
+        end
+      end
+
+      class Mock
+        def restore(id, image)
+          response         = Excon::Response.new
+          response.status  = 201
+          response.body    = {
+            'action' => {
+              'id'            => Fog::Mock.random_numbers(1).to_i,
+              'status'        => "in-progress",
+              'type'          => "restore",
+              'started_at'    => "2014-11-14T16:31:00Z",
+              'completed_at'  => null,
+              'resource_id'   => id,
+              'resource_type' => "droplet",
+              'region'        => "nyc3",
+              'region_slug'   => "nyc3"
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/requests/compute_v2/shutdown.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class DigitalOceanV2
+      class Real
+        def shutdown(id)
+          body = { :type => "shutdown" }
+
+          encoded_body = Fog::JSON.encode(body)
+
+          request(
+            :expects => [201],
+            :headers => {
+              'Content-Type' => "application/json; charset=UTF-8",
+            },
+            :method  => 'POST',
+            :path    => "v2/droplets/#{id}/actions",
+            :body    => encoded_body,
+          )
+        end
+      end
+
+      class Mock
+        def shutdown(id)
+          response         = Excon::Response.new
+          response.status  = 201
+          response.body    = {
+            'action' => {
+              'id'            => Fog::Mock.random_numbers(1).to_i,
+              'status'        => "in-progress",
+              'type'          => "shutdown",
+              'started_at'    => "2014-11-14T16:31:00Z",
+              'completed_at'  => null,
+              'resource_id'   => id,
+              'resource_type' => "droplet",
+              'region'        => "nyc3",
+              'region_slug'   => "nyc3"
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/requests/compute_v2/snapshot.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class DigitalOceanV2
+      class Real
+        def snapshot(id, name)
+          body = { :type => "snapshot", :name => name }
+
+          encoded_body = Fog::JSON.encode(body)
+
+          request(
+            :expects => [201],
+            :headers => {
+              'Content-Type' => "application/json; charset=UTF-8",
+            },
+            :method  => 'POST',
+            :path    => "v2/droplets/#{id}/actions",
+            :body    => encoded_body,
+          )
+        end
+      end
+
+      class Mock
+        def snapshot(id, name)
+          response         = Excon::Response.new
+          response.status  = 201
+          response.body    = {
+            'action' => {
+              'id'            => Fog::Mock.random_numbers(1).to_i,
+              'status'        => "in-progress",
+              'type'          => "snapshot",
+              'started_at'    => "2014-11-14T16:31:00Z",
+              'completed_at'  => null,
+              'resource_id'   => id,
+              'resource_type' => "droplet",
+              'region'        => "nyc3",
+              'region_slug'   => "nyc3"
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/requests/compute_v2/transfer_image.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class DigitalOceanV2
+      class Real
+        def transfer_image(id, region)
+          body = { :type => 'transfer', :region => region }
+
+          encoded_body = Fog::JSON.encode(body)
+
+          request(
+            :expects => [201],
+            :headers => {
+              'Content-Type' => "application/json; charset=UTF-8",
+            },
+            :method  => 'POST',
+            :path    => "v2/images/#{id}/actions",
+            :body    => encoded_body,
+          )
+        end
+      end
+
+      class Mock
+        def transfer_image(id, name)
+          response         = Excon::Response.new
+          response.status  = 201
+          response.body    = {
+            'action' => {
+              'id' => 36805527,
+              'status' => 'in-progress',
+              'type' => 'transfer',
+              'started_at' => '2014-11-14T16:42:45Z',
+              'completed_at' => null,
+              'resource_id' => 7938269,
+              'resource_type' => 'image',
+              'region' => 'nyc3',
+              'region_slug' => 'nyc3'
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/requests/compute_v2/update_ssh_key.rb

@@ -0,0 +1,46 @@
+module Fog
+  module Compute
+    class DigitalOceanV2
+      # noinspection RubyStringKeysInHashInspection
+      class Real
+
+        def update_ssh_key(key_id, name)
+          update_options = {
+            :name       => name,
+          }
+
+          encoded_body = Fog::JSON.encode(update_options)
+
+          request(
+            :expects => [200],
+            :headers => {
+              'Content-Type' => "application/json; charset=UTF-8",
+            },
+            :method  => 'PUT',
+            :path    => "/v2/account/keys/#{key_id}",
+            :body    => encoded_body,
+          )
+        end
+      end
+
+      # noinspection RubyStringKeysInHashInspection
+      class Mock
+        def update_ssh_key(key_id, name)
+          response        = Excon::Response.new
+          response.status = 200
+
+          response.body ={
+            'ssh_key' => {
+              'id'          => 512190,
+              'fingerprint' => "3b:16:bf:e4:8b:00:8b:b8:59:8c:a9:d3:f0:19:45:fa",
+              'public_key'  => "ssh-rsa AAAAB3NzaC1yc2EAAAADAQABAAAAQQDDHr/jh2Jy4yALcK4JyWbVkPRaWmhck3IgCoeOO3z1e2dBowLh64QAM+Qb72pxekALga2oi4GvT+TlWNhzPH4V example",
+              'name'        => "My SSH Public Key"
+            }
+          }
+
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/requests/compute_v2/upgrade.rb

@@ -0,0 +1,44 @@
+module Fog
+  module Compute
+    class DigitalOceanV2
+      class Real
+        def upgrade(id)
+          body = { :type => "upgrade" }
+
+          encoded_body = Fog::JSON.encode(body)
+
+          request(
+            :expects => [201],
+            :headers => {
+              'Content-Type' => "application/json; charset=UTF-8",
+            },
+            :method  => 'POST',
+            :path    => "v2/droplets/#{id}/actions",
+            :body    => encoded_body,
+          )
+        end
+      end
+
+      class Mock
+        def upgrade(id)
+          response         = Excon::Response.new
+          response.status  = 201
+          response.body    = {
+            'action' => {
+              'id'            => Fog::Mock.random_numbers(1).to_i,
+              'status'        => "in-progress",
+              'type'          => "upgrade",
+              'started_at'    => "2014-11-14T16:31:00Z",
+              'completed_at'  => null,
+              'resource_id'   => id,
+              'resource_type' => "droplet",
+              'region'        => "nyc3",
+              'region_slug'   => "nyc3"
+            }
+          }
+          response
+        end
+      end
+    end
+  end
+end

data/lib/fog/digitalocean/service.rb

@@ -0,0 +1,51 @@
+module Fog
+  module DigitalOcean
+    class Service
+
+      def request(params, parse_json = true)
+        first_attempt = true
+        begin
+          response = @connection.request(request_params(params))
+        rescue Excon::Errors::Unauthorized => error
+          raise error unless first_attempt
+          first_attempt = false
+          authenticate
+          retry
+        end
+
+        process_response(response) if parse_json
+        response
+      end
+
+      private
+
+      def process_response(response)
+        if response &&
+          response.body &&
+          response.body.is_a?(String) &&
+          !response.body.strip.empty?
+          begin
+            response.body = Fog::JSON.decode(response.body)
+          rescue Fog::JSON::DecodeError => e
+            Fog::Logger.warning("Error Parsing response json - #{e}")
+            response.body = {}
+          end
+        end
+      end
+
+      def headers(options={})
+        {'Content-Type' => 'application/json',
+         'Accept'       => 'application/json',
+        }.merge(options[:headers] || {})
+      end
+
+      def request_params(params)
+        params.merge({
+                       :headers => headers(params),
+                       :path    => "#{params[:path]}"
+                     })
+      end
+
+    end
+  end
+end

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

@@ -90,7 +90,6 @@ module Fog
 
         def setup(credentials = {})
           requires :ssh_ip_address, :username
-          require 'net/ssh'
 
           attrs = attributes.dup
           attrs.delete(:rootpassword)

data/lib/fog/joyent/compute.rb

@@ -1,6 +1,5 @@
 require 'fog/joyent/core'
 require 'fog/joyent/errors'
-require 'net/ssh'
 
 module Fog
   module Compute
@@ -126,6 +125,12 @@ module Fog
           end
 
           if options[:joyent_keyname]
+            begin
+              require "net/ssh"
+            rescue LoadError
+              Fog::Logger.warning("'net/ssh' missing, please install and try again.")
+              exit(1)
+            end
             @joyent_keyname = options[:joyent_keyname]
             @joyent_keyphrase = options[:joyent_keyphrase]
             @key_manager = Net::SSH::Authentication::KeyManager.new(nil, {

data/lib/fog/linode/compute.rb

@@ -23,12 +23,15 @@ module Fog
       collection :ips
       model :disk
       collection :disks
+      model :node_balancer_flavor
+      collection :node_balancer_flavors
 
       request_path 'fog/linode/requests/compute'
       request :avail_datacenters
       request :avail_distributions
       request :avail_kernels
       request :avail_linodeplans
+      request :avail_nodebalancers
       request :avail_stackscripts
       request :linode_disk_create
       request :linode_disk_list

data/lib/fog/linode/models/compute/data_center.rb

@@ -6,6 +6,7 @@ module Fog
       class DataCenter < Fog::Model
         identity :id
         attribute :location
+        attribute :abbr
       end
     end
   end

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

@@ -8,8 +8,11 @@ module Fog
         attribute :disk
         attribute :name
         attribute :ram
+        attribute :transfer
         attribute :price
+        attribute :price_hourly
         attribute :cores
+        attribute :available
 
         def bits
           0 # these are determined by images you select not the hardware

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

@@ -24,7 +24,14 @@ module Fog
 
         def map_flavor(flavor)
           flavor = flavor.each_with_object({}) { |(k, v), h| h[k.downcase.to_sym] = v  }
-          flavor.merge! :id => flavor[:planid], :name => flavor[:label]
+          flavor.merge! :id => flavor[:planid], :name => flavor[:label],
+                        :transfer => flavor[:xfer], :price_hourly => flavor[:hourly],
+                        :available => map_available(flavor[:avail])
+        end
+
+        def map_available(available)
+          return nil unless available
+          available.each_with_object({}) { |(k, v), h| h[k.to_i] = v }
         end
       end
     end

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

@@ -8,6 +8,8 @@ module Fog
         attribute :name
         attribute :bits
         attribute :image_size
+        attribute :created_at, types: 'time'
+        attribute :requires_pvops_kernel
       end
     end
   end

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

@@ -25,7 +25,8 @@ module Fog
         def map_image(image)
           image = image.each_with_object({}) { |(k, v), h| h[k.downcase.to_sym] = v  }
           image.merge!(:id => image[:distributionid], :name => image[:label], :image_size => image[:minimagesize],
-                       :kernel_id => image[:requirespvopskernel], :bits => ((image[:is64bit] == 1) ? 64 : 32 ))
+                       :requires_pvops_kernel => image[:requirespvopskernel], :bits => ((image[:is64bit] == 1) ? 64 : 32 ),
+                       :created_at => image[:create_dt])
         end
       end
     end

data/lib/fog/linode/models/compute/kernel.rb

@@ -6,6 +6,9 @@ module Fog
       class Kernel < Fog::Model
         identity :id
         attribute :name
+        attribute :is_xen
+        attribute :is_kvm
+        attribute :is_pvops
       end
     end
   end

data/lib/fog/linode/models/compute/kernels.rb

@@ -7,24 +7,30 @@ module Fog
       class Kernels < Fog::Collection
         model Fog::Compute::Linode::Kernel
 
-        def all
-          load kernels
+        # Returns an Array of the available kernels.
+        #
+        # The list of kernels can be filtered by support for KVM or Xen by
+        # specifying kvm: true or xen: true respectively as options.
+        def all(options={})
+          [[:kvm, :isKVM], [:xen, :isXen]].each do |type, param|
+            options[param] = options[type] ? 1 : 0 if options.has_key?(type)
+          end
+          load kernels(options)
         end
 
         def get(id)
-          new kernels(id).first
-        rescue Fog::Compute::Linode::NotFound
-          nil
+          new kernels.select {|kernel| kernel[:id] == id }.first
         end
 
         private
-        def kernels(id=nil)
-          service.avail_kernels(id).body['DATA'].map { |kernel| map_kernel kernel }
+        def kernels(options={})
+          service.avail_kernels(options).body['DATA'].map { |kernel| map_kernel kernel }
         end
 
         def map_kernel(kernel)
           kernel = kernel.each_with_object({}) { |(k, v), h| h[k.downcase.to_sym] = v  }
-          kernel.merge! :id => kernel[:kernelid], :name => kernel[:label]
+          kernel.merge! :id => kernel[:kernelid], :name => kernel[:label],
+                        :is_xen => kernel[:isxen], :is_kvm => kernel[:iskvm], :is_pvops => kernel[:ispvops]
         end
       end
     end

data/lib/fog/linode/models/compute/node_balancer_flavor.rb

@@ -0,0 +1,13 @@
+require 'fog/core/model'
+
+module Fog
+  module Compute
+    class Linode
+      class NodeBalancerFlavor < Fog::Model
+        attribute :price_monthly
+        attribute :price_hourly
+        attribute :connections
+      end
+    end
+  end
+end

data/lib/fog/linode/models/compute/node_balancer_flavors.rb

@@ -0,0 +1,27 @@
+require 'fog/core/collection'
+require 'fog/linode/models/compute/node_balancer_flavor'
+
+module Fog
+  module Compute
+    class Linode
+      class NodeBalancerFlavors < Fog::Collection
+        model Fog::Compute::Linode::NodeBalancerFlavor
+
+        def all
+          load node_balancer_flavors
+        end
+
+        private
+        def node_balancer_flavors
+          service.avail_nodebalancers.body['DATA'].map { |node_balancer_flavor| map_node_balancer_flavor node_balancer_flavor }
+        end
+
+        def map_node_balancer_flavor(node_balancer_flavor)
+          node_balancer_flavor = node_balancer_flavor.each_with_object({}) { |(k, v), h| h[k.downcase.to_sym] = v  }
+          node_balancer_flavor.merge! :price_monthly => node_balancer_flavor[:monthly],
+                                      :price_hourly => node_balancer_flavor[:hourly]
+        end
+      end
+    end
+  end
+end

data/lib/fog/linode/requests/compute/avail_datacenters.rb

@@ -24,13 +24,14 @@ module Fog
           response.body = {
             "ERRORARRAY" => [],
             "DATA" => [
-              { "LOCATION" => "Dallas, TX, USA",     "DATACENTERID" => 2 },
-              { "LOCATION" => "Fremont, CA, USA",    "DATACENTERID" => 3 },
-              { "LOCATION" => "Atlanta, GA, USA",    "DATACENTERID" => 4 },
-              { "LOCATION" => "Newark, NJ, USA",     "DATACENTERID" => 6 },
-              { "LOCATION" => "London, England, UK", "DATACENTERID" => 7 },
-              { "LOCATION" => "Tokyo, JP",           "DATACENTERID" => 8 },
-              { "LOCATION" => "Singapore, SGP",      "DATACENTERID" => 9 },
+              { "LOCATION" => "Dallas, TX, USA",     "DATACENTERID" => 2,  "ABBR" => "dallas" },
+              { "LOCATION" => "Fremont, CA, USA",    "DATACENTERID" => 3,  "ABBR" => "fremont" },
+              { "LOCATION" => "Atlanta, GA, USA",    "DATACENTERID" => 4,  "ABBR" => "atlanta" },
+              { "LOCATION" => "Newark, NJ, USA",     "DATACENTERID" => 6,  "ABBR" => "newark" },
+              { "LOCATION" => "London, England, UK", "DATACENTERID" => 7,  "ABBR" => "london" },
+              { "LOCATION" => "Tokyo, JP",           "DATACENTERID" => 8,  "ABBR" => "tokyo" },
+              { "LOCATION" => "Singapore, SGP",      "DATACENTERID" => 9,  "ABBR" => "singapore" },
+              { "LOCATION" => "Frankfurt, DE",       "DATACENTERID" => 10, "ABBR" => "frankfurt" },
             ],
             "ACTION" => "avail.datacenters"
           }

data/lib/fog/linode/requests/compute/avail_kernels.rb

@@ -5,27 +5,30 @@ module Fog
         # Get available kernels
         #
         # ==== Parameters
-        # * kernelId<~Integer>: id to limit results to
+        # * options<~Hash>
+        #   * isXen<~Boolean> Show or hide Xen compatible kernels
+        #   * isKVM<~Boolean> Show or hide KVM compatible kernels
         #
         # ==== Returns
         # * response<~Excon::Response>:
         #   * body<~Array>:
         # TODO: docs
-        def avail_kernels(kernel_id=nil)
-          options = {}
-          if kernel_id
-            options.merge!(:kernelId => kernel_id)
-          end
+        def avail_kernels(options={})
+          # avail.kernels used to accept a kernelId parameter (now removed)
+          raise Fog::Errors::Error.new('avail_kernels no longer accepts a kernelId parameter') unless !options || options.is_a?(Hash)
           request(
             :expects  => 200,
             :method   => 'GET',
-            :query    => { :api_action => 'avail.kernels' }.merge!(options)
+            :query    => { :api_action => 'avail.kernels' }.merge!(options || {})
           )
         end
       end
 
       class Mock
-        def avail_kernels(kernel_id=nil)
+        def avail_kernels(options={})
+          # avail.kernels used to accept a kernelId parameter (now removed)
+          raise Fog::Errors::Error.new('avail_kernels no longer accepts a kernelId parameter') unless !options || options.is_a?(Hash)
+
           response = Excon::Response.new
           response.status = 200
 
@@ -33,17 +36,12 @@ module Fog
             "ERRORARRAY" => [],
             "ACTION" => "avail.kernels"
           }
-          if kernel_id
-            mock_kernel = create_mock_kernel(kernel_id)
-            response.body = body.merge("DATA" => [mock_kernel])
-          else
-            mock_kernels = []
-            10.times do
-              kernel_id = rand(1..200)
-              mock_kernels << create_mock_kernel(kernel_id)
-            end
-            response.body = body.merge("DATA" => mock_kernels)
+          mock_kernels = []
+          10.times do
+            kernel_id = rand(1..200)
+            mock_kernels << create_mock_kernel(kernel_id)
           end
+          response.body = body.merge("DATA" => mock_kernels)
           response
         end
 
@@ -53,6 +51,7 @@ module Fog
           {
             "ISPVOPS"  => 1,
             "ISXEN"    => 1,
+            "ISKVM"    => 1,
             "KERNELID" => kernel_id,
             "LABEL"    => "Latest 3.0 (3.0.18-linode43)"
           }