kontena-websocket-client 0.1.0 → 0.1.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: 9cfc6e97aaa820488a6553d596598c422d977cb6
-  data.tar.gz: ab284b440b2ff882dd2c10b39c911f09af2c1c87
+  metadata.gz: bfd6cb9f7d3d9f6215854d22474b19f7ed67bb51
+  data.tar.gz: 2c3f654081f2e69fb8c783916411fda8a99dbf00
 SHA512:
-  metadata.gz: f06b75cf90c0602bf0529f81ad3dcd1bb3fecf81e0d23f5618545591217dc478f843930aba2ea066ae362950bda61ad62c6181310edc9de531c6bfa2b2f57b70
-  data.tar.gz: eee54689d732efa7dae2d6217a878bb01c13dfc7dabe056fa1917fb36993bcb56881225ba572cdb8a44db6ae907affc3e79f73a6c50257eb596845a0a4ca9cf5
+  metadata.gz: 6df6327057cb56e983332987602d3ac8784850e0e8b179a4de2ee08c9cf453a34e53714bd11c6d1876769087ef7a68470bde845e6526587a20560c09991f938e
+  data.tar.gz: 0a12250d84f4d9cd0993257e01b8fea0decd70c020a4b9dfaf32ef5b9a58f0d35320b94d66d2975a5d13bfab28e89b2754b0ef398af75a86e2e3c3856d29d76b

data/README.md

