kinetic_sdk 0.1.1

data/gems/kontena-websocket-client-0.1.1/README.md

@@ -0,0 +1,138 @@
+[![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
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+```ruby
+gem 'kontena-websocket-client'
+```
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install kontena-websocket-client
+
+## Usage
+
+The high-level `Kontena::Websocket::Client#connect` API uses a synchronous programming model instead of the event-based `on(:event) do ...` model used by the browser WebSockets API:
+
+* The `connect` class method yields the connected `Kontena::Websocket::Client` object
+* The `read` method yields received websocket messages and returns once the websocket is closed
+* The `send` and `close` methods can be called from the `connect` block, the `read` block, or a different thread
+* Any of these functions can also raise `Kontena::Websocket::Error`
+
+```ruby
+require 'kontena-websocket-client'
+
+def websocket_connect
+  Kontena::Websocket::Client.connect(url, options...) do |client|
+    on_open
+
+    client.send(...)
+    client.close(1000)
+
+    client.read do |message|
+      on_message(message)
+    end
+
+    on_close(client.close_code, client.close_reason) # client closed connection
+  end
+rescue Kontena::Websocket::CloseError => exc
+  on_close(exc.code, exc.reason) # server closed connection
+rescue Kontena::Websocket::Error => exc
+  on_error(exc)
+end
+```
+### Environment variables
+
+The library uses the following environment variables:
+
+* `SSL_CERT_FILE`: Default value for `ssl_params: { ca_file: ... }`
+* `SSL_CERT_PATH`: Default value for `ssl_params: { ca_path: ... }`
+
+### Threadsafe
+
+The `Kontena::Websocket::Client` is threadsafe: while a single read thread is blocking on `read`, other threads may safely call `send`, `ping` and `close`.
+
+The `read` block may also call `send`, `ping` and `close`.
+Do not call `read` from multiple threads, or the websocket messages may get corrupted.
+
+The library uses an internal `Mutex` to protect the internal `Websocket::Driver` state, and prevent socket read/write reordering/corruption.
+
+XXX: The `on_pong` callback is called with the mutex held; do not call any client methods from the `on_pong` block.
+
+### Timeouts
+
+The `Kontena::Websocket::Client` uses timeouts (given in `options`) to deal with network errors and not leave the client hanging. Timeouts will raise a descriptive `Kontena::Websocket::TimeoutError` from either the `connect`, `read` or `send/close` methods.
+
+* `connect_timeout` is used for both TCP, SSL `connect` operations
+* `open_timeout` is used for the websocket `open` handshake
+* `write_timeout` is used for each socket `write` operation
+* `ping_timeout` is used for each websocket `ping` request
+
+The `Kontena::Websocket::Client` supports keepalive pings, where the `read` method will send a websocket ping request every `ping_interval` seconds, and raise a `Kontena::Websocket::TimeoutError` if it does not receive a websocket pong response within `ping_timeout` seconds.
+
+### SSL Validation
+
+The `Kontena::Websocket::Client` validates `wss://` server SSL certificates by default, using the OpenSSL APIs to provide useful `Kontena::Websocket::SSLVerifyError` messages. It also provides methods to inspect and validate the server SSL certificates, even when not using strict SSL validation.
+
+Example code and resulting messages:
+
+```ruby
+begin
+  ssl_cert = ws.ssl_cert!
+rescue Kontena::Websocket::SSLVerifyError => ssl_error
+  ssl_cert = ssl_error.cert
+else
+  ssl_error = nil
+end
+
+if ssl_cert && ssl_error
+  $logger.warn "Connected to #{url} with ssl errors: #{ssl_error} (subject #{ssl_cert.subject}, issuer #{ssl_cert.issuer})"
+elsif ssl_error
+  $logger.warn "Connected to #{url} with ssl errors: #{ssl_error}"
+elsif ssl_cert && !ws.ssl_verify?
+  $logger.warn "Connected to #{url} without ssl verify: #{ssl_cert.subject} (issuer #{ssl_cert.issuer})"
+elsif ssl_cert
+  $logger.info "Connected to #{url} with ssl verify: #{ssl_cert.subject} (issuer #{ssl_cert.issuer})"
+else
+  $logger.info "Connected to #{url} without ssl"
+end
+```
+
+* `ERROR -- websocket-echo-client: certificate verify failed: self signed certificate`
+* `WARN -- websocket-echo-client: Connected to wss://localhost:9293 with ssl errors: certificate verify failed: self signed certificate (subject /CN=kontena.test, issuer /CN=kontena.test)`
+* `WARN -- websocket-echo-client: Connected to wss://echo.websocket.org without ssl verify: /OU=Domain Control Validated/CN=*.websocket.org (issuer /C=US/ST=Arizona/L=Scottsdale/O=GoDaddy.com, Inc./OU=http://certs.godaddy.com/repository//CN=Go Daddy Secure Certificate Authority - G2)`
+* `INFO -- websocket-echo-client: Connected to wss://echo.websocket.org with ssl verify: /OU=Domain Control Validated/CN=*.websocket.org (issuer /C=US/ST=Arizona/L=Scottsdale/O=GoDaddy.com, Inc./OU=http://certs.godaddy.com/repository//CN=Go Daddy Secure Certificate Authority - G2)`
+* `INFO -- websocket-echo-client: Connected to ws://echo.websocket.org without ssl`
+
+### Examples
+
+Use `bundle exec ./examples/...` to run the examples.
+
+#### [Websocket Echo Client](./examples/websocket-echo-client.rb)
+
+Connect to a websocket server, displaying the server SSL certificate. Send lines from `stdin`, and write messages to `stdout`. Close on `EOF`.
+
+```
+I, [2017-07-21T17:06:48.353944 #17507]  INFO -- : Connecting to wss://echo.websocket.org...
+I, [2017-07-21T17:06:49.329616 #17507]  INFO -- : Connected to wss://echo.websocket.org with ssl verify: /OU=Domain Control Validated/CN=*.websocket.org (issuer /C=US/ST=Arizona/L=Scottsdale/O=GoDaddy.com, Inc./OU=http://certs.godaddy.com/repository//CN=Go Daddy Secure Certificate Authority - G2)
+hello
+D, [2017-07-21T17:06:50.447423 #17507] DEBUG -- : websocket write: "hello\n"
+D, [2017-07-21T17:06:50.578683 #17507] DEBUG -- : websocket read: "hello\n"
+hello
+D, [2017-07-21T17:06:51.135395 #17507] DEBUG -- : websocket close: EOF
+I, [2017-07-21T17:06:51.375279 #17507]  INFO -- : Client closed connection with code 1000: EOF
+```
+
+## Contributing
+
+Bug reports and pull requests are welcome on GitHub at https://github.com/kontena/kontena-websocket-client.

data/gems/kontena-websocket-client-0.1.1/Rakefile

@@ -0,0 +1,6 @@
+require "bundler/gem_tasks"
+require "rspec/core/rake_task"
+
+RSpec::Core::RakeTask.new(:spec)
+
+task :default => :spec

data/gems/kontena-websocket-client-0.1.1/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/gems/kontena-websocket-client-0.1.1/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/gems/kontena-websocket-client-0.1.1/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/gems/kontena-websocket-client-0.1.1/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/gems/kontena-websocket-client-0.1.1/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)
+	}
+}