waithook 0.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 119debffa9104d9f4b3b0c1d2a943840a0bb1aaa
+  data.tar.gz: ee89ce35a2bc6a13a3517f9c524b108d53c36d16
+SHA512:
+  metadata.gz: e75927f077b2fa65d3a3af0855f314f68a4039996ae11ab641b1b2bdc58b43aaefa35196d2f6bf5728edde917729de5ed67880e58abcd85f3c57f6065a656e28
+  data.tar.gz: 07000675d72ef66ab760dde7d039e4fcbafa36186d4f06ecc18e0912ad4b829d89dcfb2454c110480f190dce8017cade2acba2adddac6548c69c48768e9f29c0

data/.gitignore

@@ -0,0 +1 @@
+*.gem

data/Gemfile

@@ -0,0 +1,8 @@
+source "https://rubygems.org"
+
+gem 'rake'
+gem 'minitest-reporters'
+gem 'excon'
+gem 'addressable'
+
+gemspec

data/Gemfile.lock

@@ -0,0 +1,37 @@
+PATH
+  remote: .
+  specs:
+    waithook (0.1)
+      websocket (~> 1.2.3)
+
+GEM
+  remote: https://rubygems.org/
+  specs:
+    addressable (2.5.0)
+      public_suffix (~> 2.0, >= 2.0.2)
+    ansi (1.5.0)
+    builder (3.2.2)
+    excon (0.54.0)
+    minitest (5.9.1)
+    minitest-reporters (1.1.12)
+      ansi
+      builder
+      minitest (>= 5.0)
+      ruby-progressbar
+    public_suffix (2.0.4)
+    rake (11.3.0)
+    ruby-progressbar (1.8.1)
+    websocket (1.2.3)
+
+PLATFORMS
+  ruby
+
+DEPENDENCIES
+  addressable
+  excon
+  minitest-reporters
+  rake
+  waithook!
+
+BUNDLED WITH
+   1.13.6

data/Rakefile

@@ -0,0 +1,4 @@
+
+task :test do
+  Dir.glob('./tests/**/*_test.rb').each { |file| require file }
+end

data/bin/waithook

@@ -0,0 +1,4 @@
+#!/usr/bin/env ruby
+
+$:.push(File.expand_path("../../lib", __FILE__))
+

data/example/example.rb

@@ -0,0 +1,54 @@
+require 'looksee'
+require 'net/http'
+
+require './websocket-client'
+
+HOST = 'localhost'
+PORT = 3012
+#HOST = 'waithook.herokuapp.com'
+#PORT = 80
+
+client = WebsocketClient.new(host: HOST, port: PORT, path: 'test-ruby')
+
+client.connect!
+
+sleep 1
+
+client.send_ping!
+
+def print_time(message)
+  s_time = Time.now.to_f
+  r = yield
+  puts "Time #{message}: #{Time.now.to_f - s_time}"
+  r
+end
+
+sleep 5
+
+Net::HTTP.start(HOST, PORT) do |http|
+  while true
+    sleep 2
+    print_time("HTTP Request") {
+      http.get("/test-ruby")
+    }
+    print_time("Waithook response") {
+      type, data = client.wait_message
+      #p [type, data]
+    }
+    #client.close!
+    #Net::HTTP.get(URI.parse("http://#{HOST}:#{PORT}/test-ruby"))
+  end
+end
+
+#socket = TCPSocket.open(hostname, port)
+#
+#request = WebSocket::Handshake::Client.new(url: 'ws://waithook.herokuapp.com/test-ruby')
+#puts request
+#
+#socket.print(request)
+#
+#while line = socket.gets
+#  puts line.chop
+#end
+#
+#socket.close

data/example/many_clients.rb

