docheck 1.1.2 → 2.0.0

data/exe/docheck

@@ -0,0 +1,6 @@
+#!/usr/bin/env ruby
+# frozen_string_literal: true
+
+require_relative "../lib/docheck/cli"
+
+exit Docheck::CLI.new(ARGV).run

data/lib/docheck/application.rb

@@ -1,76 +1,35 @@
+# frozen_string_literal: true
+
 module Docheck
+  # The 1.x API, kept for compatibility. New code should use Checker.
   class Application
-
-    # DNS name of the generic top-level domain
-    # http://en.wikipedia.org/wiki/List_of_Internet_top-level_domains
-    TLD = %w[aero asia biz cat com coop edu gov info
-    int jobs mil mobi museum name net org pro tel travel]
-
     attr_reader :available_domains, :registered_domains
 
-    # base_name is sld (Second Level Domain) and
-    # converted to lower case.
-    def initialize(base_name)
-      @base_name = base_name.to_s.downcase
+    def initialize(base_name, checker: Checker.new)
+      @base_name = base_name
+      @checker = checker
       @available_domains = []
       @registered_domains = []
     end
 
-    # Print the fetch result.
-    def print
-      result = fetch
-
-      puts "\nDocheck Result\n"
-      puts "--------------\n"
-      puts "Available Domains:"
-      result.first.map{|domain_name| puts "- #{domain_name}"}
-      puts "\n"
-      puts "Registered Domains:"
-      result.last.map{|domain_name| puts "- #{domain_name}"}
-
-      true
-    end
-
-    # Check domain name availability
-    # and return the result as array.
-    #
-    # The first element of array will return all
-    # available domains as array.
-    #
-    # The last element of array will return all
-    # registered domains as array.
+    # Returns [available_domains, registered_domains]. Each call replaces the
+    # previous result. Raises InvalidNameError for an invalid name.
     def fetch
-      attempts = 0
-      TLD.each do |tld|
-        domain_name = "#{@base_name}.#{tld}"
-        begin
-          whois_domain = Whois.whois(domain_name)
-
-          if whois_domain.available?
-            @available_domains << domain_name
-          elsif whois_domain.registered?
-            @registered_domains << domain_name
-          end
-        rescue Timeout::Error
-          if attempts <= 3
-            attempts += 1
-            retry
-          else
-            attempts = 0
-            next
-          end
-        rescue
-          if attempts <= 3
-            attempts += 1
-            retry
-          else
-            attempts = 0
-            next
-          end
-        end
-      end
+      results = @checker.check(@base_name)
+      @available_domains = results.select(&:available?).map(&:domain)
+      @registered_domains = results.select(&:registered?).map(&:domain)
+      [@available_domains, @registered_domains]
+    end
 
-      return [@available_domains, @registered_domains]
+    # Prints the fetch result to +out+ and returns true.
+    def print(out = $stdout) # rubocop:disable Naming/PredicateMethod -- 1.x public API name
+      available, registered = fetch
+      out.puts "Available Domains:"
+      available.each { |domain| out.puts "- #{domain}" }
+      out.puts
+      out.puts "Registered Domains:"
+      registered.each { |domain| out.puts "- #{domain}" }
+      true
     end
   end
 end

data/lib/docheck/bootstrap.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Docheck
+  # Maps each TLD to its RDAP base URL, using the IANA bootstrap file format
+  # (RFC 9224). The gem bundles a snapshot in data/rdap_dns.json so that a
+  # lookup needs no extra network call. Refresh it with `rake rdap:update`.
+  class Bootstrap
+    DEFAULT_PATH = File.expand_path("../../data/rdap_dns.json", __dir__)
+
+    def self.default
+      @default ||= load_file(DEFAULT_PATH)
+    end
+
+    def self.load_file(path)
+      parse(File.read(path))
+    end
+
+    def self.parse(json)
+      services = JSON.parse(json).fetch("services")
+      new(services.each_with_object({}) do |(tlds, urls), map|
+        url = urls.find { |u| u.start_with?("https://") }
+        tlds.each { |tld| map[tld.downcase] = url } if url
+      end)
+    rescue JSON::ParserError, KeyError, TypeError, NoMethodError => e
+      raise BootstrapError, "invalid RDAP bootstrap data: #{e.message}"
+    end
+
+    def initialize(base_urls)
+      @base_urls = base_urls.to_h do |tld, url|
+        raise BootstrapError, "RDAP base URL for #{tld} must use https: #{url}" unless url.start_with?("https://")
+
+        [tld.downcase.freeze, (url.end_with?("/") ? url : "#{url}/").freeze]
+      end.freeze
+      freeze
+    end
+
+    # Returns the RDAP base URL for +tld+ (ending in "/"), or nil.
+    def base_url(tld)
+      @base_urls[tld.to_s.downcase]
+    end
+  end
+end

