fog 1.38.0 → 1.39.0

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

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

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

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

@@ -1,51 +0,0 @@
-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/dnsimple.rb

@@ -1 +0,0 @@
-require 'fog/dnsimple/dns'

data/lib/fog/dnsimple/core.rb

@@ -1,10 +0,0 @@
-require 'fog/core'
-require 'fog/json'
-
-module Fog
-  module DNSimple
-    extend Fog::Provider
-
-    service(:dns, 'DNS')
-  end
-end

data/lib/fog/dnsimple/dns.rb

@@ -1,112 +0,0 @@
-require 'fog/dnsimple/core'
-
-module Fog
-  module DNS
-    class DNSimple < Fog::Service
-      recognizes :dnsimple_email, :dnsimple_password, :dnsimple_token, :dnsimple_domain, :dnsimple_url, :host, :path, :port, :scheme, :persistent
-
-      model_path 'fog/dnsimple/models/dns'
-      model       :record
-      collection  :records
-      model       :zone
-      collection  :zones
-
-      request_path 'fog/dnsimple/requests/dns'
-      request :list_domains
-      request :create_domain
-      request :get_domain
-      request :delete_domain
-      request :create_record
-      request :list_records
-      request :update_record
-      request :delete_record
-      request :get_record
-
-      class Mock
-        def self.data
-          @data ||= Hash.new do |hash, key|
-            hash[key] = {
-              :domains => [],
-              :records => {}
-            }
-          end
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def initialize(options={})
-          @dnsimple_email = options[:dnsimple_email]
-          @dnsimple_password  = options[:dnsimple_password]
-          @dnsimple_token = options[:dnsimple_token]
-          @dnsimple_domain = options[:dnsimple_domain]
-        end
-
-        def data
-          self.class.data[@dnsimple_email]
-        end
-
-        def reset_data
-          self.class.data.delete(@dnsimple_email)
-        end
-      end
-
-      class Real
-        def initialize(options={})
-          @dnsimple_email = options[:dnsimple_email]
-          @dnsimple_password  = options[:dnsimple_password]
-          @dnsimple_token = options[:dnsimple_token]
-          @dnsimple_domain = options[:dnsimple_domain]
-          @connection_options = options[:connection_options] || {}
-          if options[:dnsimple_url]
-            uri = URI.parse(options[:dnsimple_url])
-            options[:host]    = uri.host
-            options[:port]    = uri.port
-            options[:scheme]  = uri.scheme
-          end
-          @host       = options[:host]        || "api.dnsimple.com"
-          @persistent = options[:persistent]  || false
-          @port       = options[:port]        || 443
-          @scheme     = options[:scheme]      || 'https'
-          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
-        end
-
-        def reload
-          @connection.reset
-        end
-
-        def request(params)
-          params[:headers] ||= {}
-
-          if(@dnsimple_password)
-            key = "#{@dnsimple_email}:#{@dnsimple_password}"
-            params[:headers].merge!("Authorization" => "Basic " + Base64.encode64(key).gsub("\n",''))
-          elsif(@dnsimple_token)
-            if(@dnsimple_domain)
-              params[:headers].merge!("X-DNSimple-Domain-Token" => @dnsimple_token)
-            else
-              params[:headers].merge!("X-DNSimple-Token" => "#{@dnsimple_email}:#{@dnsimple_token}")
-            end
-          else
-            raise ArgumentError.new("Insufficient credentials to properly authenticate!")
-          end
-          params[:headers].merge!(
-            "Accept" => "application/json",
-            "Content-Type" => "application/json"
-          )
-
-          version = params.delete(:version) || 'v1'
-          params[:path] = File.join('/', version, params[:path])
-
-          response = @connection.request(params)
-
-          unless response.body.empty?
-            response.body = Fog::JSON.decode(response.body)
-          end
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/dnsimple/models/dns/record.rb

@@ -1,63 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module DNS
-    class DNSimple
-      class Record < Fog::Model
-        extend Fog::Deprecation
-        deprecate :ip, :value
-        deprecate :ip=, :value=
-
-        identity :id
-
-        attribute :zone_id,     :aliases => "domain_id"
-        attribute :name
-        attribute :value,       :aliases => "content"
-        attribute :ttl
-        attribute :priority,    :aliases => "prio"
-        attribute :type,        :aliases => "record_type"
-        attribute :created_at
-        attribute :updated_at
-
-        def initialize(attributes={})
-          super
-        end
-
-        def destroy
-          service.delete_record(zone.id, identity)
-          true
-        end
-
-        def zone
-          @zone
-        end
-
-        def save
-          requires :name, :type, :value
-          options = {}
-          options[:prio] = priority if priority
-          options[:ttl]  = ttl if ttl
-
-          # decide whether its a new record or update of an existing
-          if id.nil?
-            data = service.create_record(zone.id, name, type, value, options)
-          else
-            options[:name] = name if name
-            options[:content] = value if value
-            options[:type] = type if type
-            data = service.update_record(zone.id, id, options)
-          end
-
-          merge_attributes(data.body["record"])
-          true
-        end
-
-        private
-
-        def zone=(new_zone)
-          @zone = new_zone
-        end
-      end
-    end
-  end
-end

data/lib/fog/dnsimple/models/dns/records.rb

@@ -1,34 +0,0 @@
-require 'fog/core/collection'
-require 'fog/dnsimple/models/dns/record'
-
-module Fog
-  module DNS
-    class DNSimple
-      class Records < Fog::Collection
-        attribute :zone
-
-        model Fog::DNS::DNSimple::Record
-
-        def all
-          requires :zone
-          clear
-          data = service.list_records(zone.id).body.map {|record| record['record']}
-          load(data)
-        end
-
-        def get(record_id)
-          requires :zone
-          data = service.get_record(zone.id, record_id).body["record"]
-          new(data)
-        rescue Excon::Errors::NotFound
-          nil
-        end
-
-        def new(attributes = {})
-          requires :zone
-          super({ :zone => zone }.merge!(attributes))
-        end
-      end
-    end
-  end
-end

data/lib/fog/dnsimple/models/dns/zone.rb

@@ -1,46 +0,0 @@
-require 'fog/core/model'
-require 'fog/dnsimple/models/dns/records'
-
-module Fog
-  module DNS
-    class DNSimple
-      class Zone < Fog::Model
-        identity :id
-
-        attribute :domain,     :aliases => 'name'
-        attribute :created_at
-        attribute :updated_at
-
-        def destroy
-          service.delete_domain(identity)
-          true
-        end
-
-        def records
-          @records ||= begin
-            Fog::DNS::DNSimple::Records.new(
-              :zone       => self,
-              :service => service
-            )
-          end
-        end
-
-        def nameservers
-          [
-           "ns1.dnsimple.com",
-           "ns2.dnsimple.com",
-           "ns3.dnsimple.com",
-           "ns4.dnsimple.com",
-          ]
-        end
-
-        def save
-          requires :domain
-          data = service.create_domain(domain).body["domain"]
-          merge_attributes(data)
-          true
-        end
-      end
-    end
-  end
-end