irrc 0.1.0

data/lib/irrc/query_status.rb

@@ -0,0 +1,19 @@
+module Irrc
+  module QueryStatus
+    def fail
+      @failed = true
+    end
+
+    def success
+      @failed = false
+    end
+
+    def failed?
+      @failed
+    end
+
+    def succeeded?
+      @failed == false
+    end
+  end
+end

data/lib/irrc/runner.rb

@@ -0,0 +1,37 @@
+module Irrc
+  module Runner
+    def run
+      done = []
+
+      loop do
+        if queue.empty?
+          close
+          return done
+        end
+
+        query = queue.pop
+        connect unless established?
+
+        begin
+          process query
+          query.success
+        rescue
+          logger.error $!.message
+          query.fail
+        end
+
+        done << query
+      end
+    end
+
+
+    private
+
+    def execute(command)
+      return if command.nil? || command == ''
+
+      logger.debug "Executing: #{command}"
+      connection.cmd(command).tap {|result| logger.debug "Returned: #{result}" }
+    end
+  end
+end

data/lib/irrc/socket.rb

@@ -0,0 +1,5 @@
+require 'socket'
+
+class Socket
+  TCP_INFO ||= 11
+end

data/lib/irrc/subquery.rb

@@ -0,0 +1,24 @@
+module Irrc
+  module Subquery
+    # Public: Generate a child query to resolve IRR / Whois object recursively.
+    #
+    # object  - IRR / Whois object to extract. (eg: as-set, route-set, aut-num object)
+    def fork(object)
+      Query.new(object, source: sources, protocol: protocols).tap {|q|
+        q.parent = self
+      }
+    end
+
+    # Public: Returns the parent (associated) Query object, which is probably as-set.
+    def parent
+      @_parent
+    end
+
+    # Public: Set a parent (associated) Query object, which is probably as-set.
+    #
+    # parent - Parent Query object.
+    def parent=(parent)
+      @_parent = parent
+    end
+  end
+end

data/lib/irrc/version.rb

@@ -0,0 +1,3 @@
+module Irrc
+  VERSION = '0.1.0'
+end

data/lib/irrc/whoisd.rb

@@ -0,0 +1 @@
+require 'irrc/whoisd/client'

data/lib/irrc/whoisd/api.rb

@@ -0,0 +1,54 @@
+require 'irrc/irr'
+
+module Irrc
+  module Whoisd
+    module Api
+      private
+
+      def expand_set_command(as_set, sources, type)
+        "-k -r #{source_option(sources)} -T #{type} #{as_set}"
+      end
+
+      def parse_objects_from_set(result)
+        if result =~ error_code
+          raise $1
+        end
+
+        result.scan(Irrc::Irr.members_tag).flatten.map {|i| i.split /\s*,?\s+/ }.flatten
+      end
+
+      def expand_route_set_command(route_set, sources)
+        if sources && !sources.empty?
+          "-k -r -s #{sources.join(',')} -T route-set #{route_set}"
+        else
+          "-k -r -a -T route-set #{route_set}"
+        end
+      end
+
+      def expand_aut_num_command(autnum, sources)
+        "-k -r #{source_option(sources)} -K -i origin #{autnum}"
+      end
+
+      def parse_prefixes_from_aut_num(result, protocol)
+       result.scan(Irrc::Irr.route_tag(protocol)).flatten.uniq
+      end
+
+      # See http://www.ripe.net/data-tools/support/documentation/ripe-database-query-reference-manual#a1--ripe-database-query-server-response-codes-and-messages for the error code
+      def error_code
+        /^%ERROR:(.*)$/
+      end
+
+      def return_code
+        /\n\n\n/
+      end
+
+      def source_option(sources)
+        if sources && !sources.empty?
+          "-s #{sources.join(',')}"
+        else
+          '-a'
+        end
+      end
+    end
+  end
+end

data/lib/irrc/whoisd/client.rb