data/lib/docheck/checker.rb

@@ -0,0 +1,53 @@
+# frozen_string_literal: true
+
+module Docheck
+  # Checks a name against a list of TLDs, one RDAP lookup per TLD in parallel.
+  class Checker
+    # Generic TLDs open to public registration.
+    DEFAULT_TLDS = %w[com net org info biz name pro mobi asia tel travel jobs aero cat coop museum].freeze
+
+    # Upper bound in seconds for a whole #check call.
+    DEADLINE = 10
+
+    attr_reader :tlds
+
+    def initialize(tlds: DEFAULT_TLDS, bootstrap: Bootstrap.default, http: HttpClient.new, deadline: DEADLINE)
+      @tlds = tlds.map { |tld| tld.to_s.downcase.delete_prefix(".").freeze }.freeze
+      @bootstrap = bootstrap
+      @http = http
+      @deadline = deadline
+      freeze
+    end
+
+    # Returns one Result per TLD, in TLD order. Raises InvalidNameError when
+    # +name+ is not a valid DNS label. Lookups still running at the deadline
+    # get +:unknown+.
+    def check(name)
+      label = Name.normalize(name)
+      threads = tlds.map { |tld| Thread.new { lookup("#{label}.#{tld}", tld) } }
+      collect(threads, tlds.map { |tld| "#{label}.#{tld}" })
+    end
+
+    private
+
+    def lookup(domain, tld)
+      base_url = @bootstrap.base_url(tld)
+      return :unsupported unless base_url
+
+      @http.status("#{base_url}domain/#{domain}")
+    rescue StandardError
+      :unknown
+    end
+
+    def collect(threads, domains)
+      ends_at = now + @deadline
+      threads.zip(domains).map do |thread, domain|
+        finished = thread.join([ends_at - now, 0].max)
+        thread.kill unless finished
+        Result.new(domain: domain, status: finished ? thread.value : :unknown)
+      end
+    end
+
+    def now = Process.clock_gettime(Process::CLOCK_MONOTONIC)
+  end
+end

data/lib/docheck/cli.rb

@@ -0,0 +1,70 @@
+# frozen_string_literal: true
+
+require "optparse"
+require_relative "../docheck"
+
+module Docheck
+  # The docheck command. #run returns the process exit status.
+  class CLI
+    EX_OK = 0
+    EX_USAGE = 64
+
+    LABELS = {
+      available: "Available",
+      registered: "Registered",
+      unknown: "Unknown (lookup failed)",
+      unsupported: "Unsupported (no RDAP server)"
+    }.freeze
+
+    def initialize(argv, out: $stdout, err: $stderr, checker: nil)
+      @argv = argv.dup
+      @out = out
+      @err = err
+      @checker = checker
+      @done = false
+    end
+
+    def run
+      name = nil
+      parser = option_parser { |value| name = value }
+      parser.parse!(@argv)
+      return EX_OK if @done
+      return usage_error(parser, "missing --name") unless name
+
+      print_results((@checker || Checker.new).check(name))
+      EX_OK
+    rescue OptionParser::ParseError, InvalidNameError => e
+      usage_error(parser, e.message)
+    end
+
+    private
+
+    def option_parser(&on_name)
+      OptionParser.new do |opts|
+        opts.banner = "Usage: docheck -n NAME   (example: docheck -n google)"
+        opts.on("-n", "--name NAME", "Check NAME against each TLD", &on_name)
+        opts.on("-v", "--version", "Show version") { finish("docheck #{VERSION}") }
+        opts.on("-h", "--help", "Show help") { finish(opts.help) }
+      end
+    end
+
+    def finish(text)
+      @out.puts text
+      @done = true
+    end
+
+    def usage_error(parser, message)
+      @err.puts "docheck: #{message}"
+      @err.puts parser.help
+      EX_USAGE
+    end
+
+    def print_results(results)
+      results.group_by(&:status).sort_by { |status, _| LABELS.keys.index(status) }.each do |status, group|
+        @out.puts "#{LABELS.fetch(status)}:"
+        group.each { |result| @out.puts "- #{result.domain}" }
+        @out.puts
+      end
+    end
+  end
+end

