fog 1.31.0 → 1.37.0

data/gemfiles/Gemfile-ruby-1.8.7

@@ -1,17 +0,0 @@
-source "https://rubygems.org"
-
-gem 'activesupport', '~> 3.2'
-gem 'nokogiri', '~>1.5.11'
-gem 'mime-types', '~>1.16'
-gem 'rest-client', '~> 1.6.7'
-gem 'i18n', '~> 0.6.11'
-
-group :development, :test do
-  # This is here because gemspec doesn't support require: false
-  gem 'coveralls', :require => false
-  gem "netrc", :require => false
-  gem "octokit", '~> 2.7.2', :require => false
-  gem 'rake', '~> 10.1.0'
-end
-
-gemspec :path => "../"

data/lib/fog/bin/dynect.rb

@@ -1,28 +0,0 @@
-class Dynect < Fog::Bin
-  class << self
-    def class_for(key)
-      case key
-      when :dns
-        Fog::DNS::Dynect
-      else
-        raise ArgumentError, "Unrecognized service: #{key}"
-      end
-    end
-
-    def [](service)
-      @@connections ||= Hash.new do |hash, key|
-        hash[key] = case key
-        when :dns
-          Fog::DNS.new(:provider => 'Dynect')
-        else
-          raise ArgumentError, "Unrecognized service: #{service}"
-        end
-      end
-      @@connections[service]
-    end
-
-    def services
-      [:dns]
-    end
-  end
-end

data/lib/fog/bin/vsphere.rb

@@ -1,28 +0,0 @@
-class Vsphere < Fog::Bin
-  class << self
-    def class_for(key)
-      case key
-      when :compute
-        Fog::Compute::Vsphere
-      else
-        raise ArgumentError, "Unrecognized service: #{key}"
-      end
-    end
-
-    def [](service)
-      @@connections ||= Hash.new do |hash, key|
-        hash[key] = case key
-        when :compute
-          Fog::Compute.new(:provider => 'Vsphere')
-        else
-          raise ArgumentError, "Unrecognized service: #{key.inspect}"
-        end
-      end
-      @@connections[service]
-    end
-
-    def services
-      Fog::Vsphere.services
-    end
-  end
-end

data/lib/fog/bin/xenserver.rb

@@ -1,29 +0,0 @@
-class XenServer < Fog::Bin
-  class << self
-    def class_for(key)
-      case key
-      when :compute
-        Fog::Compute::XenServer
-      else
-        raise ArgumentError, "Unrecognized service: #{key}"
-      end
-    end
-
-    def [](service)
-      @@connections ||= Hash.new do |hash, key|
-        hash[key] = case key
-        when :compute
-          Fog::Logger.warning("XenServer[:compute] is not recommended, use Compute[:xenserver] for portability")
-          Fog::Compute.new(:provider => 'XenServer')
-        else
-          raise ArgumentError, "Unrecognized service: #{key.inspect}"
-        end
-      end
-      @@connections[service]
-    end
-
-    def services
-      Fog::XenServer.services
-    end
-  end
-end

data/lib/fog/dynect/core.rb

@@ -1,26 +0,0 @@
-require 'nokogiri'
-
-require 'fog/core'
-require 'fog/xml'
-
-module Fog
-  module Dynect
-    extend Fog::Provider
-
-    service(:dns, 'DNS')
-
-    class Mock
-      def self.job_id
-        Fog::Mock.random_numbers(8).to_i
-      end
-
-      def self.token
-        Fog::Mock.random_hex(48)
-      end
-
-      def self.version
-        [Fog::Mock.random_numbers(1), Fog::Mock.random_numbers(1), Fog::Mock.random_numbers(1)].join('.')
-      end
-    end
-  end
-end

data/lib/fog/dynect/dns.rb