@@ -0,0 +1,64 @@
+require 'looksee'
+require 'net/http'
+require "stringio"
+require 'json'
+
+require './websocket-client'
+
+HOST = 'localhost'
+PORT = 3012
+#HOST = 'waithook.herokuapp.com'
+#PORT = 80
+
+threads_num = ENV['THREADS'] ? ENV['THREADS'].to_i : 10
+threads = []
+timing = {}
+running = true
+
+threads_num.times do
+  threads << Thread.new do
+    begin
+      client = WebsocketClient.new(host: HOST, port: PORT, path: 'pick-hour', output: StringIO.new)
+      client.connect!
+
+      while running
+        type, data = client.wait_message
+        body = JSON.parse(data)['body']
+        puts "Message time: #{Time.now.to_f - timing[body]} sec"
+      end
+
+      client.close!
+      puts "client done"
+    rescue Object => error
+      puts "#{error.class}: #{error.message}\n#{error.backtrace.join("\n")}"
+      raise error
+    end
+  end
+end
+
+sleep 3
+
+Net::HTTP.start(HOST, PORT) do |http|
+  200.times do |n|
+    msg = "aaa-#{n}"
+    timing[msg] = Time.now.to_f
+    puts "Sending #{msg}"
+    puts http.post('/pick-hour', msg)
+    sleep 0.05
+  end
+end
+
+#200.times do |n|
+#  msg = "aaa-#{n}"
+#  timing[msg] = Time.now.to_f
+#  puts "Sending #{msg}"
+#  Net::HTTP.start(HOST, PORT) do |http|
+#    puts http.post('/pick-hour', msg)
+#  end
+#  sleep 0.01
+#end
+
+#Net::HTTP.get(URI.parse("http://#{HOST}:#{PORT}/pick-hour"))
+
+#p threads
+threads.map(&:join)

data/example/real_server_test.rb

@@ -0,0 +1,19 @@
+require 'looksee'
+require 'excon'
+
+require './websocket-client'
+
+#HOST = 'localhost'
+#PORT = 3012
+HOST = 'waithook.herokuapp.com'
+PORT = 443
+
+client = WebsocketClient.new(host: HOST, port: PORT, path: 'test-ruby').connect!.wait_handshake!
+
+Excon.get("http#{PORT == 443 ? 's' : ''}://#{HOST}:#{PORT}/test-ruby")
+type, data = client.wait_message
+
+puts "Received message (#{type})"
+puts "Received message body: #{data}"
+
+client.close!

data/example/waithook_example.rb

@@ -0,0 +1,11 @@
+require_relative './waithook'
+require 'excon'
+
+waithook = Waithook.subscribe('my-super-test', host: 'localhost', port: 3012)
+
+Excon.post('http://localhost:3012/my-super-test', body: Time.now.to_s)
+
+while true
+  response = waithook.forward_to('http://localhost:3012/my-super-test')
+  p waithook.messages.last
+end

data/lib/waithook.rb

@@ -0,0 +1,128 @@
+require 'net/http'
+require 'json'
+
+require_relative 'waithook/websocket_client'
+
+class Waithook
+
+  SERVER_HOST = "waithook.herokuapp.com"
+  SERVER_PORT = 443
+
+  def self.subscribe(path, options = {}, &block)
+    instance = new(path, options)
+    if block
+      instance.filter = block
+    end
+    instance.connect! unless instance.started?
+    instance
+  end
+
+  attr_accessor :filter
+  attr_accessor :messages
+  attr_reader :client
+
+  def initialize(path, options = {})
+    options = {
+      host: SERVER_HOST,
+      port: SERVER_PORT,
+      auto_connect: true
+    }.merge(options)
+
+    @path = path
+    @client = WebsocketClient.new(
+      path: path,
+      host: options[:host],
+      port: options[:port],
+      logger: options[:logger]
+    )
+
+    @messages = []
+    @filter = nil
+    @started = false
+
+    connect! if options[:auto_connect]
+  end
+
+  def connect!
+    raise "Waithook connection already started" if @started
+    @started = true
+    @client.connect!.wait_handshake!
+    self
+  end
+
+  def started?
+    !!@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
+  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
+      end
+    end
+  end
+
+  def close!
+    @client.close!
+    @started = false
+  end
+
+  class Webhook
+    attr_reader :url
+    attr_reader :headers
+    attr_reader :body
+    attr_reader :method
+
+    def initialize(payload)
+      data = JSON.parse(payload)
+      @url = data['url']
+      @headers = data['headers']
+      @body = data['body']
+      @method = data['method']
+    end
+
+    def json_body
+      if @body
+        @json_body ||= JSON.parse(@body)
+      end
+    end
+  end
+end

data/lib/waithook/version.rb

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

data/lib/waithook/websocket_client.rb

