nayutaya-webhook-dispatcher 0.0.1 → 0.0.2

data/Rakefile

@@ -5,10 +5,11 @@ task :default => [:test]
 
 Rake::TestTask.new do |test|
   test.libs << "test"
-  test.test_files = Dir.glob("test/*_test.rb")
+  test.test_files = Dir.glob("test/**/*_test.rb")
   test.verbose    =  true
 end
 
+desc "Generate gemspec file from template"
 task :gemspec do
   require "erb"
   require "lib/webhook-dispatcher/version"
@@ -19,8 +20,14 @@ task :gemspec do
   version = WebHookDispatcher::VERSION
   date    = Time.now.strftime("%Y-%m-%d")
 
-  files      = Dir.glob("**/*").select { |s| File.file?(s) }
-  test_files = Dir.glob("test/**").select { |s| File.file?(s) }
+  files = Dir.glob("**/*").
+    select { |path| File.file?(path) }.
+    reject { |path| /^nbproject\// =~ path }.
+    sort
+
+  test_files = Dir.glob("test/**.rb").
+    select { |path| File.file?(path) }.
+    sort
 
   File.open("webhook-dispatcher.gemspec", "wb") { |file|
     file.write(erb.result(binding))

data/example.rb

@@ -1,47 +1,17 @@
 
 # このスクリプトはイメージであり、動作しません
 
-WebHookPublisher.open_timeout = 5 # sec
-WebHookPublisher.read_timeout = 5 # sec
-WebHookPublisher.user_agent = "hoge"
-WebHookPublisher.acl = x
-WebHookPublisher.acl_with {
-}
+require "webhook-dispatcher"
 
-wp = WebHookPublisher.new
-wp.open_timeout = 5 # sec
-wp.read_timeout = 5 # sec
-wp.user_agent = "hoge"
-wp.acl = WebHookPublisher::Acl.with {
-  allow :all
-  allow "*", :all
-  allow "*", 1024..3000
-  allow "*", 0..1024
-  allow "*", [1,2,3,4]
-  deny IPAdd.new("0.0.0.0/0")
-  allow "127.0.0.0/8"
-  allow "localhost"
-}
+p dispatcher = WebHookDispatcher.new
+p request = WebHookDispatcher::Request::Get.new(URI.parse("http://www.google.co.jp"))
 
-acl.clear
-acl.add_deny(...)
-acl.add_allow(...)
-acl.allow?(ipaddr)
-acl.deny?(ipaddr)
-acl.with { ... }
-
-
-request_obj = WebHookPublisher::Request.new(:get, URI.new(..))
-request_obj.http_method = :get
-request_obj.uri = uri
+p response = dispatcher.request(request)
 
+=begin
 res = wp.request(request_obj)
 res = wp.get(url)
 res = wp.head(url)
 res = wp.post(url, data)
 #=> WebHookPublisher::Response
-res.success? #=> true/false
-res.status #=> :timeout
-res.status_code #=> 200
-res.status_message #=> OK
-res.inner_exception #=> #<RuntimeError>
+=end

data/lib/webhook-dispatcher/acl/allow_entry.rb

@@ -0,0 +1,12 @@
+
+require "webhook-dispatcher/acl/entry_base"
+
+class WebHookDispatcher
+  class Acl
+    class AllowEntry < EntryBase
+      def value
+        return true
+      end
+    end
+  end
+end

data/lib/webhook-dispatcher/acl/deny_entry.rb

@@ -0,0 +1,12 @@
+
+require "webhook-dispatcher/acl/entry_base"
+
+class WebHookDispatcher
+  class Acl
+    class DenyEntry < EntryBase
+      def value
+        return false
+      end
+    end
+  end
+end

data/lib/webhook-dispatcher/acl/entry_base.rb

@@ -0,0 +1,94 @@
+
+require "ipaddr"
+
+class WebHookDispatcher
+  class Acl
+    class EntryBase
+    end
+  end
+end
+
+class WebHookDispatcher::Acl::EntryBase
+  def initialize(options = nil)
+    case options
+    when nil, :all
+      @addr = nil
+      @name = nil
+      @port = nil
+    when Hash
+      options = options.dup
+      @addr = normalize_addr(options.delete(:addr))
+      @name = normalize_name(options.delete(:name))
+      @port = normalize_port(options.delete(:port))
+      raise(ArgumentError) unless options.empty?
+    else raise(ArgumentError)
+    end
+  end
+
+  attr_reader :addr, :name, :port
+
+  def ==(other)
+    return false unless other.instance_of?(self.class)
+    return (self.to_a == other.to_a)
+  end
+
+  def match?(addr, name, port)
+    return match_addr?(addr) && match_name?(name) && match_port?(port)
+  end
+
+  def value
+    raise(NotImplementedError)
+  end
+
+  def to_a
+    return [@addr, @name, @port]
+  end
+
+  private
+
+  def normalize_addr(addr)
+    case addr
+    when nil    then return nil
+    when :all   then return nil
+    when String then return IPAddr.new(addr)
+    when IPAddr then return addr
+    else raise(ArgumentError)
+    end
+  end
+
+  def normalize_name(name)
+    case name
+    when nil    then return nil
+    when :all   then return nil
+    when String then return name.downcase
+    when Regexp then return name
+    else raise(ArgumentError)
+    end
+  end
+
+  def normalize_port(port)
+    case port
+    when nil     then return nil
+    when :all    then return nil
+    when Integer then return [port]
+    when Array   then return port.sort
+    when Range   then return port
+    else raise(ArgumentError)
+    end
+  end
+
+  def match_addr?(addr)
+    return true if self.addr.nil?
+    return (!addr.nil? && self.addr.include?(addr))
+  end
+
+  def match_name?(name)
+    return true if self.name.nil?
+    return (!name.nil? && (self.name === name.downcase))
+  end
+
+  def match_port?(port)
+    return true if self.port.nil?
+    return (!port.nil? && self.port.include?(port))
+  end
+end

data/lib/webhook-dispatcher/acl.rb

@@ -1,26 +1,62 @@
 
 require "ipaddr"
+require "webhook-dispatcher/acl/allow_entry"
+require "webhook-dispatcher/acl/deny_entry"
 
 class WebHookDispatcher::Acl
   def initialize
-    @records = []
+    @entries = []
   end
 
   def self.with(&block)
     return self.new.with(&block)
   end
 
+  def self.allow_all
+    return self.with { allow :all }
+  end
+
+  def self.deny_all
+    return self.with { deny :all }
+  end
+  
+  def self.ipaddr?(value)
+    return true if value.instance_of?(IPAddr)
+    begin
+      IPAddr.new(value)
+      return true
+    rescue ArgumentError
+      return false
+    end
+  end
+
+  def self.create_matching_targets(addr_or_name, port)
+    if self.ipaddr?(addr_or_name)
+      addr = addr_or_name
+      return [[IPAddr.new(addr), nil, port]]
+    else
+      name = addr_or_name
+      _name, _aliases, _type, *addresses = TCPSocket.gethostbyname(name)
+      return addresses.map { |addr| [IPAddr.new(addr), name, port] }
+    end
+  end
+
+  def ==(other)
+    return false unless other.instance_of?(self.class)
+    return (@entries == other.instance_eval { @entries })
+  end
+
   def size
-    return @records.size
+    return @entries.size
   end
 
-  def add_allow(ipaddr)
-    @records << AllowRecord.new(ipaddr)
+  def add_allow(options)
+    @entries << AllowEntry.new(options)
     return self
   end
 
-  def add_deny(ipaddr)
-    @records << DenyRecord.new(ipaddr)
+  def add_deny(options)
+    @entries << DenyEntry.new(options)
     return self
   end
 
@@ -31,8 +67,8 @@ class WebHookDispatcher::Acl
 
     this = self
     (class << obj; self; end).class_eval {
-      define_method(:allow) { |ipaddr| this.add_allow(ipaddr) }
-      define_method(:deny)  { |ipaddr| this.add_deny(ipaddr) }
+      define_method(:allow) { |options| this.add_allow(options) }
+      define_method(:deny)  { |options| this.add_deny(options) }
       private :allow, :deny
     }
 
@@ -41,44 +77,18 @@ class WebHookDispatcher::Acl
     return self
   end
 
-  def allow?(ipaddr)
-    return @records.inject(true) { |result, record|
-      result = record.value if record.include?(ipaddr)
-      result
-    }
-  end
-
-  def deny?(ipaddr)
-    return !self.allow?(ipaddr)
-  end
-
-  class RecordBase
-    def initialize(ipaddr)
-      @ipaddr =
-        case ipaddr
-        when :all   then IPAddr.new("0.0.0.0/0")
-        when String then IPAddr.new(ipaddr)
-        when IPAddr then ipaddr
-        else raise(ArgumentError, "invalid IP address")
-        end
-    end
-
-    attr_reader :ipaddr
-
-    def include?(ipaddr)
-      return @ipaddr.include?(ipaddr)
-    end
-  end
+  def allow?(addr_or_name, port = nil)
+    targets = self.class.create_matching_targets(addr_or_name, port)
 
-  class AllowRecord < RecordBase
-    def value
-      return true
-    end
+    return targets.all? { |taddr, tname, tport|
+      @entries.inject(true) { |result, entry|
+        result = entry.value if entry.match?(taddr, tname, tport)
+        result
+      }
+    }
   end
 
-  class DenyRecord < RecordBase
-    def value
-      return false
-    end
+  def deny?(addr_or_name, port = nil)
+    return !self.allow?(addr_or_name, port)
   end
 end

data/lib/webhook-dispatcher/core.rb

@@ -1,3 +1,110 @@
 
+require "net/http"
+require "webhook-dispatcher/version"
+require "webhook-dispatcher/acl"
+require "webhook-dispatcher/request/get"
+require "webhook-dispatcher/request/head"
+require "webhook-dispatcher/request/post"
+require "webhook-dispatcher/response"
+
 class WebHookDispatcher
+  def initialize(options = {})
+    options = options.dup
+    @open_timeout = options.delete(:open_timeout) || self.class.open_timeout || self.class.default_open_timeout
+    @read_timeout = options.delete(:read_timeout) || self.class.read_timeout || self.class.default_read_timeout
+    @user_agent   = options.delete(:user_agent)   || self.class.user_agent   || self.class.default_user_agent
+    @acl          = options.delete(:acl)          || self.class.acl          || self.class.default_acl
+    raise(ArgumentError, "invalid parameter") unless options.empty?
+  end
+
+  class << self
+    @open_timeout = nil
+    @read_timeout = nil
+    @user_agent   = nil
+    @acl          = nil
+
+    attr_accessor :open_timeout, :read_timeout, :user_agent, :acl
+
+    define_method(:default_open_timeout) { 10 }
+    define_method(:default_read_timeout) { 10 }
+    define_method(:default_user_agent)   { "webhook-dispatcher #{self::VERSION}" }
+    define_method(:default_acl)          { Acl.new }
+
+    def acl_with(&block)
+      self.acl = Acl.with(&block)
+    end
+  end
+
+  attr_accessor :open_timeout, :read_timeout, :user_agent, :acl
+
+  def acl_with(&block)
+    self.acl = Acl.with(&block)
+  end
+
+  def request(request)
+    http_conn = request.create_http_connector
+    http_req  = request.create_http_request
+    setup_http_connector(http_conn)
+    setup_http_request(http_req)
+
+    begin
+      if @acl.deny?(http_conn.address, http_conn.port)
+        return Response.new(
+          :status    => :denied,
+          :message   => "denied.")
+      end
+
+      http_res = http_conn.start { http_conn.request(http_req) }
+
+      return Response.new(
+        :status    => (http_res.kind_of?(Net::HTTPSuccess) ? :success : :failure),
+        :http_code => http_res.code.to_i,
+        :message   => http_res.message)
+    rescue TimeoutError => e
+      return Response.new(
+        :status    => :timeout,
+        :message   => "timeout.",
+        :exception => e)
+    rescue Errno::ECONNREFUSED => e
+      return Response.new(
+        :status    => :refused,
+        :message   => "connection refused.",
+        :exception => e)
+    rescue Errno::ECONNRESET => e
+      return Response.new(
+        :status    => :reset,
+        :message   => "connection reset by peer.",
+        :exception => e)
+    rescue => e
+      return Response.new(
+        :status    => :error,
+        :message   => "#{e.class}: #{e.message}",
+        :exception => e)
+    end
+  end
+
+  def get(uri)
+    return self.request(Request::Get.new(uri))
+  end
+
+  def head(uri)
+    return self.request(Request::Head.new(uri))
+  end
+
+  def post(uri, body = nil)
+    return self.request(Request::Post.new(uri, body))
+  end
+
+  private
+
+  def setup_http_connector(http_conn)
+    http_conn.open_timeout = self.open_timeout
+    http_conn.read_timeout = self.read_timeout
+    return http_conn
+  end
+
+  def setup_http_request(http_request)
+    http_request["User-Agent"] = self.user_agent
+    http_request
+  end
 end

data/lib/webhook-dispatcher/request/base.rb

@@ -1,5 +1,6 @@
 
 require "uri"
+require "webhook-dispatcher/core"
 
 class WebHookDispatcher
   module Request
@@ -12,4 +13,12 @@ class WebHookDispatcher::Request::Base
   end
 
   attr_accessor :uri
+
+  def create_http_connector
+    return Net::HTTP.new(self.uri.host, self.uri.port)
+  end
+
+  def create_http_request
+    raise(NotImplementedError)
+  end
 end

data/lib/webhook-dispatcher/request/get.rb

@@ -5,4 +5,8 @@ class WebHookDispatcher::Request::Get < WebHookDispatcher::Request::Base
   def initialize(uri)
     super(uri)
   end
+
+  def create_http_request
+    return Net::HTTP::Get.new(self.uri.request_uri)
+  end
 end

data/lib/webhook-dispatcher/request/head.rb

@@ -0,0 +1,12 @@
+
+require "webhook-dispatcher/request/base"
+
+class WebHookDispatcher::Request::Head < WebHookDispatcher::Request::Base
+  def initialize(uri)
+    super(uri)
+  end
+
+  def create_http_request
+    return Net::HTTP::Head.new(self.uri.request_uri)
+  end
+end

data/lib/webhook-dispatcher/request/post.rb

@@ -0,0 +1,17 @@
+
+require "webhook-dispatcher/request/base"
+
+class WebHookDispatcher::Request::Post < WebHookDispatcher::Request::Base
+  def initialize(uri, body = nil)
+    super(uri)
+    @body = body
+  end
+
+  attr_accessor :body
+
+  def create_http_request
+    req = Net::HTTP::Post.new(self.uri.request_uri)
+    req.body = self.body
+    return req
+  end
+end

data/lib/webhook-dispatcher/response.rb

@@ -2,7 +2,6 @@
 class WebHookDispatcher::Response
   def initialize(options = {})
     options = options.dup
-    @success   = (options.delete(:success) == true)
     @status    = options.delete(:status)    || :unknown
     @http_code = options.delete(:http_code) || nil
     @message   = options.delete(:message)   || nil
@@ -10,9 +9,9 @@ class WebHookDispatcher::Response
     raise(ArgumentError, "invalid parameter") unless options.empty?
   end
 
-  attr_reader :success, :status, :http_code, :message, :exception
+  attr_reader :status, :http_code, :message, :exception
 
   def success?
-    return self.success
+    return (self.status == :success)
   end
 end

data/lib/webhook-dispatcher/version.rb

@@ -1,4 +1,4 @@
 
 class WebHookDispatcher
-  VERSION = "0.0.1"
+  VERSION = "0.0.2"
 end

data/test/acl/allow_entry_test.rb

@@ -0,0 +1,17 @@
+
+require File.dirname(__FILE__) + "/../test_helper"
+require "webhook-dispatcher/acl/allow_entry"
+
+class AllowEntryTest < Test::Unit::TestCase
+  def setup
+    @klass = WebHookDispatcher::Acl::AllowEntry
+  end
+
+  #
+  # インスタンスメソッド
+  #
+
+  def test_value
+    assert_equal(true, @klass.new.value)
+  end
+end

data/test/acl/deny_entry_test.rb

@@ -0,0 +1,13 @@
+
+require File.dirname(__FILE__) + "/../test_helper"
+require "webhook-dispatcher/acl/deny_entry"
+
+class DenyEntryTest < Test::Unit::TestCase
+  def setup
+    @klass = WebHookDispatcher::Acl::DenyEntry
+  end
+
+  def test_value
+    assert_equal(false, @klass.new.value)
+  end
+end