data/lib/docheck/errors.rb

@@ -0,0 +1,12 @@
+# frozen_string_literal: true
+
+module Docheck
+  # Base class for all Docheck errors.
+  class Error < StandardError; end
+
+  # Raised when a name is not a valid DNS label.
+  class InvalidNameError < Error; end
+
+  # Raised when the RDAP bootstrap data is malformed.
+  class BootstrapError < Error; end
+end

data/lib/docheck/http_client.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+
+require "net/http"
+require "openssl"
+require "uri"
+
+module Docheck
+  # Queries one RDAP domain URL and maps the HTTP response to a status.
+  #
+  # It sends HEAD, not GET (RFC 7480 section 4.1). The status code is all it
+  # needs, and some registries (Verisign) end a GET body by closing TLS without
+  # close_notify, which OpenSSL 3 reports as an error.
+  class HttpClient
+    TIMEOUT = 3
+    MAX_REDIRECTS = 1
+    RETRIES = 1
+
+    # +requester+ takes a URI and returns a Net::HTTPResponse. Tests pass a
+    # fake one; the default performs a real HTTPS HEAD request.
+    def initialize(timeout: TIMEOUT, requester: nil)
+      @timeout = timeout
+      @requester = requester || method(:head)
+    end
+
+    # Returns +:registered+, +:available+, or +:unknown+ for +url+.
+    def status(url)
+      fetch_status(URI(url), MAX_REDIRECTS, RETRIES)
+    rescue URI::Error
+      :unknown
+    end
+
+    private
+
+    NETWORK_ERRORS = [IOError, SystemCallError, SocketError, OpenSSL::SSL::SSLError, Net::ProtocolError].freeze
+    private_constant :NETWORK_ERRORS
+
+    def fetch_status(uri, redirects_left, retries_left)
+      return :unknown unless uri.is_a?(URI::HTTPS)
+
+      response = @requester.call(uri)
+      case response
+      when Net::HTTPOK then :registered
+      when Net::HTTPNotFound then :available
+      when Net::HTTPRedirection then follow(uri, response["location"], redirects_left, retries_left)
+      when Net::HTTPServerError then retry_once(uri, redirects_left, retries_left)
+      else :unknown
+      end
+    rescue Timeout::Error
+      retry_once(uri, redirects_left, retries_left)
+    rescue *NETWORK_ERRORS
+      :unknown
+    end
+
+    def retry_once(uri, redirects_left, retries_left)
+      return :unknown unless retries_left.positive?
+
+      fetch_status(uri, redirects_left, retries_left - 1)
+    end
+
+    def follow(uri, location, redirects_left, retries_left)
+      return :unknown if redirects_left.zero? || location.nil?
+
+      fetch_status(uri.merge(location), redirects_left - 1, retries_left)
+    end
+
+    def head(uri)
+      Net::HTTP.start(uri.host, uri.port, use_ssl: true,
+                                          open_timeout: @timeout, read_timeout: @timeout,
+                                          ssl_timeout: @timeout) do |http|
+        request = Net::HTTP::Head.new(uri)
+        request["Accept"] = "application/rdap+json"
+        request["User-Agent"] = "docheck/#{VERSION} (+https://github.com/kuntoaji/docheck)"
+        http.request(request)
+      end
+    end
+  end
+end

data/lib/docheck/name.rb

