kinetic_sdk 5.0.19 → 5.0.21

data/gems/kontena-websocket-client-0.1.1/benchmark/websocket-echo-server.go

@@ -1,207 +0,0 @@
-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/gems/kontena-websocket-client-0.1.1/examples/websocket-echo-client.rb

@@ -1,80 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'logger'
-require 'kontena-websocket-client'
-
-$logger = Logger.new(STDERR)
-$logger.progname = 'websocket-echo-client'
-
-def websocket_echo_writer(ws)
-  while line = $stdin.gets
-    $logger.debug "websocket write: #{line.inspect}"
-    ws.send(line)
-  end
-  $logger.debug "websocket close: EOF"
-
-  ws.close(1000, "EOF")
-end
-
-def websocket_echo_reader(ws)
-  ws.read do |msg|
-    $logger.debug "websocket read: #{msg.inspect}"
-    $stderr.puts msg
-  end
-end
-
-def websocket_echo_client(url, **options)
-  write_thread = nil
-
-  $logger.info "Connecting to #{url}..."
-
-  Kontena::Websocket::Client.connect(url, **options) do |ws|
-    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
-
-    write_thread = Thread.new {
-      websocket_echo_writer(ws)
-    }
-
-    websocket_echo_reader(ws)
-
-    $logger.info "Client closed connection with code #{ws.close_code}: #{ws.close_reason}"
-  end
-
-rescue Kontena::Websocket::CloseError => exc
-  $logger.info "#{exc}"
-rescue Kontena::Websocket::Error => exc
-  $logger.error "#{exc}"
-ensure
-  if write_thread
-    write_thread.kill
-    write_thread.join
-  end
-end
-
-url = ARGV[0] || ENV['WEBSOCKET_URL'] || 'wss://echo.websocket.org'
-ssl_verify = ENV['WEBSOCKET_SSL_VERIFY']
-ssl_verify = !ssl_verify.nil? && !ssl_verify.empty?
-
-websocket_echo_client(url,
-  ssl_params: {
-    verify_mode: ssl_verify ? OpenSSL::SSL::VERIFY_PEER : OpenSSL::SSL::VERIFY_NONE,
-  },
-)

data/gems/kontena-websocket-client-0.1.1/kontena-websocket-client.gemspec

@@ -1,24 +0,0 @@
-# coding: utf-8
-Gem::Specification.new do |spec|
-  spec.name          = "kontena-websocket-client"
-  spec.version       = '0.1.1'
-  spec.authors       = ["Kontena, Inc"]
-  spec.email         = ["info@kontena.io"]
-
-  spec.summary       = %q{Websocket client library}
-  spec.homepage      = "https://github.com/kontena/kontena-websocket-client"
-  spec.license       = "Apache-2.0"
-
-  spec.files         = `git ls-files -z`.split("\x0").reject do |f|
-    f.match(%r{^(test|spec|features)/})
-  end
-  spec.bindir        = "bin"
-  spec.executables   = spec.files.grep(%r{^bin/}) { |f| File.basename(f) }
-  spec.require_paths = ["lib"]
-
-  spec.add_dependency "websocket-driver", '~> 0.6.5'
-
-  spec.add_development_dependency "bundler", "~> 1.15"
-  spec.add_development_dependency "rake", "~> 10.0"
-  spec.add_development_dependency "rspec", "~> 3.0"
-end

data/gems/kontena-websocket-client-0.1.1/lib/kontena/websocket/client/connection.rb

