waithook 0.1 → 0.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 119debffa9104d9f4b3b0c1d2a943840a0bb1aaa
-  data.tar.gz: ee89ce35a2bc6a13a3517f9c524b108d53c36d16
+  metadata.gz: 2d3624c5bebd573d8f2e33f66d96d19b93acc3a9
+  data.tar.gz: 25d37ca7b8c923b24c04425ce35f75ed997d9033
 SHA512:
-  metadata.gz: e75927f077b2fa65d3a3af0855f314f68a4039996ae11ab641b1b2bdc58b43aaefa35196d2f6bf5728edde917729de5ed67880e58abcd85f3c57f6065a656e28
-  data.tar.gz: 07000675d72ef66ab760dde7d039e4fcbafa36186d4f06ecc18e0912ad4b829d89dcfb2454c110480f190dce8017cade2acba2adddac6548c69c48768e9f29c0
+  metadata.gz: 32a2181e21aa618a589c64d7dbd07132ebdc1942c4169bfe26019b8061d05ea18a494d0ffb8e2da343accba7307427c9c69742ed3a05477897ff3d91dd3de847
+  data.tar.gz: 3a96f332074cbd7a5e8364bcebbc42de580ca8575f39ad17c19c28d0f012320c09cd36e7df2d18ad664bd43a3852a682ad79bb608fd3ca7796fb4cf090f930b3

data/Gemfile.lock

@@ -2,7 +2,7 @@ PATH
   remote: .
   specs:
     waithook (0.1)
-      websocket (~> 1.2.3)
+      websocket (~> 1.2)
 
 GEM
   remote: https://rubygems.org/

data/bin/waithook

@@ -2,3 +2,49 @@
 
 $:.push(File.expand_path("../../lib", __FILE__))
 
+require 'optparse'
+
+def help_message
+  [
+    "Waithook command line client.",
+    "",
+    "Example usage:",
+    "    waithook waithook.herokuapp.com/my_path",
+    "    waithook waithook.herokuapp.com/my_path --forward http://localhost:3000/notify"
+  ].join("\n")
+end
+
+options = {}
+
+begin
+  OptionParser.new do |opts|
+    opts.banner = help_message + "\nOptions:"
+
+    opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+      options[:verbose] = v
+    end
+    opts.on("-f URL", "--forward URL", "Forward to HTTP server") do |value|
+      options[:forward] = value
+    end
+  end.parse!
+rescue OptionParser::InvalidOption => error
+  require 'waithook'
+  puts Waithook::WithColor.red(error.message)
+  puts "Please use --help to list of arguments"
+  exit 1
+end
+
+begin
+  require 'waithook'
+  if ARGV.first
+    Waithook::CLI.listen(ARGV.first, options)
+  else
+    puts Waithook::WithColor.red("URL is required\n")
+    puts help_message
+    exit 1
+  end
+rescue Waithook::CLI::ArgError => error
+  puts Waithook::WithColor.red(error.message)
+  puts help_message
+  exit 1
+end

data/lib/waithook/cli.rb