@@ -0,0 +1,197 @@
+require 'socket'
+require 'logger'
+require 'websocket'
+
+class Waithook
+  class WebsocketClient
+
+    attr_accessor :logger
+
+    class Waiter
+      def wait
+        @queue = Queue.new
+        @queue.pop(false)
+      end
+
+      def notify(data)
+        @queue.push(data)
+      end
+    end
+
+    def initialize(options = {})
+      # required: :host, :path
+
+      @host = options[:host]
+      @port = options[:port] || 80
+      @path = options[:path]
+
+      @use_ssl = options.has_key?(:ssl) ? options[:ssl] : @port == 443
+      @options = options
+
+      @waiters = []
+      @handshake_received = false
+      @messages = Queue.new
+      @is_open = false
+
+      @output = options[:output] || STDOUT
+
+      if options[:logger] === false
+        @output = StringIO.new
+      end
+
+      if options[:logger]
+        @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
+      end
+    end
+
+    def connect!
+      logger.info "Connecting to #{@host} #{@port}"
+
+      tcp_socket = TCPSocket.open(@host, @port)
+
+      if @use_ssl
+        require 'openssl'
+        ctx = OpenSSL::SSL::SSLContext.new
+        ctx.ssl_version = @options[:ssl_version] if @options[:ssl_version]
+        ctx.verify_mode = @options[:verify_mode] if @options[:verify_mode]
+        cert_store = OpenSSL::X509::Store.new
+        cert_store.set_default_paths
+        ctx.cert_store = cert_store
+        @socket = ::OpenSSL::SSL::SSLSocket.new(tcp_socket, ctx)
+        @socket.connect
+      else
+        @socket = tcp_socket
+      end
+
+      @is_open = true
+      @handshake = WebSocket::Handshake::Client.new(url: "ws://#{@host}/#{@path}")
+
+      logger.debug "Sending handshake:\n#{@handshake}"
+
+      @socket.print(@handshake)
+      _start_parser!
+
+      self
+    end
+
+    def connected?
+      !!@is_open
+    end
+
+    def _start_parser!
+      @reader, @writter = IO.pipe
+      @processing_thread = Thread.new do
+        Thread.current.abort_on_exception = true
+        begin
+          logger.debug "Start reading in thread"
+          handshake_response = _wait_handshake_response
+          @handshake << handshake_response
+          logger.debug "Handshake received:\n #{handshake_response}"
+
+          @frame_parser = WebSocket::Frame::Incoming::Client.new
+          @handshake_received = true
+          _wait_frames!
+        rescue Object => error
+          logger.error "#{error.class}: #{error.message}\n#{error.backtrace.join("\n")}"
+          raise error
+        end
+      end
+    end
+
+    def send_ping!
+      _send_frame(:ping)
+    end
+
+    def send_pong!
+      _send_frame(:pong)
+    end
+
+    def send_message!(payload)
+      _send_frame(:text, payload)
+    end
+
+    def wait_handshake!
+      while !@handshake_received
+        sleep 0.001
+      end
+      self
+    end
+
+    def wait_new_message
+      waiter = Waiter.new
+      @waiters << waiter
+      waiter.wait
+    end
+
+    def wait_message
+      @messages.pop
+    end
+
+    def _notify_waiters(type, payload)
+      while waiter = @waiters.shift
+        waiter.notify([type, payload])
+      end
+    end
+
+    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)"}"
+      @socket.write(frame.to_s)
+    end
+
+    def _process_frame(message)
+      if message.type == :ping
+        send_pong!
+      end
+      if message.type == :text
+        @messages.push([message.type, message.data])
+        _notify_waiters(message.type, message.data)
+      end
+    end
+
+    def _wait_frames!
+      while char = @socket.getc
+        @frame_parser << char
+        while message = @frame_parser.next
+          _process_frame(message)
+        end
+      end
+    end
+
+    def _wait_handshake_response
+      logger.debug "Waiting handshake response"
+      data = []
+      while line = @socket.gets
+        data << line
+        if line == "\r\n"
+          break
+        end
+      end
+      data.join("")
+    end
+
+    def close!(options = {send_close: true})
+      unless @is_open
+        logger.info "Already closed"
+        return false
+      end
+
+      logger.info "Disconnecting from #{@host} #{@port}"
+      @processing_thread.kill
+      _send_frame(:close) if options[:send_close]
+      @socket.close
+      @is_open = false
+
+      return true
+    end
+  end
+end

data/tests/server_test.rb

