kinetic_sdk 0.1.1

data/gems/kontena-websocket-client-0.1.1/examples/websocket-echo-client.rb

@@ -0,0 +1,80 @@
+#!/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

@@ -0,0 +1,24 @@
+# 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

@@ -0,0 +1,119 @@
+# 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

@@ -0,0 +1,13 @@
+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