@@ -1,157 +0,0 @@
-require 'fog/dynect/core'
-
-module Fog
-  module DNS
-    class Dynect < Fog::Service
-      requires :dynect_customer, :dynect_username, :dynect_password
-      recognizes :timeout, :persistent, :job_poll_timeout
-      recognizes :provider # remove post deprecation
-
-      model_path 'fog/dynect/models/dns'
-      model       :record
-      collection  :records
-      model       :zone
-      collection  :zones
-
-      request_path 'fog/dynect/requests/dns'
-      request :delete_record
-      request :delete_zone
-      request :get_node_list
-      request :get_all_records
-      request :get_record
-      request :get_zone
-      request :post_record
-      request :post_session
-      request :post_zone
-      request :put_zone
-      request :put_record
-
-      class JobIncomplete < Error; end
-
-      class Mock
-        def initialize(options={})
-          @dynect_customer = options[:dynect_customer]
-          @dynect_username = options[:dynect_username]
-          @dynect_password = options[:dynect_password]
-        end
-
-        def self.data
-          @data ||= {
-            :zones => {}
-          }
-        end
-
-        def self.reset
-          @data = nil
-        end
-
-        def auth_token
-          @auth_token ||= Fog::Dynect::Mock.token
-        end
-
-        def data
-          self.class.data
-        end
-
-        def reset_data
-          self.class.reset
-        end
-      end
-
-      class Real
-        def initialize(options={})
-          @dynect_customer = options[:dynect_customer]
-          @dynect_username = options[:dynect_username]
-          @dynect_password = options[:dynect_password]
-
-          @connection_options = options[:connection_options] || {}
-          @host               = 'api-v4.dynect.net'
-          @port               = options[:port]             || 443
-          @path               = options[:path]             || '/REST'
-          @persistent         = options[:persistent]       || false
-          @scheme             = options[:scheme]           || 'https'
-          @version            = options[:version]          || '3.5.2'
-          @job_poll_timeout   = options[:job_poll_timeout] || 10
-          @connection = Fog::XML::Connection.new("#{@scheme}://#{@host}:#{@port}", @persistent, @connection_options)
-        end
-
-        def auth_token
-          @auth_token ||= post_session.body['data']['token']
-        end
-
-        def request(params)
-          begin
-            # any request could redirect to a job
-            params[:expects] = Array(params[:expects]) | [307]
-
-            params[:headers] ||= {}
-            params[:headers]['Content-Type'] = 'application/json'
-            params[:headers]['API-Version'] = @version
-            params[:headers]['Auth-Token'] = auth_token unless params[:path] == 'Session'
-            params[:path] = "#{@path}/#{params[:path]}" unless params[:path] =~ %r{^#{Regexp.escape(@path)}/}
-
-            response = @connection.request(params)
-
-            if response.body.empty?
-              response.body = {}
-            elsif response.headers['Content-Type'] == 'application/json'
-              response.body = Fog::JSON.decode(response.body)
-            end
-
-            if response.body['status'] == 'failure'
-              raise Error, response.body['msgs'].first['INFO']
-            end
-
-            if params[:path] !~ %r{^/REST/Job/}
-              if response.status == 307
-                response = poll_job(response, params[:expects], @job_poll_timeout)
-
-              # Dynect intermittently returns 200 with an incomplete status.  When this
-              # happens, the job should still be polled.
-              elsif response.status == 200 && response.body['status'].eql?('incomplete')
-                response.headers['Location'] = "/REST/Job/#{ response.body['job_id'] }"
-                response = poll_job(response, params[:expects], @job_poll_timeout)
-              end
-            end
-
-            response
-          rescue Excon::Errors::HTTPStatusError => error
-            if @auth_token && error.message =~ /login: (Bad or expired credentials|inactivity logout)/
-              @auth_token = nil
-              retry
-            else
-              raise error
-            end
-          end
-
-          response
-        end
-
-        def poll_job(response, original_expects, time_to_wait)
-          job_location = response.headers['Location']
-
-          begin
-            Fog.wait_for(time_to_wait) do
-             response = request(
-               :expects => original_expects,
-               :idempotent => true,
-               :method => :get,
-               :path => job_location
-             )
-             response.body['status'] != 'incomplete'
-            end
-
-          rescue Errors::TimeoutError => error
-            if response.body['status'] == 'incomplete'
-              raise JobIncomplete.new("Job #{response.body['job_id']} is still incomplete")
-            else
-              raise error
-            end
-          end
-
-          response
-        end
-      end
-    end
-  end
-end

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

@@ -1,67 +0,0 @@
-require 'fog/core/model'
-
-module Fog
-  module DNS
-    class Dynect
-      class Record < Fog::Model
-        extend Fog::Deprecation
-
-        identity  :id
-        attribute :name,        :aliases => [:fqdn, 'fqdn']
-        attribute :rdata
-        attribute :serial_style
-        attribute :ttl
-        attribute :type,        :aliases => 'record_type'
-
-        def destroy
-          requires :identity, :name, :type, :zone
-          service.delete_record(type, zone.identity, name, identity)
-          true
-        end
-
-        def save(replace=false)
-          requires :name, :type, :rdata, :zone
-
-          options = {
-            :ttl => ttl
-          }
-          options.delete_if {|key, value| value.nil?}
-
-          if replace
-            data = service.put_record(type, zone.identity, name, rdata, options).body['data']
-          else
-            data = service.post_record(type, zone.identity, name, rdata, options).body['data']
-          end
-          # avoid overwriting zone object with zone string
-          data = data.reject {|key, value| key == 'zone'}
-          merge_attributes(data)
-
-          zone.publish
-          records = service.get_record(type, zone.identity, name).body['data']
-          # data in format ['/REST/xRecord/domain/fqdn/identity]
-          records.map! do |record|
-            tokens = record.split('/')
-            {
-              :identity => tokens.last,
-              :type     => tokens[2][0...-6] # everything before 'Record'
-            }
-          end
-          record = records.find {|record| record[:type] == type}
-          merge_attributes(record)
-
-          true
-        end
-
-        def zone
-          @zone
-        end
-
-        private
-
-        def zone=(new_zone)
-          @zone = new_zone
-        end
-      end
-    end
-  end
-end

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

@@ -1,48 +0,0 @@
-require 'fog/core/collection'
-require 'fog/dynect/models/dns/record'
-
-module Fog
-  module DNS
-    class Dynect
-      class Records < Fog::Collection
-        attribute :zone
-
-        model Fog::DNS::Dynect::Record
-
-        def all(options = {})
-          requires :zone
-          data = []
-          service.get_all_records(zone.domain, options).body['data'].each do |records|
-            (type, list) = records
-            list.each do |record|
-              data << {
-                :identity => record['record_id'],
-                :fqdn => record['fqdn'],
-                :type => record['record_type'],
-                :rdata => record['rdata']
-              }
-            end
-          end
-
-          load(data)
-        end
-
-        def get(record_id)
-          requires :zone
-
-          # there isn't a way to look up by just id
-          # must have type and domain for 'get_record' request
-          # so we pick it from the list returned by 'all'
-
-          list = all
-          list.detect {|e| e.id == record_id}
-        end
-
-        def new(attributes = {})
-          requires :zone
-          super({:zone => zone}.merge!(attributes))
-        end
-      end
-    end
-  end
-end

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

@@ -1,56 +0,0 @@
-require 'fog/core/model'
-require 'fog/dynect/models/dns/records'
-
-module Fog
-  module DNS
-    class Dynect
-      class Zone < Fog::Model
-        identity  :domain
-
-        attribute :domain,        :aliases => 'zone'
-        attribute :email,         :aliases => 'rname'
-        attribute :serial
-        attribute :serial_style
-        attribute :ttl
-        attribute :type,          :aliases => 'zone_type'
-
-        def initialize(attributes={})
-          super
-        end
-
-        def destroy
-          requires :domain
-          service.delete_zone(domain)
-          true
-        end
-
-        undef_method :domain=
-        def domain=(new_domain)
-          attributes[:domain] = new_domain.split('/').last
-        end
-
-        def publish
-          requires :identity
-          data = service.put_zone(identity, 'publish' => true)
-          true
-        end
-
-        def records
-          @records ||= Fog::DNS::Dynect::Records.new(:zone => self, :service => service)
-        end
-
-        def nameservers
-          raise 'nameservers Not Implemented'
-        end
-
-        def save
-          self.ttl ||= 3600
-          requires :domain, :email, :ttl
-          data = service.post_zone(email, ttl, domain).body['data']
-          merge_attributes(data)
-          true
-        end
-      end
-    end
-  end
-end

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

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

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

@@ -1,55 +0,0 @@
-module Fog
-  module DNS
-    class Dynect
-      class Real
-        # Delete a record
-        #
-        # ==== Parameters
-        # * type<~String> - type of record in ['AAAA', 'ANY', 'A', 'CNAME', 'DHCID', 'DNAME', 'DNSKEY', 'DS', 'KEY', 'LOC', 'MX', 'NSA', 'NS', 'PTR', 'PX', 'RP', 'SOA', 'SPF', 'SRV', 'SSHFP', 'TXT']
-        # * zone<~String> - zone of record
-        # * fqdn<~String> - fqdn of record
-        # * record_id<~String> - id of record
-
-        def delete_record(type, zone, fqdn, record_id)
-          request(
-            :expects  => 200,
-            :idempotent => true,
-            :method   => :delete,
-            :path     => ["#{type.to_s.upcase}Record", zone, fqdn, record_id].join('/')
-          )
-        end
-      end
-
-      class Mock
-        def delete_record(type, zone, fqdn, record_id)
-          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
-
-          raise Fog::DNS::Dynect::NotFound unless zone[:records][type].find { |record| record[:fqdn] == fqdn && record[:record_id] == record_id.to_i }
-
-          zone[:records_to_delete] << {
-            :type => type,
-            :fqdn => fqdn,
-            :record_id => record_id.to_i
-          }
-
-          response = Excon::Response.new
-          response.status = 200
-
-          response.body = {
-            "status" => "success",
-            "data" => {},
-            "job_id" => Fog::Dynect::Mock.job_id,
-            "msgs" => [{
-              "INFO" => "delete: Record will be deleted on zone publish",
-              "SOURCE" => "BLL",
-              "ERR_CD" => nil,
-              "LVL" => "INFO"
-            }]
-          }
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/dynect/requests/dns/delete_zone.rb

@@ -1,41 +0,0 @@
-module Fog
-  module DNS
-    class Dynect
-      class Real
-        # Delete a zone
-        #
-        # ==== Parameters
-        # * zone<~String> - zone to host
-
-        def delete_zone(zone)
-          request(
-            :expects  => 200,
-            :method   => :delete,
-            :path     => "Zone/#{zone}"
-          )
-        end
-      end
-
-      class Mock
-        def delete_zone(zone)
-          self.data[:zones].delete(zone)
-
-          response = Excon::Response.new
-          response.status = 200
-          response.body = {
-            "status" => "success",
-            "data" => {},
-            "job_id" => Fog::Dynect::Mock.job_id,
-            "msgs" => [{
-              "ERR_CD" => '',
-              "INFO" => '',
-              "LVL" => '',
-              "SOURCE" => ''
-            }]
-          }
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/dynect/requests/dns/get_all_records.rb

@@ -1,56 +0,0 @@
-module Fog
-  module DNS
-    class Dynect
-      class Real
-        # Get one or more node lists
-        #
-        # ==== Parameters
-        # * zone<~String> - zone to lookup node lists for
-        # * options<~Hash>
-        #   * fqdn<~String> - fully qualified domain name of node to lookup
-
-        def get_all_records(zone, options = {})
-          requested_fqdn = options['fqdn'] || options[:fqdn]
-          request(
-            :expects  => 200,
-            :idempotent => true,
-            :method   => :get,
-            :path     => ['AllRecord', zone, requested_fqdn].compact.join('/'),
-            :query    => {'detail' => 'Y'} # return full records, instead of just resource URLs
-          )
-        end
-      end
-
-      class Mock
-        def get_all_records(zone, options = {})
-          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
-
-          response = Excon::Response.new
-          response.status = 200
-
-          data = [zone[:zone]]
-
-          if fqdn = options[:fqdn]
-            data = data | zone[:records].map { |type, records| records.select { |record| record[:fqdn] == fqdn } }.flatten.compact
-          else
-            data = data | zone[:records].map { |type, records| records.map { |record| record[:fqdn] } }.flatten
-          end
-
-          response.body = {
-            "status" => "success",
-            "data" => data,
-            "job_id" => Fog::Dynect::Mock.job_id,
-            "msgs" => [{
-              "INFO" => "get_tree: Here is your zone tree",
-              "SOURCE" => "BLL",
-              "ERR_CD" => nil,
-              "LVL" => "INFO"
-            }]
-          }
-
-          response
-        end
-      end
-    end
-  end
-end

data/lib/fog/dynect/requests/dns/get_node_list.rb

@@ -1,55 +0,0 @@
-module Fog
-  module DNS
-    class Dynect
-      class Real
-        # Get one or more node lists
-        #
-        # ==== Parameters
-        # * zone<~String> - zone to lookup node lists for
-        # * options<~Hash>
-        #   * fqdn<~String> - fully qualified domain name of node to lookup
-
-        def get_node_list(zone, options = {})
-          requested_fqdn = options['fqdn'] || options[:fqdn]
-          request(
-            :expects  => 200,
-            :idempotent => true,
-            :method   => :get,
-            :path     => ['AllRecord', zone, requested_fqdn].compact.join('/')
-          )
-        end
-      end
-
-      class Mock
-        def get_node_list(zone, options = {})
-          raise Fog::DNS::Dynect::NotFound unless zone = self.data[:zones][zone]
-
-          response = Excon::Response.new
-          response.status = 200
-
-          data = [zone[:zone]]
-
-          if fqdn = options[:fqdn]
-            data = data | zone[:records].map { |type, records| records.select { |record| record[:fqdn] == fqdn } }.flatten.compact
-          else
-            data = data | zone[:records].map { |type, records| records.map { |record| record[:fqdn] } }.flatten
-          end
-
-          response.body = {
-            "status" => "success",
-            "data" => data,
-            "job_id" => Fog::Dynect::Mock.job_id,
-            "msgs" => [{
-              "INFO" => "get_tree: Here is your zone tree",
-              "SOURCE" => "BLL",
-              "ERR_CD" => nil,
-              "LVL" => "INFO"
-            }]
-          }
-
-          response
-        end
-      end
-    end
-  end
-end