@@ -0,0 +1,20 @@
+# frozen_string_literal: true
+
+module Docheck
+  # Validates the second-level name that Docheck appends each TLD to.
+  module Name
+    # One LDH (letter, digit, hyphen) label of 1 to 63 characters that does
+    # not start or end with a hyphen. IDNs must be passed in punycode (xn--).
+    LABEL = /\A[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?\z/
+
+    # Returns +name+ stripped and downcased, or raises InvalidNameError.
+    def self.normalize(name)
+      label = name.to_s.strip.downcase
+      return label if LABEL.match?(label)
+
+      raise InvalidNameError,
+            "#{name.to_s.inspect} is not a valid domain name label " \
+            "(1-63 letters, digits, or hyphens, no leading or trailing hyphen)"
+    end
+  end
+end

data/lib/docheck/result.rb

@@ -0,0 +1,23 @@
+# frozen_string_literal: true
+
+module Docheck
+  # The availability of one domain name.
+  #
+  # +status+ is one of:
+  # - +:available+: the registry has no record of the domain
+  # - +:registered+: the registry has a record of the domain
+  # - +:unknown+: the lookup failed (timeout, rate limit, or server error)
+  # - +:unsupported+: the TLD has no RDAP server in the bootstrap data
+  Result = Data.define(:domain, :status) do
+    def initialize(domain:, status:)
+      raise ArgumentError, "unknown status: #{status.inspect}" unless Result::STATUSES.include?(status)
+
+      super
+    end
+
+    def available? = status == :available
+    def registered? = status == :registered
+  end
+
+  Result::STATUSES = %i[available registered unknown unsupported].freeze
+end

data/lib/docheck/version.rb

@@ -1,3 +1,5 @@
+# frozen_string_literal: true
+
 module Docheck
-  VERSION = '1.1.2'
+  VERSION = "2.0.0"
 end

data/lib/docheck.rb

@@ -1,6 +1,18 @@
-libdir = File.dirname(__FILE__)
-$LOAD_PATH.unshift(libdir) unless $LOAD_PATH.include?(libdir)
+# frozen_string_literal: true
 
-require 'whois'
-require 'docheck/version'
-require 'docheck/application'
+require_relative "docheck/version"
+require_relative "docheck/errors"
+require_relative "docheck/name"
+require_relative "docheck/result"
+require_relative "docheck/bootstrap"
+require_relative "docheck/http_client"
+require_relative "docheck/checker"
+require_relative "docheck/application"
+
+# Domain name availability checker built on RDAP.
+module Docheck
+  # Checks +name+ against the default TLDs. See Checker#check.
+  def self.check(name)
+    Checker.new.check(name)
+  end
+end

metadata

@@ -1,70 +1,47 @@
 --- !ruby/object:Gem::Specification
 name: docheck
 version: !ruby/object:Gem::Version
-  version: 1.1.2
+  version: 2.0.0
 platform: ruby
 authors:
 - Kunto Aji Kristianto
-autorequire: 
-bindir: bin
+bindir: exe
 cert_chain: []
-date: 2019-10-03 00:00:00.000000000 Z
-dependencies:
-- !ruby/object:Gem::Dependency
-  name: whois
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.6.5
-  type: :runtime
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - '='
-      - !ruby/object:Gem::Version
-        version: 3.6.5
-- !ruby/object:Gem::Dependency
-  name: shoulda
-  requirement: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.6.0
-  type: :development
-  prerelease: false
-  version_requirements: !ruby/object:Gem::Requirement
-    requirements:
-    - - "~>"
-      - !ruby/object:Gem::Version
-        version: 3.6.0
-description: "    Domain name availability checker.\n"
+date: 1980-01-02 00:00:00.000000000 Z
+dependencies: []
+description: Checks whether a domain name is available or registered across generic
+  TLDs, using RDAP.
 email: kuntoaji@kaklabs.com
 executables:
 - docheck
 extensions: []
 extra_rdoc_files:
-- README.rdoc
 - LICENSE
+- README.rdoc
 files:
-- ".gitignore"
-- Gemfile
-- Gemfile.lock
+- CHANGELOG.md
 - LICENSE
 - README.rdoc
-- Rakefile
-- bin/docheck
-- docheck.gemspec
+- data/rdap_dns.json
+- exe/docheck
 - lib/docheck.rb
 - lib/docheck/application.rb
-- lib/docheck/command.rb
+- lib/docheck/bootstrap.rb
+- lib/docheck/checker.rb
+- lib/docheck/cli.rb
+- lib/docheck/errors.rb
+- lib/docheck/http_client.rb
+- lib/docheck/name.rb
+- lib/docheck/result.rb
 - lib/docheck/version.rb
-- test/docheck_test.rb
-- test/helper.rb
-homepage: http://github.com/kuntoaji/docheck
-licenses: []
-metadata: {}
-post_install_message: 
+homepage: https://github.com/kuntoaji/docheck
+licenses:
+- MIT
+metadata:
+  source_code_uri: https://github.com/kuntoaji/docheck
+  changelog_uri: https://github.com/kuntoaji/docheck/blob/master/CHANGELOG.md
+  bug_tracker_uri: https://github.com/kuntoaji/docheck/issues
+  rubygems_mfa_required: 'true'
 rdoc_options:
 - "--main"
 - README.rdoc
@@ -74,15 +51,14 @@ required_ruby_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
-      version: 1.9.2
+      version: '3.2'
 required_rubygems_version: !ruby/object:Gem::Requirement
   requirements:
   - - ">="
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.0.3
-signing_key: 
+rubygems_version: 4.0.20
 specification_version: 4
 summary: Domain name availability checker
 test_files: []

data/.gitignore

@@ -1,3 +0,0 @@
-*~
-*.swp
-*.swo

data/Gemfile

@@ -1,3 +0,0 @@
-source "http://rubygems.org"
-
-gemspec

data/Gemfile.lock

@@ -1,39 +0,0 @@
-PATH
-  remote: .
-  specs:
-    docheck (1.1.2)
-      whois (= 3.6.5)
-
-GEM
-  remote: http://rubygems.org/
-  specs:
-    activesupport (5.2.3)
-      concurrent-ruby (~> 1.0, >= 1.0.2)
-      i18n (>= 0.7, < 2)
-      minitest (~> 5.1)
-      tzinfo (~> 1.1)
-    concurrent-ruby (1.1.5)
-    i18n (1.6.0)
-      concurrent-ruby (~> 1.0)
-    minitest (5.11.3)
-    shoulda (3.6.0)
-      shoulda-context (~> 1.0, >= 1.0.1)
-      shoulda-matchers (~> 3.0)
-    shoulda-context (1.2.2)
-    shoulda-matchers (3.1.3)
-      activesupport (>= 4.0.0)
-    thread_safe (0.3.6)
-    tzinfo (1.2.5)
-      thread_safe (~> 0.1)
-    whois (3.6.5)
-      activesupport (>= 3)
-
-PLATFORMS
-  ruby
-
-DEPENDENCIES
-  docheck!
-  shoulda (~> 3.6.0)
-
-BUNDLED WITH
-   1.17.2

data/Rakefile

@@ -1,2 +0,0 @@
-require 'bundler'
-Bundler::GemHelper.install_tasks

data/bin/docheck

@@ -1,3 +0,0 @@
-#!/usr/bin/env ruby
-
-require File.expand_path('../../lib/docheck/command.rb', __FILE__)

data/docheck.gemspec

@@ -1,28 +0,0 @@
-# -*- encoding: utf-8 -*-
-$:.push File.expand_path("../lib", __FILE__)
-require "docheck/version"
-
-Gem::Specification.new do |s|
-  s.name        = "docheck"
-  s.version     = Docheck::VERSION
-  s.platform    = Gem::Platform::RUBY
-  s.authors     = "Kunto Aji Kristianto"
-  s.email       = 'kuntoaji@kaklabs.com'
-  s.homepage    = "http://github.com/kuntoaji/docheck"
-  s.summary     = 'Domain name availability checker'
-  s.description = <<-EOF
-    Domain name availability checker.
-  EOF
-
-  s.files         = `git ls-files`.split("\n")
-  s.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
-  s.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
-  s.require_paths = ["lib"]
-
-  s.rdoc_options = ['--main', 'README.rdoc']
-  s.extra_rdoc_files = ['README.rdoc', 'LICENSE']
-
-  s.required_ruby_version = '>= 1.9.2'
-  s.add_dependency('whois', '3.6.5')
-  s.add_development_dependency('shoulda', '~> 3.6.0')
-end

data/lib/docheck/command.rb

@@ -1,31 +0,0 @@
-begin
-  require File.expand_path('../../docheck.rb', __FILE__)
-rescue LoadError
-  require 'rubygems'
-  require File.expand_path('../../docheck.rb', __FILE__)
-end
-
-require 'optparse'
-
-begin
-  OptionParser.new do |opts|
-    opts.banner = "Usage: docheck -n [basename]. Example: docheck -n google"
-
-    opts.on("-v", "--version", "Show version") do
-      puts "Docheck #{Docheck::VERSION}"
-    end
-
-    opts.on("-n", "--name NAME", "Execute domain name checker") do |name|
-      Docheck::Application.new(name).print
-    end
-
-    opts.on_tail("-h", "--help", "Show help") do
-      puts opts
-      exit
-    end
-  end.parse!
-rescue OptionParser::InvalidOption
-  puts "Invalid option"
-rescue OptionParser::MissingArgument
-  puts "Missing argument"
-end