@@ -1,119 +0,0 @@
-# WebSocket::Driver.client(...) API
-class Kontena::Websocket::Client::Connection
-  include Kontena::Websocket::Logging
-
-  # ruby version >= 2.3
-  module Waitable
-    # @param socket [Socket]
-    # @param timeout [Float] default (nil) blocks indefinitely
-    # @raise [Kontena::Websocket::TimeoutError]
-    def wait_socket_readable!(socket, timeout = nil)
-      debug "wait read: timeout=#{timeout}"
-
-      unless @socket.wait_readable(timeout)
-        raise Kontena::Websocket::TimeoutError, "read timeout after #{timeout}s"
-      end
-    end
-
-    # @param socket [Socket]
-    # @param timeout [Float] default (nil) blocks indefinitely
-    # @raise [Kontena::Websocket::TimeoutError]
-    def wait_socket_writable!(socket, timeout = nil)
-      debug "wait write: timeout=#{timeout}"
-
-      unless @socket.wait_writable(timeout)
-        raise Kontena::Websocket::TimeoutError, "write timeout after #{timeout}s"
-      end
-    end
-  end
-
-  # ruby version <= 2.2
-  #
-  # io/wait IO#wait_readable returns nil on EOF
-  module Waitable_Ruby2_2
-    # @param socket [Socket]
-    # @param timeout [Float] default (nil) blocks indefinitely
-    # @raise [Kontena::Websocket::TimeoutError]
-    def wait_socket_readable!(socket, timeout = nil)
-      debug "wait read: timeout=#{timeout}"
-
-      unless IO.select([socket], nil, nil, timeout)
-        raise Kontena::Websocket::TimeoutError, "read timeout after #{timeout}s"
-      end
-    end
-
-    # @param socket [Socket]
-    # @param timeout [Float] default (nil) blocks indefinitely
-    # @raise [Kontena::Websocket::TimeoutError]
-    def wait_socket_writable!(socket, timeout = nil)
-      debug "wait write: timeout=#{timeout}"
-
-      unless IO.select(nil, [socket], nil, timeout)
-        raise Kontena::Websocket::TimeoutError, "write timeout after #{timeout}s"
-      end
-    end
-  end
-
-  if Kontena::Websocket::Client.ruby_version? '2.3'
-    require 'io/wait'
-    include Waitable
-  else
-    include Waitable_Ruby2_2
-  end
-
-  attr_reader :uri
-
-  # @param uri [URI]
-  # @param socket [TCPSocket, OpenSSL::SSL::SSLSocket]
-  # @param write_timeout [Float] per each write syscall
-  def initialize(uri, socket, write_timeout: nil)
-    @uri = uri
-    @socket = socket
-    @write_timeout = write_timeout
-  end
-
-  # @return [String]
-  def url
-    @uri.to_s
-  end
-
-  # Wait up to timeout before retrying any blocking operation.
-  #
-  # @param timeout [Float] default (nil) blocks indefinitely
-  # @raise [Kontena::Websocket::TimeoutError]
-  def nonblocking_timeout(timeout = nil, &block)
-    return yield
-  rescue IO::WaitReadable
-    wait_socket_readable!(@socket, timeout) # raises Kontena::Websocket::TimeoutError
-    retry
-  rescue IO::WaitWritable
-    wait_socket_writable!(@socket, timeout) # raises Kontena::Websocket::TimeoutError
-    retry
-  end
-
-  # @param size [Integer]
-  # @param timeout [Float]
-  # @raise [EOFError]
-  # @return [String] 0..size bytes
-  def read(size, timeout: nil)
-    buf = nonblocking_timeout(timeout) do
-      @socket.read_nonblock(size)
-    end
-
-    debug "read size=#{size}: #buf=#{buf.size}"
-
-    return buf
-  end
-
-  # @param buf [String]
-  def write(buf)
-    until buf.empty?
-      # it can take more than the timeout to write out the entire buffer
-      size = nonblocking_timeout(@write_timeout) do
-        @socket.write_nonblock(buf)
-      end
-      debug "write #buf=#{buf.size}: size=#{size}"
-      buf = buf[size..-1]
-    end
-  end
-end

data/gems/kontena-websocket-client-0.1.1/lib/kontena/websocket/client/version.rb

@@ -1,13 +0,0 @@
-class Kontena::Websocket::Client
-  VERSION = "0.1.1"
-
-  # Running ruby >= version?
-  # @param gte_version [String]
-  # @return [Boolean]
-  def self.ruby_version?(gte_version)
-    ruby_version = RUBY_VERSION.split('.').map{|x|x.to_i}
-    gte_version = gte_version.split('.').map{|x|x.to_i}
-
-    return (ruby_version <=> gte_version) >= 0
-  end
-end