fog-dnsimple 2.0.0 → 3.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: 7ae36b9bfa292d8ec1b6f188e38f00c38250b6cb
-  data.tar.gz: 4a8d56b5b4a8c37113305ec80fa61283964c60b1
+SHA256:
+  metadata.gz: 823036363818ab3ec842ea8ccefa3e07af9491587275c388897a00393fa3d4af
+  data.tar.gz: 9feb86908b986414ac18650a56435eae0cc6327824494eac901b523a0f59886c
 SHA512:
-  metadata.gz: bd86df711ff013b7f711afb7edaf0897a5ccc4788ea13a52beb05b12d8f19e2c802de6c3cd611403fa03e949a7bbb257453297a9a5d136eaec8590ecbf254173
-  data.tar.gz: 50533cd840e2002326d4ce7c17251289a82dc1607bb0033ec5726ed2a504a2565d5d9e0bbdae0ae69144fa55b84a72aa685787707be4a1409d9940fcf0781ab5
+  metadata.gz: 1fec9f2a935a5ceb6867c0ecffb49be3fedd46704ee0864b30ba0d96f9589eb04e35a9603c30008e8310aacd186f31a3bfa3cd813bdcac891a1d8bf83981e851
+  data.tar.gz: 44f31c656c473ae7ad26fcb62dcb0850a5c69a42f4ce3f4323d966150a696d7b47af2d5e1191429c92a9b20429fa429ffbb539bd3d8ab3c2abeb10b51da6381d

data/CHANGELOG.md

@@ -1,7 +1,22 @@
 # Changelog
 
+#### Release 3.0.0
 