@@ -0,0 +1,131 @@
+require_relative 'test_helper'
+
+describe "Server" do
+  after do
+    @client.close! if @client && @client.connected?
+    assert_equal(0, get_stats['total_listeners'])
+  end
+
+  def default_client
+    Waithook::WebsocketClient.new(host: HOST, port: PORT, path: PATH, output: StringIO.new).connect!.wait_handshake!
+  end
+
+  it "should remove connection on disconnect with close frame" do
+    @client = default_client
+
+    POST(PATH, 'test data')
+    type, data = @client.wait_message
+    message = JSON.parse(data)
+
+    assert_equal(:text, type)
+    assert_equal('test data', message['body'])
+
+    @client.close!
+
+    assert_equal(0, get_stats['total_listeners'])
+  end
+
+  it "should remove connection after disconnect without close frame" do
+    @client = default_client
+
+    POST(PATH, 'test data')
+    type, data = @client.wait_message
+    message = JSON.parse(data)
+
+    assert_equal(:text, type)
+    assert_equal('test data', message['body'])
+
+    @client.close!(send_close: false)
+
+    assert_equal(0, get_stats['total_listeners'])
+  end
+
+  it "should show stats for subscribed connection" do
+    @client = default_client
+
+    response = GET('@/stats')
+    stats = JSON.parse(response.body)
+    @client.close!
+
+    assert_equal({'/test-ruby' => 1}, stats['listeners'])
+    assert_equal({
+      "Connection"     => "close",
+      "Content-Length" => "116",
+      "Content-Type"   => "application/json"
+    }, response.headers)
+  end
+
+  it "should not allow keep-alive" do
+    response = POST(PATH, 'test data')
+
+    assert_equal("OK\n", response.body)
+    assert_equal({
+      "Connection"     => "close",
+      "Content-Length" => "3",
+      "Content-Type"   => "text/plain"
+    }, response.headers)
+  end
+
+  it "should serve index.html" do
+    response = GET("")
+
+    assert_includes(response.body, "<html>")
+    assert_equal({
+      "Connection"     => "close",
+      "Content-Length" => response.headers["Content-Length"],
+      "Content-Type"   => "text/html"
+    }, response.headers)
+  end
+
+  it "should serve index.html" do
+    response = GET("@/index.js")
+
+    assert_includes(response.body, "function")
+    assert_equal({
+      "Connection"     => "close",
+      "Content-Length" => response.headers["Content-Length"],
+      "Content-Type"   => "application/javascript; charset=utf-8"
+    }, response.headers)
+  end
+
+  it "should support utf-8 content" do
+    @client = default_client
+
+    response = POST(PATH, "привет")
+    assert_includes(response.body, "OK\n")
+
+    type, data = @client.wait_message
+    message = JSON.parse(data)
+
+    assert_equal(:text, type)
+    assert_equal("привет", message['body'])
+  end
+
+  it "should support utf-8 paths" do
+    skip "hyper not support it yet"
+    path = "бум!!!"
+    @client = Waithook::WebsocketClient.new(host: HOST, port: PORT, path: path, output: StringIO.new).connect!
+    @client.wait_handshake!
+
+    response = POST(path, "test-body")
+    assert_includes(response.body, "OK\n")
+
+    type, data = @client.wait_message
+    message = JSON.parse(data)
+
+    assert_equal(:text, type)
+    assert_equal("test-body", message['body'])
+  end
+
+  it "should work with PUT" do
+    @client = default_client
+    response = Excon.put("http://#{HOST}:#{PORT}/#{PATH}", body: "test-data")
+
+    type, data = @client.wait_message
+    message = JSON.parse(data)
+
+    assert_equal(:text, type)
+    assert_equal("test-data", message['body'])
+    assert_equal("PUT", message['method'])
+  end
+end

data/tests/test_helper.rb

@@ -0,0 +1,45 @@
+Encoding.default_internal = Encoding::UTF_8
+Encoding.default_external = Encoding::UTF_8
+
+require 'bundler/setup'
+require_relative '../lib/waithook'
+
+require 'excon'
+require 'json'
+require "minitest/autorun"
+require "minitest/reporters"
+require "addressable/uri"
+
+Minitest::Reporters.use!(
+  Minitest::Reporters::SpecReporter.new(color: true)
+)
+
+if ENV['SEQ']
+  puts "Set test_order == :alpha"
+  class Minitest::Test
+    def self.test_order
+     :alpha
+    end
+  end
+end
+
+# To support UTF-8 in path
+module WebSocket::Handshake
+  URI = Addressable::URI
+end
+
+HOST = 'localhost'
+PORT = 3012
+PATH = 'test-ruby'
+
+def POST(path, data = nil)
+  Excon.post("http://#{HOST}:#{PORT}/#{path}", body: data, uri_parser: Addressable::URI)
+end
+
+def GET(path)
+  Excon.get("http://#{HOST}:#{PORT}/#{path}", uri_parser: Addressable::URI)
+end
+
+def get_stats
+  JSON.parse(GET('@/stats').body)
+end

