fog 1.38.0 → 1.39.0

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

@@ -1,25 +0,0 @@
-require 'fog/core/collection'
-require 'fog/dnsimple/models/dns/zone'
-
-module Fog
-  module DNS
-    class DNSimple
-      class Zones < Fog::Collection
-        model Fog::DNS::DNSimple::Zone
-
-        def all
-          clear
-          data = service.list_domains.body.map {|zone| zone['domain']}
-          load(data)
-        end
-
-        def get(zone_id)
-          data = service.get_domain(zone_id).body['domain']
-          new(data)
-        rescue Excon::Errors::NotFound
-          nil
-        end
-      end
-    end
-  end
-end

data/lib/fog/dnsimple/requests/dns/create_domain.rb

@@ -1,62 +0,0 @@
-module Fog
-  module DNS
-    class DNSimple
-      class Real
-        # Create a single domain in DNSimple in your account.
-        #
-        # ==== Parameters
-        # * name<~String> - domain name to host (ie example.com)
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'domain'<~Hash> The representation of the domain.
-        def create_domain(name)
-          body = {
-            "domain" => {
-              "name" => name
-            }
-          }
-
-          request(
-            :body     => Fog::JSON.encode(body),
-            :expects  => 201,
-            :method   => 'POST',
-            :path     => "/domains"
-          )
-        end
-      end
-
-      class Mock
-        def create_domain(name)
-          body = {
-            "domain" =>  {
-              "id"                 => Fog::Mock.random_numbers(1).to_i,
-              "user_id"            => 1,
-              "registrant_id"      => nil,
-              "name"               => name,
-              "unicode_name"       => name,
-              "token"              => "4fIFYWYiJayvL2tkf_mkBkqC4L+4RtYqDA",
-              "state"              => "registered",
-              "language"           => nil,
-              "lockable"           => true,
-              "auto_renew"         => nil,
-              "whois_protected"    => false,
-              "record_count"       => 0,
-              "service_count"      => 0,
-              "expires_on"         => Date.today + 365,
-              "created_at"         => Time.now.iso8601,
-              "updated_at"         => Time.now.iso8601,
-            }
-          }
-          self.data[:domains] << body
-
-          response = Excon::Response.new
-          response.status = 201
-          response.body = body
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/dnsimple/requests/dns/create_record.rb

@@ -1,67 +0,0 @@
-module Fog
-  module DNS
-    class DNSimple
-      class Real
-        # Create a new host in the specified zone
-        #
-        # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
-        # * name<~String>
-        # * type<~String>
-        # * content<~String>
-        # * options<~Hash> - optional
-        #   * priority<~Integer>
-        #   * ttl<~Integer>
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'record'<~Hash> The representation of the record.
-        def create_record(domain, name, type, content, options = {})
-          body = {
-            "record" => {
-              "name" => name,
-              "record_type" => type,
-              "content" => content
-            }
-          }
-
-          body["record"].merge!(options)
-
-          request(
-            :body     => Fog::JSON.encode(body),
-            :expects  => 201,
-            :method   => 'POST',
-            :path     => "/domains/#{domain}/records"
-          )
-        end
-      end
-
-      class Mock
-        def create_record(domain, name, type, content, options = {})
-          body = {
-            "record" => {
-              "id" => Fog::Mock.random_numbers(1).to_i,
-              "domain_id" => domain,
-              "name" => name,
-              "content" => content,
-              "ttl" => 3600,
-              "prio" => nil,
-              "record_type" => type,
-              "system_record" => nil,
-              "created_at" => Time.now.iso8601,
-              "updated_at" => Time.now.iso8601,
-            }.merge(options)
-          }
-          self.data[:records][domain] ||= []
-          self.data[:records][domain] << body
-
-          response = Excon::Response.new
-          response.status = 201
-          response.body = body
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/dnsimple/requests/dns/delete_domain.rb

@@ -1,35 +0,0 @@
-module Fog
-  module DNS
-    class DNSimple
-      class Real
-        # Delete the given domain from your account. You may use
-        # either the domain ID or the domain name.
-        #
-        # Please note that for domains which are registered with
-        # DNSimple this will not delete the domain from the registry.
-        #
-        # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
-        #
-        def delete_domain(domain)
-          request(
-            :expects  => 200,
-            :method   => 'DELETE',
-            :path     => "/domains/#{domain}"
-          )
-        end
-      end
-
-      class Mock
-        def delete_domain(name)
-          self.data[:records].delete name
-          self.data[:domains].reject! { |domain| domain["domain"]["name"] == name }
-
-          response = Excon::Response.new
-          response.status = 200
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/dnsimple/requests/dns/delete_record.rb