-#### Release 2.0
+- FIXED: Record requests use the zone name instead of the zone ID (#7, #11)
+- CHANGED: Minimum Ruby version is now 3.2 (#9)
+- CHANGED: Moved CI from Travis to GitHub Actions (#9)
+- CHANGED: Minimum fog-core version is now 2.5 (#10)
+- CHANGED: The service class is now `Fog::Dnsimple::DNS`. `Fog::DNS::Dnsimple` remains as an alias (#10)
+- CHANGED: Requests use the dnsimple-ruby client instead of a custom HTTP connection (#11)
+- CHANGED: Removed `Real#reload` and the public `Real#request`. From `connection_options`, only the proxy is used (#11)
+
+#### Release 2.1.0
+
+- NEW: Added ability to fetch all (non-paginated) domains and records (#4, #6)
+- FIXED: Added missing "minimum Ruby version" in Gemspec
+- CHANGED: Replaced Shindo with Minitest (#5)
+
+#### Release 2.0.0
 
 Upgrade to DNSimple API v2.
 https://developer.dnsimple.com/v2/
@@ -11,7 +26,6 @@ In order to use API v2 you need an API v2 Oauth token, and the accound ID. The a
     https://dnsimple.com/a/1234/domains/example.com
     -> 1234
 
-
-#### Release 1.0
+#### Release 1.0.0
 
 Initial version, extracted from `fog`.

data/Gemfile

@@ -1,4 +1,11 @@
-source 'https://rubygems.org'
+# frozen_string_literal: true
+
+source "https://rubygems.org"
 
-# Specify your gem's dependencies in fog-dnsimple.gemspec
 gemspec
+
+gem "rake"
+
+gem "minitest"
+gem "minitest-reporters"
+gem "webmock"

data/LICENSE.txt

@@ -0,0 +1,22 @@
+The MIT License (MIT)
+
+Copyright (c) 2009-2016 https://github.com/fog/fog/blob/master/CONTRIBUTORS.md
+Copyright (c) 2016-2026 DNSimple Corporation
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

data/README.md

@@ -1,47 +1,45 @@
 # Fog::Dnsimple
 
-[![Build Status](https://travis-ci.org/fog/fog-dnsimple.svg?branch=master)](https://travis-ci.org/fog/fog-dnsimple)
-
-
-## API Version
-
-This library currently uses the [DNSimple API v1](https://developer.dnsimple.com/v1/) 
-and it is fully compatible with the legacy implementation bundled with the `fog` gem.
-
-In other words, this is a drop-in replacement. Please note that the `dnsimple` provider
-will eventually be removed from the `fog` gem in favor of this fog-specific module.
+[![CI](https://github.com/fog/fog-dnsimple/actions/workflows/ci.yml/badge.svg)](https://github.com/fog/fog-dnsimple/actions/workflows/ci.yml)
 
+This library is the [DNSimple](https://dnsimple.com/) provider for [fog](https://github.com/fog/fog). It uses the [DNSimple API](https://developer.dnsimple.com/) through the [dnsimple-ruby](https://github.com/dnsimple/dnsimple-ruby) client.
 
 ## Installation
 
 Add this line to your application's Gemfile:
 
 ```ruby
-gem 'fog-dnsimple'
+gem "fog-dnsimple"
 ```
 
 And then execute:
 
-    $ bundle
+```bash
+bundle install
+```
 
 Or install it yourself as:
 
-    $ gem install fog-dnsimple
-
+```bash
+gem install fog-dnsimple
+```
 
 ## Usage
 
 Initialize a `Fog::DNS` object using the DNSimple provider.
 
 ```ruby
-dns = Fog::DNS.new({
+dns = Fog::DNS.new(
   provider:         "DNSimple",
   dnsimple_token:   "YOUR_API_TOKEN",
   dnsimple_account: "YOUR_ACCOUNT_ID",
-})
+)
 ```
 
-This can then be used like other [Fog DNS](http://fog.io/dns/) providers.
+- `YOUR_API_TOKEN`: the API access token. You can create it from your account page: Account > Access Tokens > Account access tokens.
+- `YOUR_ACCOUNT_ID`: the numeric account ID. It is the number after `/a` in the account URL. For instance, if the account page is `https://dnsimple.com/a/1234/domains`, the account ID is `1234`.
+
+You can then use it like other fog DNS providers.
 
 ```ruby
 zone = dns.zones.create(
@@ -54,19 +52,24 @@ record = zone.records.create(
 )
 ```
 
-The following configurations are supported:
+The following options are also supported:
 
 ```ruby
-dns = Fog::DNS.new({
-  # Use dnsimple_url to provide a different base URL, e.g. the Sandbox URL
-  dnsimple_url:   "https://api.sandbox.dnsimple.com/",
-})
+dns = Fog::DNS.new(
+  provider:           "DNSimple",
+  dnsimple_token:     "YOUR_API_TOKEN",
+  dnsimple_account:   "YOUR_ACCOUNT_ID",
+  # A different base URL, for example the Sandbox URL
+  dnsimple_url:       "https://api.sandbox.dnsimple.com",
+  # An HTTP proxy
+  connection_options: { proxy: "http://proxy.example.com:8080" },
+)
 ```
 
 ## Contributing
 
-1. Fork it ( https://github.com/fog/fog-dnsimple/fork )
-2. Create your feature branch (`git checkout -b my-new-feature`)
-3. Commit your changes (`git commit -am 'Add some feature'`)
+1. Fork it (https://github.com/fog/fog-dnsimple/fork)
+2. Create your feature branch (`git switch -c my-new-feature`)
+3. Commit your changes (`git commit -am "Add some feature"`)
 4. Push to the branch (`git push origin my-new-feature`)
-5. Create new Pull Request
+5. Create a new Pull Request

data/lib/fog/bin/dnsimple.rb

@@ -1,28 +1,49 @@
-class Dnsimple < Fog::Bin
-  class << self
-    def class_for(key)
-      case key
-      when :dns
-        Fog::DNS::Dnsimple
-      else
-        raise ArgumentError, "Unrecognized service: #{key}"
-      end
-    end
+module Fog
+  module Dnsimple
+    class Bin < Fog::Bin
+      class << self
+        def class_for(key)
+          case key
+          when :dns
+            Fog::Dnsimple::DNS
+          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: "Dnsimple")
-        else
-          raise ArgumentError, "Unrecognized service: #{key.inspect}"
+        def [](service)
+          @@connections ||= Hash.new do |hash, key|
+            hash[key] = case key
+            when :dns
+              Fog::DNS.new(provider: "Dnsimple")
+            else
+              raise ArgumentError, "Unrecognized service: #{key.inspect}"
+            end
+          end
+          @@connections[service]
+        end
+
+        def services
+          Fog::Dnsimple.services
         end
       end
-      @@connections[service]
     end
+  end
+end
 
-    def services
-      Fog::Dnsimple.services
-    end
+# fog finds the provider bin at the top-level Dnsimple constant, but the dnsimple gem owns that module.
+# Thus the module sends the bin methods to Fog::Dnsimple::Bin.
+module Dnsimple
+  def self.method_missing(name, *args, &block)
+    bin_method?(name) ? Fog::Dnsimple::Bin.public_send(name, *args, &block) : super
+  end
+
+  def self.respond_to_missing?(name, include_private = false)
+    bin_method?(name) || super
+  end
+
+  def self.bin_method?(name)
+    Fog::Dnsimple::Bin.singleton_methods.include?(name.to_sym)
   end
+  private_class_method :bin_method?
 end

data/lib/fog/dnsimple/dns.rb

@@ -1,9 +1,11 @@
 require "fog/core"
-require "fog/json"
+# dnsimple-ruby uses JSON but does not require it.
+require "json"
+require "dnsimple"
 
 module Fog
-  module DNS
-    class Dnsimple < Fog::Service
+  module Dnsimple
+    class DNS < Fog::Service
       recognizes :dnsimple_token, :dnsimple_account, :dnsimple_url
 
       model_path 'fog/dnsimple/models/dns'
@@ -14,11 +16,13 @@ module Fog
 
       request_path 'fog/dnsimple/requests/dns'
       request :list_domains
+      request :list_all_domains
       request :create_domain
       request :get_domain
       request :delete_domain
       request :create_record
       request :list_records
+      request :list_all_records
       request :update_record
       request :delete_record
       request :get_record
@@ -55,52 +59,83 @@ module Fog
           @dnsimple_token = options[:dnsimple_token]
           @dnsimple_account = options[:dnsimple_account]
 
-          if options[:dnsimple_url]
-            uri = URI.parse(options[:dnsimple_url])
-            options[:host]    = uri.host
-            options[:port]    = uri.port
-            options[:scheme]  = uri.scheme
+          @client = ::Dnsimple::Client.new(
+            access_token: @dnsimple_token,
+            base_url: options[:dnsimple_url],
+            proxy: proxy_address(options.dig(:connection_options, :proxy)),
+            user_agent: "#{Fog::Core::Connection.user_agents} fog-dnsimple/#{Fog::Dnsimple::VERSION}"
+          )
+        end
+
+        private
+
+        # Converts the dnsimple-ruby result and errors to Excon types.
+        def request
+          unless @dnsimple_token && @dnsimple_account
+            raise ArgumentError.new("Insufficient credentials to properly authenticate!")
           end
 
-          connection_options = options[:connection_options] || {}
-          connection_options[:headers] ||= {}
-          connection_options[:headers]["User-Agent"] = "#{Fog::Core::Connection.user_agents} fog-dnsimple/#{Fog::Dnsimple::VERSION}"
+          http_response = yield(@client).http_response
+          excon_response(http_response, http_response.parsed_response || "")
+        rescue ::Dnsimple::RequestError => e
+          raise Excon::Error.status_error({}, excon_response(e.http_response, e.http_response.body.to_s))
+        rescue ::Dnsimple::AuthenticationFailed => e
+          raise Excon::Error.status_error({}, Excon::Response.new(status: 401, body: JSON.dump("message" => e.message)))
+        rescue Timeout::Error => e
+          raise Excon::Error::Timeout, e.message
+        rescue SocketError, SystemCallError, IOError, OpenSSL::SSL::SSLError => e
+          raise Excon::Error::Socket.new(e)
+        rescue JSON::ParserError => e
+          raise Excon::Error::ResponseParse, e.message
+        end
 
-          host       = options[:host]        || "api.dnsimple.com"
-          persistent = options[:persistent]  || false
-          port       = options[:port]        || 443
-          scheme     = options[:scheme]      || "https"
-          @connection = Fog::Core::Connection.new("#{scheme}://#{host}:#{port}", persistent, connection_options)
+        # Converts an Excon proxy (URL or Hash) to the "host:port" form of dnsimple-ruby.
+        def proxy_address(proxy)
+          case proxy
+          when String
+            uri = URI.parse(proxy)
+            "#{uri.host}:#{uri.port}"
+          when Hash
+            "#{proxy[:host]}:#{proxy[:port]}"
+          end
         end
 
-        def reload
-          @connection.reset
+        # Excon errors carry the raw body, and successful responses carry the parsed JSON.
+        def excon_response(http_response, body)
+          Excon::Response.new(
+            status: http_response.code,
+            headers: http_response.response.each_header.to_h,
+            body: body
+          )
         end
 
-        def request(params)
-          params[:headers] ||= {}
+        def paginate(query: {})
+          current_page = 0
+          total_pages = nil
+          total_entries = nil
+          collection = []
+          response = nil
 
-          if @dnsimple_token && @dnsimple_account
-            params[:headers].merge!("Authorization" => "Bearer #{@dnsimple_token}")
-          else
-            raise ArgumentError.new("Insufficient credentials to properly authenticate!")
-          end
-          params[:headers].merge!(
-              "Accept" => "application/json",
-              "Content-Type" => "application/json"
-          )
+          begin
+            current_page += 1
+            current_query = query.merge({ page: current_page, per_page: 100 })
 
-          version = params.delete(:version) || "v2"
-          params[:path] = File.join("/", version, params[:path])
+            response = yield(current_query)
+            total_entries ||= response.body.dig("pagination", "total_entries")
+            total_pages ||= response.body.dig("pagination", "total_pages")
+            collection.concat(response.body["data"])
+          end while current_page < total_pages
 
-          response = @connection.request(params)
+          total_entries == collection.size or
+            raise(Fog::Errors::Error, "Expected `#{total_entries}`, fetched only `#{collection.size}`")
 
-          unless response.body.empty?
-            response.body = Fog::JSON.decode(response.body)
-          end
+          response.body["data"] = collection
           response
         end
       end
     end
   end
+
+  # Keeps the constant from the service::provider format for compatibility.
+  DNS::Dnsimple = Dnsimple::DNS
 end

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

@@ -1,8 +1,8 @@
 require 'fog/core/model'
 
 module Fog
-  module DNS
-    class Dnsimple
+  module Dnsimple
+    class DNS
       class Record < Fog::Model
         identity :id
 
@@ -20,7 +20,7 @@ module Fog
         end
 
         def destroy
-          service.delete_record(zone.id, identity)
+          service.delete_record(zone.domain, identity)
           true
         end
 
@@ -35,12 +35,12 @@ module Fog
 
           # decide whether its a new record or update of an existing
           if id.nil?
-            data = service.create_record(zone.id, name, type, value, options)
+            data = service.create_record(zone.domain, 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)
+            data = service.update_record(zone.domain, id, options)
           end
 
           merge_attributes(data.body["data"])

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

@@ -2,23 +2,23 @@ require 'fog/core/collection'
 require 'fog/dnsimple/models/dns/record'
 
 module Fog
-  module DNS
-    class Dnsimple
+  module Dnsimple
+    class DNS
       class Records < Fog::Collection
         attribute :zone
 
-        model Fog::DNS::Dnsimple::Record
+        model Fog::Dnsimple::DNS::Record
 
         def all
           requires :zone
           clear
-          data = service.list_records(zone.id).body["data"]
+          data = service.list_records(zone.domain).body["data"]
           load(data)
         end
 
         def get(record_id)
           requires :zone
-          data = service.get_record(zone.id, record_id).body["data"]
+          data = service.get_record(zone.domain, record_id).body["data"]
           new(data)
         rescue Excon::Errors::NotFound
           nil

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

@@ -2,8 +2,8 @@ require 'fog/core/model'
 require 'fog/dnsimple/models/dns/records'
 
 module Fog
-  module DNS
-    class Dnsimple
+  module Dnsimple
+    class DNS
       class Zone < Fog::Model
         identity :id
 
@@ -18,7 +18,7 @@ module Fog
 
         def records
           @records ||= begin
-            Fog::DNS::Dnsimple::Records.new(
+            Fog::Dnsimple::DNS::Records.new(
               :zone       => self,
               :service => service
             )

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

@@ -2,10 +2,10 @@ require 'fog/core/collection'
 require 'fog/dnsimple/models/dns/zone'
 
 module Fog
-  module DNS
-    class Dnsimple
+  module Dnsimple
+    class DNS
       class Zones < Fog::Collection
-        model Fog::DNS::Dnsimple::Zone
+        model Fog::Dnsimple::DNS::Zone
 
         def all
           clear

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

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class Dnsimple
+  module Dnsimple
+    class DNS
       class Real
         # Create a single domain in DNSimple in your account.
         #
@@ -12,16 +12,7 @@ module Fog
         #   * body<~Hash>:
         #     * "data"<~Hash> The representation of the domain.
         def create_domain(zone_name)
-          body = {
-            "name" => zone_name
-          }
-
-          request(
-            body:     Fog::JSON.encode(body),
-            expects:  201,
-            method:   "POST",
-            path:     "/#{@dnsimple_account}/domains"
-          )
+          request { |client| client.domains.create_domain(@dnsimple_account, name: zone_name) }
         end
       end
 

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

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class Dnsimple
+  module Dnsimple
+    class DNS
       class Real
         # Create a new host in the specified zone
         #
@@ -18,19 +18,9 @@ module Fog
         #   * body<~Hash>:
         #     * 'record'<~Hash> The representation of the record.
         def create_record(zone_name, name, type, content, options = {})
-          body = {
-            "name" => name,
-            "type" => type,
-            "content" => content
-          }
-          body.merge!(options)
+          attributes = { name: name, type: type, content: content }.merge(options)
 
-          request(
-            body:     Fog::JSON.encode(body),
-            expects:  201,
-            method:   "POST",
-            path:     "/#{@dnsimple_account}/zones/#{zone_name}/records"
-          )
+          request { |client| client.zones.create_zone_record(@dnsimple_account, zone_name, attributes) }
         end
       end
 

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

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class Dnsimple
+  module Dnsimple
+    class DNS
       class Real
         # Delete the given domain from your account. You may use
         # either the domain ID or the domain name.
@@ -9,22 +9,17 @@ module Fog
         # DNSimple this will not delete the domain from the registry.
         #
         # ==== Parameters
-        # * account_id<~String> - the account the domain belong to
         # * zone_name<~String> - zone name
         #
         def delete_domain(zone_name)
-          request(
-            expects:  204,
-            method:   "DELETE",
-            path:     "/#{@dnsimple_account}/domains/#{zone_name}"
-          )
+          request { |client| client.domains.delete_domain(@dnsimple_account, zone_name) }
         end
       end
 
       class Mock
         def delete_domain(zone_name)
           self.data[:records].delete(zone_name)
-          self.data[:domains].reject! { |domain| domain["name"] == zone_name }
+          self.data[:domains].reject! { |domain| domain["id"] == zone_name || domain["name"] == zone_name }
 
           response = Excon::Response.new
           response.status = 204

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

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class Dnsimple
+  module Dnsimple
+    class DNS
       class Real
         # Delete the record with the given ID for the given domain.
         #
@@ -8,11 +8,7 @@ module Fog
         # * zone_name<~String> - zone name
         # * record_id<~String>
         def delete_record(zone_name, record_id)
-          request(
-            expects:  204,
-            method:   "DELETE",
-            path:     "/#{@dnsimple_account}/zones/#{zone_name}/records/#{record_id}"
-          )
+          request { |client| client.zones.delete_zone_record(@dnsimple_account, zone_name, record_id) }
         end
       end
 

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

@@ -1,6 +1,6 @@
 module Fog
-  module DNS
-    class Dnsimple
+  module Dnsimple
+    class DNS
       class Real
         # Get the details for a specific domain in your account. You
         # may pass either the domain numeric ID or the domain name
@@ -14,23 +14,24 @@ module Fog
         #   * body<~Hash>:
         #     * "data"<~Hash> The representation of the domain.
         def get_domain(zone_name)
-          request(
-            expects:  200,
-            method:   "GET",
-            path:     "/#{@dnsimple_account}/domains/#{zone_name}"
-          )
+          request { |client| client.domains.domain(@dnsimple_account, zone_name) }
         end
       end
 
       class Mock
         def get_domain(zone_name)
-          domain = self.data[:domains].find do |domain|
-            domain["id"] == zone_name || domain["name"] == zone_name
+          response = Excon::Response.new
+
+          payload = self.data[:domains].find { |domain| domain["id"] == zone_name || domain["name"] == zone_name }
+          if payload
+            response.status = 200
+            response.body = { "data" => payload }
+          else
+            # response.status = 404
+            # response.body = { "message" => "Domain `#{zone_name}` not found" }
+            raise Excon::Errors::NotFound, "Domain `#{zone_name}` not found"
           end
 
-          response = Excon::Response.new
-          response.status = 200
-          response.body = { "data" => domain }
           response
         end
       end