@@ -0,0 +1,88 @@
+require 'net/telnet'
+
+require 'irrc/connecting'
+require 'irrc/logging'
+require 'irrc/parameter'
+require 'irrc/prefix'
+require 'irrc/runner'
+require 'irrc/socket'
+require 'irrc/whoisd/api'
+
+module Irrc
+  module Whoisd
+
+    # Public: Whoisd client worker.
+    class Client
+      include Irrc::Connecting
+      include Irrc::Logging
+      include Irrc::Parameter
+      include Irrc::Prefix
+      include Irrc::Runner
+      include Irrc::Whoisd::Api
+
+      attr_reader :host, :queue
+
+
+      private
+
+      def process(query)
+        case query.object_type
+        when 'as-set'
+          query.add_aut_num_result objects_from_set(query, 'as-set')
+          resolve_prefixes_from_aut_nums query
+        when 'route-set'
+          resolve_prefixes_from_route_set query
+        when 'aut-num'
+          query.add_aut_num_result query.object
+          resolve_prefixes_from_aut_nums query
+        end
+      end
+
+      def objects_from_set(query, type)
+        command = expand_set_command(query.object, query.sources, type)
+        cache(query.object) {
+          result = execute(command)
+          parse_objects_from_set(result).map {|object|
+            expand_if_necessary(query.fork(object), type)
+          }.flatten.uniq.compact
+        }
+      rescue
+        raise "'#{command}' failed on '#{host}' (#{$!.message})."
+      end
+
+      def expand_if_necessary(query, type)
+        if query.object_type == type
+          objects_from_set(query, type)
+        else
+          query.object
+        end
+      end
+
+      def resolve_prefixes_from_route_set(query)
+        prefixes = classify_by_protocol(objects_from_set(query, 'route-set'))
+        query.protocols.each do |protocol|
+          query.add_prefix_result prefixes[protocol], nil, protocol
+        end
+      end
+
+      def resolve_prefixes_from_aut_nums(query)
+        unless query.protocols.empty?
+          # ipv4 and ipv6 should have the same result so far
+          (query.result[:ipv4] || query.result[:ipv6]).keys.each do |autnum|
+            command = expand_aut_num_command(autnum, query.sources)
+            result = execute(command)
+
+            query.protocols.each do |protocol|
+              query.add_prefix_result parse_prefixes_from_aut_num(result, protocol), autnum, protocol
+            end
+          end
+        end
+      end
+
+      def cache(object, &block)
+        @_cache ||= {}
+        @_cache[object] ||= yield
+      end
+    end
+  end
+end

data/spec/features/irr_as_set_resolution_spec.rb