@@ -1,30 +0,0 @@
-module Fog
-  module DNS
-    class DNSimple
-      class Real
-        # Delete the record with the given ID for the given domain.
-        #
-        # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
-        # * record_id<~String>
-        def delete_record(domain, record_id)
-          request(
-            :expects  => 200,
-            :method   => "DELETE",
-            :path     => "/domains/#{domain}/records/#{record_id}"
-          )
-        end
-      end
-
-      class Mock
-        def delete_record(domain, record_id)
-          self.data[:records][domain].reject! { |record| record["record"]["id"] == record_id }
-
-          response = Excon::Response.new
-          response.status = 200
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/dnsimple/requests/dns/get_domain.rb

@@ -1,39 +0,0 @@
-module Fog
-  module DNS
-    class DNSimple
-      class Real
-        # Get the details for a specific domain in your account. You
-        # may pass either the domain numeric ID or the domain name
-        # itself.
-        #
-        # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'domain'<~Hash> The representation of the domain.
-        def get_domain(domain)
-          request(
-            :expects  => 200,
-            :method   => "GET",
-            :path     => "/domains/#{domain}"
-          )
-        end
-      end
-
-      class Mock
-        def get_domain(id)
-          domain = self.data[:domains].find do |domain|
-            domain["domain"]["id"] == id || domain["domain"]["name"] == id
-          end
-
-          response = Excon::Response.new
-          response.status = 200
-          response.body = domain
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/dnsimple/requests/dns/get_record.rb

@@ -1,49 +0,0 @@
-module Fog
-  module DNS
-    class DNSimple
-      class Real
-        # Gets record from given domain.
-        #
-        # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
-        # * record_id<~String>
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'record'<~Hash> The representation of the record.
-        def get_record(domain, record_id)
-          request(
-            :expects  => 200,
-            :method   => "GET",
-            :path     => "/domains/#{domain}/records/#{record_id}"
-          )
-        end
-      end
-
-      class Mock
-        def get_record(domain, record_id)
-          response = Excon::Response.new
-
-          if self.data[:records].key?(domain)
-            response.status = 200
-            response.body = self.data[:records][domain].find { |record| record["record"]["id"] == record_id }
-
-            if response.body.nil?
-              response.status = 404
-              response.body = {
-                "error" => "Couldn't find Record with id = #{record_id}"
-              }
-            end
-          else
-            response.status = 404
-            response.body = {
-              "error" => "Couldn't find Domain with name = #{domain}"
-            }
-          end
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/dnsimple/requests/dns/list_domains.rb

@@ -1,34 +0,0 @@
-module Fog
-  module DNS
-    class DNSimple
-      class Real
-        # Get the details for a specific domain in your account. You
-        # may pass either the domain numeric ID or the domain name itself.
-        #
-        # ==== Parameters
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * <~Array>:
-        #       * 'domain'<~Hash> The representation of the domain.
-        def list_domains
-          request(
-            :expects  => 200,
-            :method   => 'GET',
-            :path     => '/domains'
-          )
-        end
-      end
-
-      class Mock
-        def list_domains
-          response = Excon::Response.new
-          response.status = 200
-          response.body = self.data[:domains]
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/dnsimple/requests/dns/list_records.rb

@@ -1,34 +0,0 @@
-module Fog
-  module DNS
-    class DNSimple
-      class Real
-        # Get the list of records for the specific domain.
-        #
-        # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * <~Array>:
-        #       * 'record'<~Hash> The representation of the record.
-        def list_records(domain)
-          request(
-            :expects  => 200,
-            :method   => "GET",
-            :path     => "/domains/#{domain}/records"
-          )
-        end
-      end
-
-      class Mock
-        def list_records(domain)
-          response = Excon::Response.new
-          response.status = 200
-          response.body = self.data[:records][domain] || []
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/dnsimple/requests/dns/update_record.rb

@@ -1,53 +0,0 @@
-module Fog
-  module DNS
-    class DNSimple
-      class Real
-        # Update the given record for the given domain.
-        #
-        # ==== Parameters
-        # * domain<~String> - domain name or numeric ID
-        # * record_id<~String>
-        # * options<~Hash> - optional
-        #   * type<~String>
-        #   * content<~String>
-        #   * priority<~Integer>
-        #   * ttl<~Integer>
-        #
-        # ==== Returns
-        # * response<~Excon::Response>:
-        #   * body<~Hash>:
-        #     * 'record'<~Hash> The representation of the record.
-        def update_record(domain, record_id, options)
-          body = {
-            "record" => options
-          }
-
-          request(
-            :body     => Fog::JSON.encode(body),
-            :expects  => 200,
-            :method   => "PUT",
-            :path     => "/domains/#{domain}/records/#{record_id}"
-          )
-        end
-      end
-
-      class Mock
-        def update_record(domain, record_id, options)
-          record = self.data[:records][domain].find { |record| record["record"]["id"] == record_id }
-          response = Excon::Response.new
-
-          if record.nil?
-            response.status = 400
-          else
-            response.status = 200
-            record["record"].merge!(options)
-            record["record"]["updated_at"] = Time.now.iso8601
-            response.body = record
-          end
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/ninefold.rb