@@ -0,0 +1,64 @@
+class Waithook
+  module WithColor
+    extend self
+    def black(s);   "\033[30m#{s}\033[0m" end
+    def red(s);     "\033[31m#{s}\033[0m" end
+    def green(s);   "\033[32m#{s}\033[0m" end
+    def brown(s);   "\033[33m#{s}\033[0m" end
+    def blue(s);    "\033[34m#{s}\033[0m" end
+    def magenta(s); "\033[35m#{s}\033[0m" end
+    def cyan(s);    "\033[36m#{s}\033[0m" end
+    def gray(s);    "\033[37m#{s}\033[0m" end
+    def yellow(s);  "\033[93m#{s}\033[0m" end
+    def bold(s);    "\e[1m#{s}\e[m"       end
+  end
+
+  module CLI
+    class ArgError < ArgumentError; end
+
+    extend self
+
+    def listen(url, options)
+      puts "Run with options: #{options}" if options[:verbose]
+      unless url.start_with?('ws://', 'wss://')
+        url = 'wss://' + url
+      end
+
+      unless url =~ /\A#{URI::regexp(['ws', 'wss'])}\z/
+        raise ArgError, "#{url.inspect} is not a valid websocket URL"
+      end
+
+      uri = URI.parse(url)
+      port = uri.scheme == 'wss' ? 443 : uri.port
+      path = uri.path.start_with?('/') ? uri.path.sub(/^\//, '') : uri.path
+      logger_level = options[:verbose] ? 'trace' : 'warn'
+
+      puts WithColor.green("Connecting to #{url}")
+      waithook = Waithook.new(host: uri.host, port: port, path: path, logger_level: logger_level)
+      puts WithColor.green("Connected! Waiting to for message...") if waithook.client.wait_connected
+
+      while true
+        message = waithook.wait_message
+        puts message.message
+        if options[:forward]
+          Thread.new do
+            begin
+              forward_url = if options[:forward].start_with?('http://', 'https://')
+                forward_url
+              else
+                "http://#{options[:forward]}"
+              end
+
+              puts WithColor.brown("Sending as HTTP to #{forward_url}")
+              response = message.send_to(forward_url)
+              puts WithColor.brown("Reponse from #{forward_url} -> #{WithColor.bold("#{response.code} #{response.message}")}")
+            rescue => error
+              puts WithColor.red("#{error.message} (#{error.class})")
+              puts WithColor.red(error.backtrace.join("\n"))
+            end
+          end
+        end
+      end
+    end
+  end
+end

data/lib/waithook/logger_with_trace.rb

@@ -0,0 +1,49 @@
+require 'logger'
+
+# Just add trace level
+class LoggerWithTrace < ::Logger
+  module Severity
+    include ::Logger::Severity
+    TRACE = -1
+  end
+
+  TRACE = Severity::TRACE
+
+  def trace(progname = nil, &block)
+    add(TRACE, nil, progname, &block)
+  end
+
+  def trace?
+    @level <= TRACE
+  end
+
+  def level=(severity)
+    if severity.is_a?(Integer)
+      @level = severity
+    else
+      @level = case severity.to_s.downcase
+      when 'trace'.freeze   then TRACE
+      when 'debug'.freeze   then DEBUG
+      when 'info'.freeze    then INFO
+      when 'warn'.freeze    then WARN
+      when 'error'.freeze   then ERROR
+      when 'fatal'.freeze   then FATAL
+      when 'unknown'.freeze then UNKNOWN
+      else
+        raise ArgumentError, "invalid log level: #{severity}"
+      end
+    end
+  end
+
+  def setup(options)
+    self.progname = options[:progname]
+    self.formatter = proc do |serverity, time, progname, msg|
+      msg.lines.map do |line|
+        "#{progname} :: #{line}"
+      end.join("") + "\n"
+    end
+    self.level = options[:level]
+
+    self
+  end
+end

data/lib/waithook/version.rb

@@ -1,3 +1,3 @@
 class Waithook
-  VERSION = "0.1"
+  VERSION = "0.2"
 end

data/lib/waithook/websocket_client.rb

@@ -1,6 +1,8 @@
 require 'socket'
-require 'logger'
 require 'websocket'
+require 'stringio'
+
+require_relative 'logger_with_trace'
 
 class Waithook
   class WebsocketClient
@@ -29,26 +31,24 @@ class Waithook
       @options = options
 
       @waiters = []
+      @connect_waiters = []
       @handshake_received = false
       @messages = Queue.new
       @is_open = false
 
-      @output = options[:output] || STDOUT
+      @output = options[:output] || $stdout
 
       if options[:logger] === false
         @output = StringIO.new
       end
 
-      if options[:logger]
+      if options[:logger] && options[:logger] != true
         @logger = options[:logger]
       else
-        @logger = Logger.new(@output)
-        @logger.progname = self.class.name
-        @logger.formatter = proc do |serverity, time, progname, msg|
-          msg.lines.map do |line|
-            "#{progname} :: #{line}"
-          end.join("") + "\n"
-        end
+        @logger = LoggerWithTrace.new(@output).setup(
+          progname: self.class.name,
+          level: options[:logger_level] || :info
+        )
       end
     end
 
@@ -74,7 +74,7 @@ class Waithook
       @is_open = true
       @handshake = WebSocket::Handshake::Client.new(url: "ws://#{@host}/#{@path}")
 
-      logger.debug "Sending handshake:\n#{@handshake}"
+      logger.trace "Sending handshake:\n#{@handshake}"
 
       @socket.print(@handshake)
       _start_parser!
@@ -94,10 +94,10 @@ class Waithook
           logger.debug "Start reading in thread"
           handshake_response = _wait_handshake_response
           @handshake << handshake_response
-          logger.debug "Handshake received:\n #{handshake_response}"
+          logger.trace "Handshake received:\n #{handshake_response}"
 
           @frame_parser = WebSocket::Frame::Incoming::Client.new
-          @handshake_received = true
+          _handshake_recieved!
           _wait_frames!
         rescue Object => error
           logger.error "#{error.class}: #{error.message}\n#{error.backtrace.join("\n")}"
@@ -135,6 +135,20 @@ class Waithook
       @messages.pop
     end
 
+    def wait_connected
+      return true if @handshake_received
+      waiter = Waiter.new
+      @connect_waiters << waiter
+      waiter.wait
+    end
+
+    def _handshake_recieved!
+      @handshake_received = true
+      while waiter = @connect_waiters.shift
+        waiter.notify(true)
+      end
+    end
+
     def _notify_waiters(type, payload)
       while waiter = @waiters.shift
         waiter.notify([type, payload])
@@ -144,11 +158,13 @@ class Waithook
     def _send_frame(type, payload = nil)
       wait_handshake!
       frame = WebSocket::Frame::Outgoing::Client.new(version: @handshake.version, data: payload, type: type)
-      logger.debug "Sending :#{frame.type} #{payload ? "DATA: #{frame.data}" : "(no data)"}"
+      logger.trace "Sending :#{frame.type} #{payload ? "DATA: #{frame.data}" : "(no data)"}"
       @socket.write(frame.to_s)
     end
 
     def _process_frame(message)
+      logger.trace "Received :#{message.type} #{message.data ? "DATA: #{message.data}" : "(no data)"}"
+
       if message.type == :ping
         send_pong!
       end

data/lib/waithook.rb

@@ -1,15 +1,20 @@
 require 'net/http'
+require 'uri'
+require 'timeout'
 require 'json'
+require 'stringio'
 
+require_relative 'waithook/logger_with_trace'
 require_relative 'waithook/websocket_client'
+require_relative 'waithook/cli'
 
 class Waithook
 
   SERVER_HOST = "waithook.herokuapp.com"
   SERVER_PORT = 443
 
-  def self.subscribe(path, options = {}, &block)
-    instance = new(path, options)
+  def self.subscribe(options = {}, &block)
+    instance = new(options)
     if block
       instance.filter = block
     end
@@ -17,30 +22,52 @@ class Waithook
     instance
   end
 
+  def self.default_path
+    @default_path
+  end
+ 
+  def self.default_path=(value)
+    @default_path = value
+  end
+
   attr_accessor :filter
   attr_accessor :messages
   attr_reader :client
+  attr_reader :options
 
-  def initialize(path, options = {})
-    options = {
+  def initialize(options = {})
+    @options = {
       host: SERVER_HOST,
       port: SERVER_PORT,
-      auto_connect: true
+      auto_connect: true,
+      path: self.class.default_path
     }.merge(options)
 
-    @path = path
+    if @options[:path] == nil
+      raise ArgumentError, ":path is missing. Please add :path to options argument or set Waithook.default_path = 'foo'"
+    end
+
     @client = WebsocketClient.new(
-      path: path,
-      host: options[:host],
-      port: options[:port],
-      logger: options[:logger]
+      path: @options[:path],
+      host: @options[:host],
+      port: @options[:port],
+      logger: @options[:logger],
+      logger_level: @options[:logger_level],
+      output: @options[:output]
     )
 
     @messages = []
     @filter = nil
     @started = false
 
-    connect! if options[:auto_connect]
+    connect! if @options[:auto_connect]
+  end
+
+  def logger
+    @logger ||= LoggerWithTrace.new(@options[:logger] ? $stdout : StringIO.new).setup(
+      progname: self.class.name,
+      level: @options[:logger_level] || :info
+    )
   end
 
   def connect!
@@ -54,50 +81,31 @@ class Waithook
     !!@started
   end
 
-  def forward_to(url)
-    webhook = wait_message
-
-    uri = URI.parse(url)
-    response = nil
-
-    Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
-      http_klass = case webhook.method
-        when "GET"    then Net::HTTP::Get
-        when "POST"   then Net::HTTP::Post
-        when "PUT"    then Net::HTTP::Put
-        when "PATCH"  then Net::HTTP::Patch
-        when "HEAD"   then Net::HTTP::Head
-        when "DELETE" then Net::HTTP::Delete
-        when "MOVE"   then Net::HTTP::Move
-        when "COPY"   then Net::HTTP::Copy
-        when "HEAD"   then Net::HTTP::Head
-        else Net::HTTP::Post
-      end
-
-      request = http_klass.new(uri)
-      webhook.headers.each do |key, value|
-        request[key] = value
-      end
-
-      if webhook.body
-        request.body = webhook.body
-      end
-
-      response = http.request(request)
-    end
-
-    response
+  def forward_to(url, options = {})
+    webhook = wait_message(options)
+    webhook.send_to(url) unless webhook.nil?
   end
 
-  def wait_message
-    while true
-      type, data = @client.wait_message
-      webhook = Webhook.new(data)
-      if @filter && @filter.call(webhook) || !@filter
-        @messages << webhook
-        return webhook
+  def wait_message(options = {})
+    raise_timeout_error = options.has_key?(:raise_on_timeout) ? options[:raise_on_timeout] : true
+    timeout = options[:timeout] || @options[:timeout] || 0
+
+    start_time = Time.new.to_f
+    Timeout.timeout(timeout) do
+      while true
+        type, data = @client.wait_message
+        webhook = Webhook.new(data)
+        if @filter && @filter.call(webhook) || !@filter
+          @messages << webhook
+          return webhook
+        end
       end
     end
+  rescue Timeout::Error => error
+    time_diff = (Time.now.to_f - start_time).round(3)
+    logger.error "#{error.class}: #{error.message} (after #{time_diff} seconds)"
+    raise error if raise_timeout_error
+    return nil
   end
 
   def close!
@@ -110,9 +118,11 @@ class Waithook
     attr_reader :headers
     attr_reader :body
     attr_reader :method
+    attr_reader :message
 
     def initialize(payload)
-      data = JSON.parse(payload)
+      @message = payload
+      data = JSON.parse(@message)
       @url = data['url']
       @headers = data['headers']
       @body = data['body']
@@ -124,5 +134,38 @@ class Waithook
         @json_body ||= JSON.parse(@body)
       end
     end
+
+    def send_to(url)
+      uri = URI.parse(url)
+      response = nil
+
+      Net::HTTP.start(uri.host, uri.port, use_ssl: uri.scheme == 'https') do |http|
+        http_klass = case method
+          when "GET"    then Net::HTTP::Get
+          when "POST"   then Net::HTTP::Post
+          when "PUT"    then Net::HTTP::Put
+          when "PATCH"  then Net::HTTP::Patch
+          when "HEAD"   then Net::HTTP::Head
+          when "DELETE" then Net::HTTP::Delete
+          when "MOVE"   then Net::HTTP::Move
+          when "COPY"   then Net::HTTP::Copy
+          when "HEAD"   then Net::HTTP::Head
+          else Net::HTTP::Post
+        end
+
+        request = http_klass.new(uri)
+        headers.each do |key, value|
+          request[key] = value
+        end
+
+        if body
+          request.body = body
+        end
+
+        response = http.request(request)
+      end
+
+      response
+    end
   end
 end

data/tests/waithook_test.rb

@@ -11,7 +11,7 @@ describe "Waithook" do
   end
 
   def default_client(options = {})
-    client = Waithook.subscribe(options[:path] || 'my-super-test', host: HOST, port: PORT, logger: false)
+    client = Waithook.subscribe({path: 'my-super-test', host: HOST, port: PORT, logger: false}.merge(options))
     @waithook_instances.push(client)
     client
   end
@@ -54,4 +54,46 @@ describe "Waithook" do
     assert_equal(message, webhook.json_body)
     assert_equal("POST", webhook.method)
   end
+
+  it "should have trace log level" do
+    out, err = capture_io do
+      default_client(logger_level: :trace, logger: true)
+    end
+
+    assert_includes(out, 'Sec-WebSocket-Version')
+  end
+
+  it "should be more quiet generally" do
+    out, err = capture_io do
+      default_client(logger: true)
+    end
+
+    refute_includes(out, 'Sec-WebSocket-Version')
+  end
+
+  it "wait_message should raise exception after timeout" do
+    assert_raises(Timeout::Error) do
+      default_client.wait_message(timeout: 0.1)
+    end
+  end
+
+  it "wait_message should return nil after timeout" do
+    waithook = default_client
+    assert_equal(nil, waithook.wait_message(timeout: 0.1, raise_on_timeout: false))
+  end
+
+  it "forward_to should raise exception after timeout" do
+    assert_raises(Timeout::Error) do
+      default_client.forward_to('', timeout: 0.1)
+    end
+  end
+
+  it "forward_to should return nil after timeout" do
+    out, err = capture_io do
+      waithook = default_client(logger: true)
+      assert_equal(nil, waithook.forward_to('', timeout: 0.1, raise_on_timeout: false))
+    end
+
+    assert_includes(out, "Timeout::Error: execution expired")
+  end
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: waithook
 version: !ruby/object:Gem::Version
-  version: '0.1'
+  version: '0.2'
 platform: ruby
 authors:
 - Pavel Evstigneev
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2016-11-27 00:00:00.000000000 Z
+date: 2016-12-29 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket
@@ -42,6 +42,8 @@ files:
 - example/real_server_test.rb
 - example/waithook_example.rb
 - lib/waithook.rb
+- lib/waithook/cli.rb
+- lib/waithook/logger_with_trace.rb
 - lib/waithook/version.rb
 - lib/waithook/websocket_client.rb
 - tests/server_test.rb