data/tests/waithook_test.rb

@@ -0,0 +1,57 @@
+require_relative 'test_helper'
+
+describe "Waithook" do
+
+  before do
+    @waithook_instances = []
+  end
+
+  after do
+    @waithook_instances.map(&:close!).clear
+  end
+
+  def default_client(options = {})
+    client = Waithook.subscribe(options[:path] || 'my-super-test', host: HOST, port: PORT, logger: false)
+    @waithook_instances.push(client)
+    client
+  end
+
+  it "should subscribe" do
+    waithook = default_client
+
+    stats = get_stats
+    assert_equal(1, stats['total_listeners'])
+    assert_equal({"/my-super-test" => 1}, stats['listeners'])
+  end
+
+  it "should receive a message" do
+    waithook = default_client
+
+    message = JSON.generate([Time.now.to_s])
+    Excon.post("http://#{HOST}:#{PORT}/my-super-test", body: message)
+
+    webhook = waithook.wait_message
+    assert_instance_of(Waithook::Webhook, webhook)
+    assert_equal(message, webhook.body)
+    assert_equal(JSON.parse(message), webhook.json_body)
+  end
+
+  it "should forward request" do
+    waithook = default_client
+    second_client = default_client(path: 'my-super-test2')
+
+    message = {'my_data' => true}
+
+    Excon.post("http://#{HOST}:#{PORT}/my-super-test", body: JSON.generate(message))
+
+    server_response = waithook.forward_to("http://#{HOST}:#{PORT}/my-super-test2")
+
+    assert_instance_of(Net::HTTPOK, server_response)
+    assert_equal("OK\n", server_response.body)
+
+    webhook = second_client.wait_message
+
+    assert_equal(message, webhook.json_body)
+    assert_equal("POST", webhook.method)
+  end
+end

data/waithook.gemspec

@@ -0,0 +1,20 @@
+require_relative 'lib/waithook/version'
+
+Gem::Specification.new do |s|
+  s.name        = "waithook"
+  s.version     = Waithook::VERSION
+  s.author      = ["Pavel Evstigneev"]
+  s.email       = ["pavel.evst@gmail.com"]
+  s.homepage    = "https://github.com/paxa/waithook-ruby"
+  s.summary     = %q{HTTP to WebSocket transmitting client}
+  s.description = "Waithook gem is client lib for waithook service https://waithook.heroku.com"
+  s.license     = 'MIT'
+
+  s.files       = `git ls-files`.split("\n")
+  s.test_files  = []
+
+  s.require_paths = ["lib"] 
+  s.executables   = ["waithook"]
+
+  s.add_runtime_dependency "websocket", "~> 1.2"
+end

metadata

@@ -0,0 +1,75 @@
+--- !ruby/object:Gem::Specification
+name: waithook
+version: !ruby/object:Gem::Version
+  version: '0.1'
+platform: ruby
+authors:
+- Pavel Evstigneev
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-11-27 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: websocket
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+description: Waithook gem is client lib for waithook service https://waithook.heroku.com
+email:
+- pavel.evst@gmail.com
+executables:
+- waithook
+extensions: []
+extra_rdoc_files: []
+files:
+- ".gitignore"
+- Gemfile
+- Gemfile.lock
+- Rakefile
+- bin/waithook
+- example/example.rb
+- example/many_clients.rb
+- example/real_server_test.rb
+- example/waithook_example.rb
+- lib/waithook.rb
+- lib/waithook/version.rb
+- lib/waithook/websocket_client.rb
+- tests/server_test.rb
+- tests/test_helper.rb
+- tests/waithook_test.rb
+- waithook.gemspec
+homepage: https://github.com/paxa/waithook-ruby
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.6.8
+signing_key: 
+specification_version: 4
+summary: HTTP to WebSocket transmitting client
+test_files: []