@@ -0,0 +1,193 @@
+require 'spec_helper'
+
+describe 'IRR as-set resolution' do
+  include_context 'irr queries'
+
+  context 'When FQDN specified for IRR server' do
+    subject { send_query(irr_fqdn, 'AS-JPNIC') }
+
+    it 'returns ipv4 and ipv6 prefixes by default' do
+      expect(subject['AS-JPNIC'][:ipv4]['AS2515']).to include '192.41.192.0/24', '202.12.30.0/24',
+      '211.120.240.0/21', '211.120.248.0/24'
+      expect(subject['AS-JPNIC'][:ipv6]['AS2515']).to include '2001:dc2::/32', '2001:0fa0::/32'
+    end
+  end
+
+  context 'When a name specified for IRR server' do
+    subject { send_query(irr, as_set) }
+
+    it 'returns the same result as if the FQDN specified' do
+      expect(subject).to eq send_query(irr_fqdn, as_set)
+    end
+  end
+
+  it 'gently closes connections to IRR server' do
+    expect_any_instance_of(Irrc::Irrd::Client).to receive(:close)
+    send_query(irr_fqdn, as_set)
+  end
+
+  describe 'Fintering by Authoritative IRR server' do
+    subject { send_query(:jpirr, 'AS-JPNIC', source: :apnic) }
+
+    it 'returns nothing' do
+      expect(subject).to eq({})
+    end
+  end
+
+  context 'When as-set resolution is done but something wrong while further processes' do
+    subject { send_query(irr, as_set) }
+    before do
+      allow_any_instance_of(Irrc::Irrd::Client).to receive(:resolve_prefixes_from_aut_nums){ raise }
+    end
+
+    it 'ignores a halfway result' do
+      expect(subject).to eq({})
+    end
+  end
+
+  context 'When only ipv4 is specified for protocol' do
+    subject { send_query(irr, as_set, protocol: :ipv4) }
+
+    it 'returns nothing about ipv6' do
+      expect(subject[as_set][:ipv6]).to be_nil
+    end
+  end
+
+  context 'When nil specified for protocol' do
+    subject { send_query(irr, as_set, protocol: nil) }
+
+    it 'returns nothing about the as-set' do
+      expect(subject[as_set]).to eq({})
+    end
+  end
+
+  context 'When blank protocol specified' do
+    subject { send_query(irr, as_set, protocol: []) }
+
+    it 'returns nothing about the as-set' do
+      expect(subject[as_set]).to eq({})
+    end
+  end
+
+  context 'When an invalid protocol specified' do
+    subject { send_query(irr, as_set, protocol: :invalid) }
+
+    it 'reports an ArgumentError' do
+      expect { subject }.to raise_error ArgumentError
+    end
+  end
+
+  context 'When a non-mirrored server specified for authoritative IRR server' do
+    subject { send_query(irr, as_set, source: :outsider) }
+
+    it 'returns nothing' do
+      expect(subject).to eq({})
+    end
+  end
+
+  context 'When nil specified for authoritative IRR server' do
+    subject { send_query(irr, as_set, source: nil) }
+
+    it 'returns a result without any filter of authoritative IRR server' do
+      expect(subject).to eq send_query(irr, as_set)
+    end
+  end
+
+  context 'When blank authoritative IRR server specified' do
+    subject { send_query(irr, as_set, source: []) }
+
+    it 'returns a result without any filter of authoritative IRR server' do
+      expect(subject).to eq send_query(irr, as_set)
+    end
+  end
+
+  context 'When non-existent IRR object specified' do
+    subject { send_query(irr, 'AS-NON-EXISTENT') }
+
+    it 'ignores the IRR error' do
+      expect(subject).to eq({})
+    end
+  end
+
+  context 'When invalid IRR server name specified' do
+    subject { send_query(:invalid, as_set) }
+
+    it 'reports an error' do
+      expect { subject }.to raise_error
+    end
+  end
+
+  context 'When non-resolvable IRR server fqdn specified' do
+    subject { send_query('non-resolvable.localdomain', as_set) }
+
+    it 'reports an error' do
+      expect { subject }.to raise_error
+    end
+  end
+
+  context 'When unreachable IRR server specified' do
+    subject { send_query('192.0.2.1', as_set) }
+
+    it 'reports an error' do
+      expect { subject }.to raise_error
+    end
+  end
+
+  context 'When specifing an IRR server out of service' do
+    subject { send_query('127.0.0.1', as_set) }
+
+    it 'reports an error' do
+      expect { subject }.to raise_error
+    end
+  end
+
+  describe 'NOTE: These may fail due to Whois database changes, not code. Check Whois database if fails.' do
+    describe 'route-set' do
+      subject { send_query(irr, 'RS-RC-26462') }
+
+      it 'returns the same result as Whois database' do
+        expect(subject['RS-RC-26462']).to eq(
+          {:ipv4=>{nil=>["137.238.0.0/16"]}, :ipv6=>{nil=>[]}}
+        )
+      end
+    end
+
+    describe 'nested as-set' do
+      subject { send_query(irr, 'AS-PDOXUPLINKS', source: :apnic) }
+
+      it 'returns the same result as Whois database' do
+        expect(subject['AS-PDOXUPLINKS']).to eq(
+          {:ipv4=>
+             {"AS703"=>[],
+              "AS1221"=>["203.92.26.0/24", "155.143.128.0/17"],
+              "AS2764"=>[],
+              "AS7474"=>[],
+              "AS7657"=>[],
+              "AS4565"=>[],
+              "AS5650"=>[],
+              "AS6461"=>[]},
+           :ipv6=>
+             {"AS703"=>[],
+              "AS1221"=>[],
+              "AS2764"=>[],
+              "AS7474"=>[],
+              "AS7657"=>[],
+              "AS4565"=>[],
+              "AS5650"=>[],
+              "AS6461"=>[]}}
+        )
+      end
+    end
+
+    describe 'nested route-set' do
+      subject { send_query(irr, 'RS-RR-COUDERSPORT') }
+
+      it 'returns the same result as Whois database' do
+        expect(subject['RS-RR-COUDERSPORT']).to eq(
+          {:ipv4=>{nil=>["107.14.160.0/20", "71.74.32.0/20", "75.180.128.0/19"]},
+           :ipv6=>{nil=>[]}}
+        )
+      end
+    end
+  end
+end

data/spec/features/irr_invalid_object_resolution_spec.rb

@@ -0,0 +1,32 @@
+require 'spec_helper'
+
+describe 'IRR Invalid object resolution' do
+  include_context 'irr queries'
+
+  describe 'Try as-jpnic with JPIRR' do
+    context 'When invalid object specified' do
+      subject { send_query(irr, 'INVALID') }
+
+      it "doesn't report an error" do
+        expect(subject['INVALID']).to eq({})
+      end
+    end
+
+    context 'When a blank String given for IRR object to resolve' do
+      subject { send_query(irr, '') }
+
+      it "doesn't report an error" do
+        expect(subject['']).to eq({})
+      end
+    end
+
+    context 'When nil given for IRR object to resolve' do
+      subject { send_query(irr, nil) }
+
+      it 'does nothing even reporting the error' do
+        expect_any_instance_of(Irrc::Irrd::Client).not_to receive(:connect)
+        expect(subject).to eq({})
+      end
+    end
+  end
+end