irrc 0.1.0 → 0.2.0

data/bin/irrc

@@ -1,5 +0,0 @@
-#!/usr/bin/env ruby -Ilib
-
-require 'irrc/cli'
-
-Irrc::Cli::Client.new(ARGV).start

data/lib/irrc/cli.rb

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

data/lib/irrc/cli/client.rb

@@ -1,108 +0,0 @@
-require 'optparse'
-
-require 'irrc'
-require 'irrc/cli/yaml_printer'
-
-module Irrc
-  module Cli
-    class Client
-      def initialize(args)
-        @args = args
-        @options = Struct.new(:host, :source, :protocol, :threads, :debug).new(nil, [], [], 1, nil)
-      end
-
-      def start
-        OptionParser.new(&method(:options)).parse!(@args)
-
-        verify_arguments
-        set_default_arguments
-
-        Irrc::Cli::YamlPrinter.print perform
-
-      rescue
-        $stderr.print "#{$!.class}: " unless $!.instance_of?(RuntimeError)
-        $stderr.puts $!.message
-
-        exit 1
-      end
-
-
-      private
-
-      def options(opts)
-        opts.banner = <<-EOS
-Usage: #{opts.program_name} [options] [objects ...]
-
-Description:
-  Better IRR client to resolve as-set, route-set or aut-num object into prefixes.
-
-  If no [-4|-6|--ipv4|--ipv6] option given, it tries both of ipv4 and ipv6.
-
-Options:
-        EOS
-
-        opts.on '-h HOST', 'Specify FQDN of IRR / Whois server to send queries.',
-                           'IRR / Whois name is also acceptable. This switch is mandatory.' do |host|
-          @options.host = host
-        end
-
-        opts.on '-s SOURCE', '--source', 'Specify an authoritative IRR / Whois source name.',
-                                         'Multiply this option for multiple SOURCE.',
-                                         "eg) #{opts.program_name} -s jpirr -s radb AS-JPNIC" do |source|
-          @options.source |= [source]
-        end
-
-        opts.on '-4', '--ipv4', 'Resolve IPv4 prefixes.' do
-          @options.protocol |= [:ipv4]
-        end
-
-        opts.on '-6', '--ipv6', 'Resolve IPv6 prefixes.' do
-          @options.protocol |= [:ipv6]
-        end
-
-        opts.on '-t NUMBER', '--threads', 'Number of threads to resolve prefixes per IRR / Whois server.' do |threads|
-          @options.threads = threads
-        end
-
-        opts.on '-d', '--debug', 'Print raw queries, answers and additional informations.' do
-          @options.debug = true
-        end
-      end
-
-      def verify_arguments
-        if @args.empty?
-          $stderr.puts <<-EOS
-Missing Argument: objects required.
-
-Use --help for usage.
-          EOS
-          exit 1
-        end
-
-        unless @options.host
-          $stderr.puts <<-EOS
-Missing Argument: -h option is required.
-
-Use --help for usage.
-          EOS
-          exit 1
-        end
-      end
-
-      def set_default_arguments
-        @options.protocol = [:ipv4, :ipv6] if @options.protocol.empty?
-      end
-
-      def perform
-        client = if @options.debug
-                   Irrc::Client.new(@options.threads) {|c| c.logger = Logger.new(STDERR) }
-                 else
-                   Irrc::Client.new(@options.threads)
-                 end
-
-        client.query(@options.host, @args, source: @options.source, protocol: @options.protocol)
-        client.perform
-      end
-    end
-  end
-end

data/lib/irrc/cli/yaml_printer.rb

@@ -1,13 +0,0 @@
-require 'yaml'
-
-module Irrc
-  module Cli
-    class YamlPrinter
-      class << self
-        def print(hash)
-          puts hash.to_yaml
-        end
-      end
-    end
-  end
-end

data/spec/features/irr_as_set_resolution_spec.rb

@@ -1,193 +0,0 @@
-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

@@ -1,32 +0,0 @@
-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

data/spec/features/whois_as_set_resolution_spec.rb

@@ -1,193 +0,0 @@
-require 'spec_helper'
-
-describe 'Whois as-set resolution' do
-  include_context 'whois queries'
-
-  context 'When FQDN specified for Whois server' do
-    subject { send_query(whois_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 Whois server' do
-    subject { send_query(whois, as_set) }
-
-    it 'returns the same result as if the FQDN specified' do
-      expect(subject).to eq send_query(whois_fqdn, as_set)
-    end
-  end
-
-  it 'gently closes connections to Whois server' do
-    expect_any_instance_of(Irrc::Whoisd::Client).to receive(:close)
-    send_query(whois_fqdn, as_set)
-  end
-
-  describe 'Fintering by Authoritative Whois 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(whois, as_set) }
-    before do
-      allow_any_instance_of(Irrc::Whoisd::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(whois, 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(whois, 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(whois, 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(whois, 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 Whois server' do
-    subject { send_query(whois, as_set, source: :outsider) }
-
-    it 'returns nothing' do
-      expect(subject).to eq({})
-    end
-  end
-
-  context 'When nil specified for authoritative Whois server' do
-    subject { send_query(whois, as_set, source: nil) }
-
-    it 'returns a result without any filter of authoritative Whois server' do
-      expect(subject).to eq send_query(whois, as_set)
-    end
-  end
-
-  context 'When blank authoritative Whois server specified' do
-    subject { send_query(whois, as_set, source: []) }
-
-    it 'returns a result without any filter of authoritative Whois server' do
-      expect(subject).to eq send_query(whois, as_set)
-    end
-  end
-
-  context 'When non-existent Whois object specified' do
-    subject { send_query(whois, 'AS-NON-EXISTENT') }
-
-    it 'ignores the Whois error' do
-      expect(subject).to eq({})
-    end
-  end
-
-  context 'When invalid Whois 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 Whois 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 Whois 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 Whois 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(whois, '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=>["2620:0:5080::/48"]}}
-        )
-      end
-    end
-
-    describe 'nested as-set' do
-      subject { send_query(whois, 'AS-PDOXUPLINKS', source: :apnic) }
-
-      it 'returns the same result as Whois database' do
-        expect(subject['AS-PDOXUPLINKS']).to eq(
-          {:ipv4=>
-             {"AS703"=>[],
-              "AS1221"=>["155.143.128.0/17", "203.92.26.0/24"],
-              "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(whois, 'RS-RR-COUDERSPORT') }
-
-      it 'returns the same result as Whois database' do
-        expect(subject['RS-RR-COUDERSPORT']).to eq(
-          {:ipv4=>{nil=>["71.74.32.0/20", "75.180.128.0/19", "107.14.160.0/20"]},
-           :ipv6=>{nil=>[]}}
-        )
-      end
-    end
-  end
-end