@@ -1,4 +1,6 @@
 [![Build Status](https://travis-ci.org/kontena/kontena-websocket-client.svg?branch=master)](https://travis-ci.org/kontena/kontena-websocket-client)
+[![Gem Version](https://badge.fury.io/rb/kontena-websocket-client.svg)](https://badge.fury.io/rb/kontena-websocket-client)
+[![Yard Docs](http://img.shields.io/badge/yard-docs-blue.svg)](http://www.rubydoc.info/github/kontena/kontena-websocket-client/master)
 
 # Kontena::Websocket::Client
 

data/benchmark/.gitignore

@@ -0,0 +1 @@
+websocket-echo-server

data/benchmark/benchmark-client.rb

@@ -0,0 +1,45 @@
+#!/usr/bin/env ruby
+
+Thread.abort_on_exception = true
+
+require 'kontena-websocket-client'
+require_relative './benchmark'
+
+WEBSOCKET_OPTIONS = {
+  connect_timeout: 1.0,
+  open_timeout: 1.0,
+  ping_timeout: 1.0,
+  ping_interval: nil,
+  write_timeout: 5.0,
+}
+
+Kontena::Websocket::Logging.initialize_logger(STDERR, LOG_LEVEL)
+
+run_benchmark do |url, **options|
+  send_thread = nil
+  reader = BenchmarkReader.new
+
+  Kontena::Websocket::Client.connect(url, **WEBSOCKET_OPTIONS) do |client|
+    $logger.info "connect: #{client}"
+
+    send_thread = Thread.new {
+      send_stats = benchmark_sender(**options) do |msg, seq|
+        client.send(msg)
+      end
+
+      client.close()
+
+      send_stats
+    }
+
+    reader.start()
+    client.read do |message|
+      reader.on_message(Time.now, message)
+    end
+  end
+
+  read_stats = reader.stop()
+  send_stats = send_thread.value
+
+  next send_stats, read_stats
+end

data/benchmark/benchmark-em.rb

@@ -0,0 +1,66 @@
+#!/usr/bin/env ruby
+
+Thread.abort_on_exception = true
+
+require 'faye/websocket'
+require 'eventmachine'
+require_relative './benchmark'
+
+run_benchmark do |url, **options|
+  send_thread = nil
+  reader = BenchmarkReader.new
+
+  EM.run {
+    ws = Faye::WebSocket::Client.new(url)
+
+    ws.on :open do |event|
+      $logger.info "open"
+
+      send_thread = Thread.new {
+        send_stats = benchmark_sender(**options) do |msg, seq|
+          EM.next_tick {
+            $logger.debug "send seq=%d" % [seq]
+            ws.send(msg)
+          }
+        end
+
+        EM.next_tick {
+          $logger.info "close..."
+          ws.close()
+        }
+
+        send_stats
+      }
+
+      reader.start()
+    end
+
+    read = 0
+
+    ws.on :message do |event|
+      seq, rtt = reader.on_message(Time.now, event.data)
+
+      $logger.debug "read %d: seq=%d rtt=%.2f" % [read, seq, rtt]
+
+      read += 1
+    end
+
+    ws.on :close do |event|
+      $logger.info "closed"
+
+      reader.stop
+      EM.stop
+    end
+
+    ws.on :error do |event|
+      $logger.warn "error: #{event}"
+
+      exit 1
+    end
+  }
+
+  read_stats = reader.stop()
+  send_stats = send_thread.value
+
+  next send_stats, read_stats
+end

data/benchmark/benchmark.rb

@@ -0,0 +1,161 @@
+require 'logger'
+
+LOG_LEVEL = ENV['LOG_LEVEL'] || Logger::WARN
+
+$logger = Logger.new(STDERR)
+$logger.level = LOG_LEVEL
+$logger.progname = 'websocket-benchmark'
+
+# @yield at given target interval
+# @return after duration
+def with_rate(rate, duration, &block)
+  t0 = Time.now
+  interval = 1.0 / rate
+  count = 0
+  count_miss = 0
+  total_yield = 0.0
+
+  while (t = Time.now) < t0 + duration
+    yield t
+
+    t_yield = Time.now
+
+    count += 1
+    total_yield += (t_yield - t)
+
+    t_next = t0 + count * interval
+
+    if t_next > t_yield
+      sleep t_next - t_yield
+    else
+      count_miss += 1
+    end
+  end
+
+  t_total = t - t0
+
+  return {
+    time: t_total,
+    count: count,
+    rate: count / t_total,
+    util: total_yield / t_total,
+    miss: (count_miss / count),
+  }
+end
+
+# @yield [seq, message]
+# @return [Hash] after duration
+def benchmark_sender(rate: 1000, duration: 5.0, message_size: 1000)
+  total_size = 0
+  seq = 0
+
+  padding = 'X'*(message_size - 16 - 16)
+
+  stats = with_rate(rate, duration) do |t|
+    message = '%15.6f %15d %s' % [t.to_f, seq, padding]
+
+    yield message, seq
+
+    total_size += message.length
+    seq += 1
+  end
+
+  return stats.merge(
+    bytes: total_size,
+  )
+end
+
+class BenchmarkReader
+  def initialize
+    @count = 0
+    @bytes = 0
+    @latency_total = 0.0
+  end
+
+  def start
+    @t_start = Time.now
+  end
+
+  # @param time [Time] Time.now
+  # @param message [String]
+  # @return [Integer, Float] seq, rtt
+  def on_message(time, message)
+    msg_time_s, msg_seq_s, padding = message.split(' ', 3)
+    msg_t = msg_time_s.to_f
+    msg_seq = msg_seq_s.to_i
+    t = time.to_f
+
+    @count += 1
+    @bytes += message.length
+    @latency_total += (t - msg_t)
+
+    return msg_seq, t - msg_t
+  end
+
+  # @return [Hash]
+  def stop
+    @t_stop = Time.now
+    seconds = @t_stop - @t_start
+
+    return {
+      time: seconds,
+      count: @count,
+      rate: @count / seconds,
+      bytes: @bytes,
+      bytes_rate: @bytes / seconds,
+      latency_avg: @latency_total / @count,
+    }
+  end
+end
+
+URL = 'ws://localhost:8080/echo'
+RATES = [1, 10, 100, 1000, 3000, 5000, 10000]
+DURATION = 5.0
+MESSAGE_SIZE = 1000
+
+HEADER = '%5s  %6s/s %9s: send @ %9s/s (%6s%% %6s%%) read @ %9s/s (%6s%%) = %12s/s ~%9s'
+FORMAT = '%5.2fs %6d/s %9d: send @ %9.2f/s (%6.2f%% %6.2f%%) read @ %9.2f/s (%6.2f%%) = %12s/s ~%9.6fs'
+
+def to_si(val)
+  if val > 10**9
+    '%.3fG' % [val / 10**9]
+  elsif val > 10**6
+    '%.3fM' % [val / 10**6]
+  elsif val > 10**3
+    '%.3fK' % [val / 10**3]
+  else
+    '%.3f ' % [val]
+  end
+end
+
+# @yield [url, **options]
+# @yieldreturn [send_stats, read_stats]
+def run_benchmark()
+  url = ENV['URL'] || URL
+
+  rates = (ENV['RATES']&.split&.map{|r| Integer(r)} || RATES)
+  duration = (ENV['DURATION'] || DURATION).to_f
+  message_size = (ENV['MESSAGE_SIZE'] || MESSAGE_SIZE).to_i
+
+  puts HEADER % ['TIME ', 'RATE', 'COUNT', 'MESSAGES', 'UTIL', 'MISS', 'MESSAGES', 'DROP', 'BYTES', 'LATENCY']
+
+  for rate in rates
+    options = {
+      rate: rate,
+      duration: duration,
+      message_size: message_size,
+    }
+
+    $logger.info "benchmark: #{url} #{options}"
+
+    send_stats, read_stats = yield(url, **options)
+
+    drop_ratio = 1.0 - read_stats[:count].to_f / send_stats[:count].to_f
+
+    puts FORMAT % [
+      duration, rate, send_stats[:count],
+      send_stats[:rate], send_stats[:util] * 100.0, send_stats[:miss] * 100.0,
+      read_stats[:rate], drop_ratio * 100.0, to_si(read_stats[:bytes_rate]), read_stats[:latency_avg],
+    ]
+  end
+end

data/benchmark/benchmark.sh

@@ -0,0 +1,17 @@
+#!/bin/sh
+
+set -uex
+
+DIR=$(dirname $0)
+SERVER_ARGS=${SERVER_ARGS:- -drop}
+BENCHMARK=${BENCHMARK:-benchmark-client.rb}
+
+go get -d github.com/gorilla/websocket
+go build -o $DIR/websocket-echo-server $DIR/websocket-echo-server.go
+
+killall websocket-echo-server || true
+$DIR/websocket-echo-server -quiet $SERVER_ARGS &
+
+$DIR/${BENCHMARK}
+
+trap "kill 0" INT EXIT

data/benchmark/websocket-echo-server.go

@@ -0,0 +1,207 @@
+package main
+
+import (
+	"flag"
+	"fmt"
+	"github.com/gorilla/websocket"
+	"log"
+	"net/http"
+	"time"
+)
+
+var websocketUpgrader = websocket.Upgrader{}
+
+// single-goroutine read+write loop
+// blocks reads if writes block
+func websocketEchoSync(conn *websocket.Conn) error {
+	for {
+		if messageType, data, err := conn.ReadMessage(); err != nil {
+			if websocket.IsCloseError(err, 1000) {
+				break
+			} else {
+				return fmt.Errorf("websocket read: %v", err)
+			}
+		} else if err := conn.WriteMessage(messageType, data); err != nil {
+			return fmt.Errorf("websocket write: %v", err)
+		} else {
+			if options.Verbose {
+				log.Printf("websocket echo: %v", data)
+			}
+		}
+	}
+
+	return nil
+}
+
+type websocketMessage struct {
+	Type int
+	Data []byte
+}
+
+func websocketAsyncReader(conn *websocket.Conn, c chan websocketMessage) error {
+	defer close(c)
+
+	var messages, dropped int
+	var start = time.Now()
+
+	for {
+		if messageType, data, err := conn.ReadMessage(); err != nil {
+			if websocket.IsCloseError(err, 1000) {
+				if options.Verbose {
+					log.Printf("websocket read close: %v", err)
+				}
+
+				break
+			} else {
+				return fmt.Errorf("websocket read: %v", err)
+			}
+		} else {
+			var m = websocketMessage{messageType, data}
+			messages += 1
+
+			select {
+			case c <- m:
+				if options.Verbose {
+					log.Printf("websocket read: %v", m.Data)
+				}
+
+			default:
+				dropped += 1
+
+				if options.Verbose {
+					log.Printf("websocket drop: %v", m.Data)
+				}
+			}
+		}
+	}
+
+	var end = time.Now()
+
+	if !options.Quiet {
+		var seconds = end.Sub(start).Seconds()
+
+		log.Printf("websocket read: %d messages in %.1fs (%.2f/s, dropped %.2f%%)",
+			messages, seconds,
+			float64(messages)/seconds,
+			float64(dropped)/float64(messages)*100.0,
+		)
+	}
+
+	return nil
+}
+
+func websocketAsyncWriter(conn *websocket.Conn, c <-chan websocketMessage) error {
+	for m := range c {
+		if err := conn.WriteMessage(m.Type, m.Data); err != nil {
+			return fmt.Errorf("websocket write: %v", err)
+		} else {
+			if options.Verbose {
+				log.Printf("websocket write: %v", m.Data)
+			}
+		}
+	}
+
+	return nil
+}
+
+func websocketEchoAsync(conn *websocket.Conn) error {
+	var messageChan = make(chan websocketMessage, options.DropBuffer)
+	var readClose struct {
+		code int
+		text string
+	}
+	var readError error
+
+	// custom close handler to send close frame after reader drains the message queue
+	conn.SetCloseHandler(func(code int, text string) error {
+		readClose.code = code
+		readClose.text = text
+
+		return nil
+	})
+
+	go func() {
+		if err := websocketAsyncReader(conn, messageChan); err != nil {
+			readError = err
+			log.Printf("websocket read error: %v", err)
+		}
+	}()
+
+	if err := websocketAsyncWriter(conn, messageChan); err != nil {
+		return err
+	} else if readError != nil {
+		return readError
+	} else {
+		var closeMessage = websocket.FormatCloseMessage(readClose.code, readClose.text)
+
+		if err := conn.WriteControl(websocket.CloseMessage, closeMessage, time.Time{}); err != nil {
+			log.Printf("websocket write close: %v", err)
+		} else {
+			if options.Verbose {
+				log.Printf("websocket write close")
+			}
+		}
+
+		return nil
+	}
+}
+
+func EchoHandler(w http.ResponseWriter, r *http.Request) {
+	if websocketConn, err := websocketUpgrader.Upgrade(w, r, nil); err != nil {
+		log.Printf("Websocket Upgrade error: %v", err)
+		w.WriteHeader(500)
+		fmt.Fprintf(w, "%v", err)
+	} else {
+		if !options.Quiet {
+			log.Printf("Websocket echo connect: %v", r.RemoteAddr)
+		}
+
+		defer websocketConn.Close()
+
+		if options.Drop {
+			if err := websocketEchoAsync(websocketConn); err != nil {
+				log.Printf("Websocket echo error: %v", err)
+				return
+			}
+		} else {
+			if err := websocketEchoSync(websocketConn); err != nil {
+				log.Printf("Websocket echo error: %v", err)
+				return
+			}
+		}
+
+		if !options.Quiet {
+			log.Printf("Websocket echo close: %v", r.RemoteAddr)
+		}
+	}
+}
+
+var options struct {
+	Listen     string
+	Verbose    bool
+	Quiet      bool
+	Drop       bool
+	DropBuffer uint
+}
+
+func init() {
+	flag.StringVar(&options.Listen, "listen", "localhost:8080", "HOST:PORT")
+	flag.BoolVar(&options.Verbose, "verbose", false, "log echo messages")
+	flag.BoolVar(&options.Quiet, "quiet", false, "do not log connects")
+	flag.BoolVar(&options.Drop, "drop", false, "drop messages if client is sending faster than reading")
+	flag.UintVar(&options.DropBuffer, "drop-buffer", 1000, "message buffer length")
+}
+
+func main() {
+	flag.Parse()
+
+	if !options.Quiet {
+		log.Printf("Websocket listen: %v", options.Listen)
+	}
+
+	http.HandleFunc("/echo", EchoHandler)
+
+	if err := http.ListenAndServe(options.Listen, nil); err != nil {
+		log.Fatalf("http listen: %v", err)
+	}
+}

data/kontena-websocket-client.gemspec

@@ -1,7 +1,7 @@
 # coding: utf-8
 Gem::Specification.new do |spec|
   spec.name          = "kontena-websocket-client"
-  spec.version       = '0.1.0'
+  spec.version       = '0.1.1'
   spec.authors       = ["Kontena, Inc"]
   spec.email         = ["info@kontena.io"]
 

data/lib/kontena/websocket/client.rb

@@ -348,7 +348,7 @@ class Kontena::Websocket::Client
           debug "ping-pong at #{ping_at} in #{ping_delay}s"
 
           # XXX: defer call without mutex?
-          @on_pong.call(ping_delay) # TODO: also pass ping_at
+          @on_pong.call(ping_delay) if @on_pong # TODO: also pass ping_at
         end
       end
     end

data/lib/kontena/websocket/client/version.rb

@@ -1,5 +1,5 @@
 class Kontena::Websocket::Client
-  VERSION = "0.1.0"
+  VERSION = "0.1.1"
 
   # Running ruby >= version?
   # @param gte_version [String]

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kontena-websocket-client
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.1.1
 platform: ruby
 authors:
 - Kontena, Inc
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2017-07-21 00:00:00.000000000 Z
+date: 2017-08-14 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: websocket-driver
@@ -80,6 +80,12 @@ files:
 - LICENSE
 - README.md
 - Rakefile
+- benchmark/.gitignore
+- benchmark/benchmark-client.rb
+- benchmark/benchmark-em.rb
+- benchmark/benchmark.rb
+- benchmark/benchmark.sh
+- benchmark/websocket-echo-server.go
 - examples/websocket-echo-client.rb
 - kontena-websocket-client.gemspec
 - lib/kontena-websocket-client.rb