@@ -1 +0,0 @@
-require 'fog/ninefold/compute'

data/lib/fog/ninefold/compute.rb

@@ -1,144 +0,0 @@
-require 'fog/ninefold/core'
-
-module Fog
-  module Compute
-    class Ninefold < Fog::Service
-      API_URL = "http://api.ninefold.com/compute/v1.0/"
-
-      requires :ninefold_compute_key, :ninefold_compute_secret
-      recognizes :ninefold_api_url  # allow us to specify non-prod environments
-
-      model_path 'fog/ninefold/models/compute'
-      model       :server
-      collection  :servers
-      model       :flavor
-      collection  :flavors
-      model       :image
-      collection  :images
-      model       :address
-      collection  :addresses
-      model       :ip_forwarding_rule
-      collection  :ip_forwarding_rules
-
-      request_path 'fog/ninefold/requests/compute'
-      # General list-only stuff
-      request :list_accounts
-      request :list_events
-      request :list_service_offerings
-      request :list_disk_offerings
-      request :list_capabilities
-      request :list_hypervisors
-      request :list_zones
-      request :list_network_offerings
-      request :list_resource_limits
-      # Templates
-      request :list_templates
-      # Virtual Machines
-      request :deploy_virtual_machine
-      request :destroy_virtual_machine
-      request :list_virtual_machines
-      request :reboot_virtual_machine
-      request :stop_virtual_machine
-      request :start_virtual_machine
-      request :change_service_for_virtual_machine
-      request :reset_password_for_virtual_machine
-      request :update_virtual_machine
-      # Jobs
-      request :list_async_jobs
-      request :query_async_job_result
-      # Networks
-      request :list_networks
-      # Addresses
-      request :associate_ip_address
-      request :list_public_ip_addresses
-      request :disassociate_ip_address
-      # NAT
-      request :enable_static_nat
-      request :disable_static_nat
-      request :create_ip_forwarding_rule
-      request :delete_ip_forwarding_rule
-      request :list_ip_forwarding_rules
-      # Load Balancers
-      request :create_load_balancer_rule
-      request :delete_load_balancer_rule
-      request :remove_from_load_balancer_rule
-      request :assign_to_load_balancer_rule
-      request :list_load_balancer_rules
-      request :list_load_balancer_rule_instances
-      request :update_load_balancer_rule
-
-      class Mock
-        def initialize(options)
-          @api_url = options[:ninefold_api_url] || API_URL
-          @ninefold_compute_key = options[:ninefold_compute_key]
-          @ninefold_compute_secret = options[:ninefold_compute_secret]
-        end
-
-        def request(options)
-          raise "Not implemented"
-        end
-      end
-
-      class Real
-        def initialize(options)
-          @api_url                  = options[:ninefold_api_url] || API_URL
-          @ninefold_compute_key     = options[:ninefold_compute_key]
-          @ninefold_compute_secret  = options[:ninefold_compute_secret]
-          @connection_options       = options[:connection_options] || {}
-          @persistent               = options[:persistent] || false
-          @connection = Fog::XML::Connection.new(@api_url, @persistent, @connection_options)
-        end
-
-        def request(command, params, options)
-          params['response'] = "json"
-          # convert params to strings for sort
-          req_params = params.merge('apiKey' => @ninefold_compute_key, 'command' => command)
-          req = URI.escape(req_params.sort_by{|k,v| k.to_s }.map{|e| "#{e[0].to_s}=#{e[1].to_s}"}.join('&'))
-          encoded_signature = url_escape(encode_signature(req))
-
-          options = {
-            :expects => 200,
-            :method => 'GET',
-            :query => "#{req}&signature=#{encoded_signature}"
-          }.merge(options)
-
-          begin
-            response = @connection.request(options)
-          end
-          unless response.body.empty?
-            # Because the response is some weird xml-json thing, we need to try and mung
-            # the values out with a prefix, and if there is an empty data entry return an
-            # empty version of the expected type (if provided)
-            response = Fog::JSON.decode(response.body)
-            if options.key? :response_prefix
-              keys = options[:response_prefix].split('/')
-              keys.each do |k|
-                if response[k]
-                  response = response[k]
-                elsif options[:response_type]
-                  response = options[:response_type].new
-                  break
-                else
-                end
-              end
-              response
-            else
-              response
-            end
-          end
-        end
-
-        private
-        def url_escape(string)
-          string.gsub(/([^ a-zA-Z0-9_.-]+)/n) do
-            '%' + $1.unpack('H2' * $1.size).join('%').upcase
-          end.tr(' ', '+')
-        end
-
-        def encode_signature(data)
-          Base64.encode64(OpenSSL::HMAC.digest('sha1', @ninefold_compute_secret, URI.encode(data.downcase).gsub('+', '%20'))).chomp
-        end
-      end
-    end
-  end
-end