kpumuk-thrift 0.24.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: f0dfce780ae29e9f1b5b569e545ccc69b0c157ee66a419d3a33d1d1ce80fb3e1
+  data.tar.gz: '08590bca4dc532c304d00cd855ff0c6c8833da44c5f6f70d74e8e84140492129'
+SHA512:
+  metadata.gz: 220d0f33b4ea153ab47d777cee1105e11e109cc7f35272e91abad94ffa6387050ef6b0a1db928f4d31cdfa41c339898ce8d8e7e002288a9cc7a01aa6caf69443
+  data.tar.gz: e5e21dc48a3fc494478d280d304d25614a66b85bf3e8b440c21474bf022b71b3a11b705274beefe97828bc288b7f68da9eb3437ac23be21a2627fa7c8ad43ecb

data/README.md

@@ -0,0 +1,201 @@
+# Thrift Ruby Software Library
+
+## License
+
+Licensed to the Apache Software Foundation (ASF) under one
+or more contributor license agreements. See the NOTICE file
+distributed with this work for additional information
+regarding copyright ownership. The ASF licenses this file
+to you under the Apache License, Version 2.0 (the
+"License"); you may not use this file except in compliance
+with the License. You may obtain a copy of the License at
+
+  http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing,
+software distributed under the License is distributed on an
+"AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, either express or implied. See the License for the
+specific language governing permissions and limitations
+under the License.
+
+# Using Thrift with Ruby
+
+Ruby bindings for the Apache Thrift RPC system. The gem contains the runtime
+types, transports, protocols, and servers used by generated Ruby code for both
+clients and services.
+
+## Compatibility
+
+- Ruby MRI >= 2.7 (tested against current supported releases).
+- JRuby works with the pure-Ruby implementation; the native extension is
+  skipped automatically.
+- For the repo-wide transport, protocol, and server support matrix, see
+  [Language Feature Matrix](https://github.com/apache/thrift/blob/master/LANGUAGES.md). This README focuses on Ruby-specific
+  behavior and migration notes.
+
+## Installation
+
+- Requirements: Ruby >= 2.7.
+- From RubyGems: `gem install thrift`
+- From source: `bundle install`, `gem build thrift.gemspec`, then install the
+  resulting `thrift-*.gem`. The native accelerator is built when the gem is
+  installed on supported runtimes.
+
+## Generating Ruby Code
+
+The Ruby library does not include the Thrift compiler. Use a compiler built
+from the root of this repository to generate Ruby bindings:
+
+    thrift --gen rb path/to/service.thrift
+    # with namespaced modules
+    thrift --gen rb:namespaced --recurse path/to/service.thrift
+
+Generated files are typically written to `gen-rb/` and can be required
+directly from your application.
+
+## Basic Client Usage
+
+    $:.push File.expand_path('gen-rb', __dir__)
+    require 'thrift'
+    require 'calculator'
+
+    socket     = Thrift::Socket.new('localhost', 9090)
+    transport  = Thrift::BufferedTransport.new(socket)
+    protocol   = Thrift::BinaryProtocol.new(transport)
+    client     = Calculator::Client.new(protocol)
+
+    transport.open
+    puts client.add(1, 1)
+    transport.close
+
+## Basic Server Usage
+
+    $:.push File.expand_path('gen-rb', __dir__)
+    require 'thrift'
+    require 'calculator'
+
+    class CalculatorHandler
+      def add(a, b)
+        a + b
+      end
+    end
+
+    handler            = CalculatorHandler.new
+    processor          = Calculator::Processor.new(handler)
+    server_transport   = Thrift::ServerSocket.new(9090)
+    transport_factory  = Thrift::BufferedTransportFactory.new
+    protocol_factory   = Thrift::BinaryProtocolFactory.new
+
+    server = Thrift::ThreadedServer.new(processor, server_transport,
+                                        transport_factory, protocol_factory)
+    server.serve
+
+## Development and Tests
+
+- `bundle exec rake spec` runs the Ruby specs. It expects a built Thrift
+  compiler at `../../compiler/cpp/thrift`.
+- `bundle exec rake test` runs the cross-language test suite; it must be
+  executed from a full Thrift checkout.
+- `bundle exec rake build_ext` (implicit in the tasks above) compiles the
+  optional native extension that accelerates protocols and buffers.
+
+## More Ruby Code
+
+- Tutorial client and server: `tutorial/rb/RubyClient.rb` and `tutorial/rb/RubyServer.rb`
+- Runtime benchmarks: `lib/rb/benchmark`
+- Protocol benchmark: `test/rb/benchmarks/protocol_benchmark.rb`
+- Library specs: `lib/rb/spec`
+- Fuzzing harnesses and notes: `lib/rb/test/fuzz`
+- Cross-language and integration tests: `test/rb`
+
+## Breaking Changes
+
+### 0.23.0
+
+The documented source-build flow now effectively requires Ruby `2.7+`.
+The committed development bundle no longer resolves on Ruby `2.6`
+(`json-2.18.1 requires ruby version >= 2.7`), so building and testing this
+library from source should be treated as `2.7+`.
+
+Generated structs and unions now consistently raise
+`Thrift::ProtocolException::INVALID_DATA` for invalid payloads such as unset
+required fields, invalid enum values, or invalid union state. If your
+application or tests matched older exception types or messages, update them.
+
+Regenerated Ruby clients now validate replies more strictly. Mismatched reply
+message types, method names, or sequence IDs raise
+`Thrift::ApplicationException::INVALID_MESSAGE_TYPE`,
+`Thrift::ApplicationException::WRONG_METHOD_NAME`, or
+`Thrift::ApplicationException::BAD_SEQUENCE_ID`. If you relied on older,
+looser reply handling in servers, proxies, or tests, regenerate and update
+those call paths together.
+
+Generated Ruby clients have never been safe to share across concurrent
+threads. A client tracks pending sequence IDs on a single reply stream, so use
+one client/transport pair per thread or serialize access yourself.
+
+Treat `Thrift::ApplicationException::BAD_SEQUENCE_ID` as a correctness bug
+that needs immediate attention. It means the client read a reply whose
+sequence ID did not match the next pending request, so the connection may
+already be out of sync and you may be reading a reply intended for a
+different call. The most common cause is sharing one client across threads,
+but a buggy proxy or server can also cause it.
+
+### 0.13.0
+
+Ruby development and CI moved to Ruby `2.4+`, but the runtime still claimed
+support for older interpreters. Treat Ruby `< 2.4` on the `0.13.x` line as
+best-effort, not guaranteed.
+
+- Historical note for very old releases: the Ruby runtime was rearranged to use
+  more Ruby-like names, and generated files switched to underscored filenames.
+  If you are upgrading very old code, regenerate your Ruby bindings and update
+  any old `T*` constants or legacy require paths such as
+  `TBinaryProtocol` -> `Thrift::BinaryProtocol`.
+- `rb:namespaced` changes the generated file layout. Flat output from
+  `thrift --gen rb` and namespaced output from `thrift --gen rb:namespaced`
+  use different require paths, so switch them atomically with regenerated code.
+
+      # --gen rb
+      require 'calculator'
+
+      # --gen rb:namespaced
+      require 'my_namespace/calculator'
+
+## Migration Notes
+
+- If you upgrade across the stricter reply-validation changes, regenerate all
+  Ruby stubs and deploy them with the matching Ruby runtime. Do not mix old
+  generated code, new generated code, and new runtime code on the same client
+  path without testing that combination.
+- If you receive `Thrift::ApplicationException::BAD_SEQUENCE_ID`, treat the
+  connection as out of sync. Close it, create a new client/transport pair, and
+  investigate the root cause before retrying.
+- Do not share one generated Ruby client across concurrent threads. Use one
+  client/transport pair per thread, or serialize access to a shared client.
+- If you switch between `thrift --gen rb` and `thrift --gen rb:namespaced`,
+  regenerate all Ruby output and update `require` paths in the same change.
+
+## Runtime Notes
+
+- Loading the `thrift_native` extension changes which implementation you are
+  running. It replaces
+  `Thrift::Struct`, `Thrift::Union`, and `Thrift::CompactProtocol` methods
+  with C implementations in place. `Thrift::BinaryProtocol` remains available
+  in pure Ruby, and the C-backed binary protocol is opt-in through
+  `Thrift::BinaryProtocolAcceleratedFactory` or
+  `Thrift::BinaryProtocolAccelerated` when that class is available.
+- The native extension is optional. If it cannot be built or loaded, Thrift
+  falls back to the pure-Ruby implementation. This mainly changes performance
+  and implementation details.
+- JRuby skips the native extension automatically and uses the pure-Ruby path.
+- Do not share one client instance across concurrent threads. A client tracks
+  request and reply state on a single transport stream.
+- `Thrift::NonblockingServer` expects framed input. Use
+  `Thrift::FramedTransport` with it on the wire.
+- Client and server must agree on transport and protocol choices. If you
+  switch to SSL, HTTP, header transport, compact protocol, or namespaced
+  generated code, update both ends together.
+- HTTPS client transport verifies peers by default, and `Thrift::SSLSocket`
+  performs a hostname check against the host you pass in.

data/benchmark/Benchmark.thrift

@@ -0,0 +1,24 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+namespace rb ThriftBenchmark
+
+service BenchmarkService {
+  i32 fibonacci(1:byte n)
+}

data/benchmark/benchmark.rb

@@ -0,0 +1,285 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+require 'rubygems'
+$:.unshift File.dirname(__FILE__) + '/../lib'
+$:.unshift File.dirname(__FILE__) + '/../ext'
+require 'thrift'
+require 'stringio'
+
+HOST = '127.0.0.1'
+PORT = 42587
+
+###############
+## Server
+###############
+
+class Server
+  attr_accessor :serverclass
+  attr_accessor :interpreter
+  attr_accessor :host
+  attr_accessor :port
+  attr_accessor :protocol_type
+
+  def initialize(opts)
+    @serverclass = opts.fetch(:class, Thrift::NonblockingServer)
+    @interpreter = opts.fetch(:interpreter, "ruby")
+    @host = opts.fetch(:host, ::HOST)
+    @port = opts.fetch(:port, ::PORT)
+    @protocol_type = opts.fetch(:protocol_type, 'binary')
+    @tls = opts.fetch(:tls, false)
+  end
+
+  def start
+    return if @serverclass == Object
+    args = (File.basename(@interpreter) == "jruby" ? "-J-server" : "")
+    @pipe = IO.popen("#{@interpreter} #{args} #{File.dirname(__FILE__)}/server.rb #{"-tls" if @tls} #{@host} #{@port} #{@serverclass.name} #{@protocol_type}", "r+")
+    Marshal.load(@pipe) # wait until the server has started
+    sleep 0.4 # give the server time to actually start spawning sockets
+  end
+
+  def shutdown
+    return unless @pipe
+    Marshal.dump(:shutdown, @pipe)
+    begin
+      @pipe.read(10) # block until the server shuts down
+    rescue EOFError
+    end
+    @pipe.close
+    @pipe = nil
+  end
+end
+
+class BenchmarkManager
+  def initialize(opts, server)
+    @socket = opts.fetch(:socket) do
+      @host = opts.fetch(:host, 'localhost')
+      @port = opts.fetch(:port)
+      nil
+    end
+    @num_processes = opts.fetch(:num_processes, 40)
+    @clients_per_process = opts.fetch(:clients_per_process, 10)
+    @calls_per_client = opts.fetch(:calls_per_client, 50)
+    @interpreter = opts.fetch(:interpreter, "ruby")
+    @server = server
+    @log_exceptions = opts.fetch(:log_exceptions, false)
+    @protocol_type = opts.fetch(:protocol_type, 'binary')
+    @tls = opts.fetch(:tls, false)
+  end
+
+  def run
+    @pool = []
+    @benchmark_start = Time.now
+    puts "Spawning benchmark processes..."
+    @num_processes.times do
+      spawn
+      sleep 0.02 # space out spawns
+    end
+    collect_output
+    @benchmark_end = Time.now # we know the procs are done here
+    translate_output
+    analyze_output
+    report_output
+  end
+
+  def spawn
+    pipe = IO.popen("#{@interpreter} #{File.dirname(__FILE__)}/client.rb #{"-log-exceptions" if @log_exceptions} #{"-tls" if @tls} #{@host} #{@port} #{@clients_per_process} #{@calls_per_client} #{@protocol_type}")
+    @pool << pipe
+  end
+
+  def socket_class
+    if @socket
+      Thrift::UNIXSocket
+    elsif @tls
+      Thrift::SSLSocket
+    else
+      Thrift::Socket
+    end
+  end
+
+  def collect_output
+    puts "Collecting output..."
+    # read from @pool until all sockets are closed
+    @buffers = Hash.new { |h, k| h[k] = '' }
+    until @pool.empty?
+      rd, = select(@pool)
+      next if rd.nil?
+      rd.each do |fd|
+        begin
+          @buffers[fd] << fd.readpartial(4096)
+        rescue EOFError
+          @pool.delete fd
+        end
+      end
+    end
+  end
+
+  def translate_output
+    puts "Translating output..."
+    @output = []
+    @buffers.each do |fd, buffer|
+      strio = StringIO.new(buffer)
+      logs = []
+      begin
+        loop do
+          logs << Marshal.load(strio)
+        end
+      rescue EOFError
+        @output << logs
+      end
+    end
+  end
+
+  def analyze_output
+    puts "Analyzing output..."
+    call_times = []
+    client_times = []
+    connection_failures = []
+    connection_errors = []
+    shortest_call = 0
+    shortest_client = 0
+    longest_call = 0
+    longest_client = 0
+    @output.each do |logs|
+      cur_call, cur_client = nil
+      logs.each do |tok, time|
+        case tok
+        when :start
+          cur_client = time
+        when :call_start
+          cur_call = time
+        when :call_end
+          delta = time - cur_call
+          call_times << delta
+          longest_call = delta unless longest_call > delta
+          shortest_call = delta if shortest_call == 0 or delta < shortest_call
+          cur_call = nil
+        when :end
+          delta = time - cur_client
+          client_times << delta
+          longest_client = delta unless longest_client > delta
+          shortest_client = delta if shortest_client == 0 or delta < shortest_client
+          cur_client = nil
+        when :connection_failure
+          connection_failures << time
+        when :connection_error
+          connection_errors << time
+        end
+      end
+    end
+    @report = {}
+    @report[:total_calls] = call_times.inject(0.0) { |a, t| a += t }
+    @report[:avg_calls] = @report[:total_calls] / call_times.size
+    @report[:total_clients] = client_times.inject(0.0) { |a, t| a += t }
+    @report[:avg_clients] = @report[:total_clients] / client_times.size
+    @report[:connection_failures] = connection_failures.size
+    @report[:connection_errors] = connection_errors.size
+    @report[:shortest_call] = shortest_call
+    @report[:shortest_client] = shortest_client
+    @report[:longest_call] = longest_call
+    @report[:longest_client] = longest_client
+    @report[:total_benchmark_time] = @benchmark_end - @benchmark_start
+    @report[:fastthread] = $".include?('fastthread.bundle')
+  end
+
+  def report_output
+    fmt = "%.4f seconds"
+    puts
+    tabulate "%d",
+             [["Server class", "%s"], @server.serverclass == Object ? "" : @server.serverclass],
+             [["Server interpreter", "%s"], @server.interpreter],
+             [["Client interpreter", "%s"], @interpreter],
+             [["Protocol type", "%s"], @protocol_type],
+             [["Socket class", "%s"], socket_class],
+             ["Number of processes", @num_processes],
+             ["Clients per process", @clients_per_process],
+             ["Calls per client", @calls_per_client],
+             [["Using fastthread", "%s"], @report[:fastthread] ? "yes" : "no"]
+    puts
+    failures = (@report[:connection_failures] > 0)
+    tabulate fmt,
+             [["Connection failures", "%d", [:red, :bold]], @report[:connection_failures]],
+             [["Connection errors", "%d", [:red, :bold]], @report[:connection_errors]],
+             ["Average time per call", @report[:avg_calls]],
+             ["Average time per client (%d calls)" % @calls_per_client, @report[:avg_clients]],
+             ["Total time for all calls", @report[:total_calls]],
+             ["Real time for benchmarking", @report[:total_benchmark_time]],
+             ["Shortest call time", @report[:shortest_call]],
+             ["Longest call time", @report[:longest_call]],
+             ["Shortest client time (%d calls)" % @calls_per_client, @report[:shortest_client]],
+             ["Longest client time (%d calls)" % @calls_per_client, @report[:longest_client]]
+  end
+
+  ANSI = {
+    :reset => 0,
+    :bold => 1,
+    :black => 30,
+    :red => 31,
+    :green => 32,
+    :yellow => 33,
+    :blue => 34,
+    :magenta => 35,
+    :cyan => 36,
+    :white => 37
+  }
+
+  def tabulate(fmt, *labels_and_values)
+    labels = labels_and_values.map { |l| Array === l ? l.first : l }
+    label_width = labels.inject(0) { |w, l| l.size > w ? l.size : w }
+    labels_and_values.each do |(l, v)|
+      f = fmt
+      l, f, c = l if Array === l
+      fmtstr = "%-#{label_width+1}s #{f}"
+      if STDOUT.tty? and c and v.to_i > 0
+        fmtstr = "\e[#{[*c].map { |x| ANSI[x] } * ";"}m" + fmtstr + "\e[#{ANSI[:reset]}m"
+      end
+      puts fmtstr % [l+":", v]
+    end
+  end
+end
+
+def resolve_const(const)
+  const and const.split('::').inject(Object) { |k, c| k.const_get(c) }
+end
+
+puts "Starting server..."
+protocol_type = ENV['THRIFT_PROTOCOL'] || 'binary'
+args = {}
+args[:interpreter] = ENV['THRIFT_SERVER_INTERPRETER'] || ENV['THRIFT_INTERPRETER'] || "ruby"
+args[:class] = resolve_const(ENV['THRIFT_SERVER']) || Thrift::NonblockingServer
+args[:host] = ENV['THRIFT_HOST'] || HOST
+args[:port] = (ENV['THRIFT_PORT'] || PORT).to_i
+args[:tls] = ENV['THRIFT_TLS'] == 'true'
+args[:protocol_type] = protocol_type
+server = Server.new(args)
+server.start
+
+args = {}
+args[:host] = ENV['THRIFT_HOST'] || HOST
+args[:port] = (ENV['THRIFT_PORT'] || PORT).to_i
+args[:tls] = ENV['THRIFT_TLS'] == 'true'
+args[:num_processes] = (ENV['THRIFT_NUM_PROCESSES'] || 40).to_i
+args[:clients_per_process] = (ENV['THRIFT_NUM_CLIENTS'] || 5).to_i
+args[:calls_per_client] = (ENV['THRIFT_NUM_CALLS'] || 50).to_i
+args[:interpreter] = ENV['THRIFT_CLIENT_INTERPRETER'] || ENV['THRIFT_INTERPRETER'] || "ruby"
+args[:log_exceptions] = !!ENV['THRIFT_LOG_EXCEPTIONS']
+args[:protocol_type] = protocol_type
+BenchmarkManager.new(args, server).run
+
+server.shutdown

data/benchmark/client.rb

@@ -0,0 +1,117 @@
+#
+# Licensed to the Apache Software Foundation (ASF) under one
+# or more contributor license agreements. See the NOTICE file
+# distributed with this work for additional information
+# regarding copyright ownership. The ASF licenses this file
+# to you under the Apache License, Version 2.0 (the
+# "License"); you may not use this file except in compliance
+# with the License. You may obtain a copy of the License at
+#
+#   http://www.apache.org/licenses/LICENSE-2.0
+#
+# Unless required by applicable law or agreed to in writing,
+# software distributed under the License is distributed on an
+# "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+# KIND, either express or implied. See the License for the
+# specific language governing permissions and limitations
+# under the License.
+#
+
+$:.unshift File.dirname(__FILE__) + '/../lib'
+$:.unshift File.dirname(__FILE__) + '/../ext'
+require 'thrift'
+require 'openssl'
+$:.unshift File.dirname(__FILE__) + "/gen-rb"
+require 'benchmark_service'
+
+class Client
+  def initialize(host, port, clients_per_process, calls_per_client, log_exceptions, tls, protocol_type)
+    @host = host
+    @port = port
+    @clients_per_process = clients_per_process
+    @calls_per_client = calls_per_client
+    @log_exceptions = log_exceptions
+    @tls = tls
+    @protocol_type = protocol_type || 'binary'
+  end
+
+  def create_protocol(socket)
+    case @protocol_type
+    when 'binary'
+      transport = Thrift::FramedTransport.new(socket)
+      Thrift::BinaryProtocol.new(transport)
+    when 'compact'
+      transport = Thrift::FramedTransport.new(socket)
+      Thrift::CompactProtocol.new(transport)
+    when 'header'
+      Thrift::HeaderProtocol.new(socket)
+    when 'header-compact'
+      Thrift::HeaderProtocol.new(socket, nil, Thrift::HeaderSubprotocolID::COMPACT)
+    when 'header-zlib'
+      protocol = Thrift::HeaderProtocol.new(socket)
+      protocol.add_transform(Thrift::HeaderTransformID::ZLIB)
+      protocol
+    else
+      transport = Thrift::FramedTransport.new(socket)
+      Thrift::BinaryProtocol.new(transport)
+    end
+  end
+
+  def run
+    @clients_per_process.times do
+      socket = if @tls
+        ssl_context = OpenSSL::SSL::SSLContext.new.tap do |ctx|
+          ctx.verify_mode = OpenSSL::SSL::VERIFY_PEER
+          ctx.min_version = OpenSSL::SSL::TLS1_2_VERSION
+
+          keys_dir = File.expand_path("../../../test/keys", __dir__)
+          ctx.ca_file = File.join(keys_dir, "CA.pem")
+          ctx.cert = OpenSSL::X509::Certificate.new(File.open(File.join(keys_dir, "client.crt")))
+          ctx.cert_store = OpenSSL::X509::Store.new
+          ctx.cert_store.add_file(File.join(keys_dir, 'server.pem'))
+          ctx.key = OpenSSL::PKey::RSA.new(File.open(File.join(keys_dir, "client.key")))
+        end
+
+        Thrift::SSLSocket.new(@host, @port, 5, ssl_context)
+      else
+        Thrift::Socket.new(@host, @port, 5)
+      end
+      protocol = create_protocol(socket)
+      transport = protocol.trans
+      client = ThriftBenchmark::BenchmarkService::Client.new(protocol)
+      begin
+        start = Time.now
+        transport.open
+        Marshal.dump [:start, start], STDOUT
+      rescue => e
+        Marshal.dump [:connection_failure, Time.now], STDOUT
+        print_exception e if @log_exceptions
+      else
+        begin
+          @calls_per_client.times do
+            Marshal.dump [:call_start, Time.now], STDOUT
+            client.fibonacci(15)
+            Marshal.dump [:call_end, Time.now], STDOUT
+          end
+          transport.close
+          Marshal.dump [:end, Time.now], STDOUT
+        rescue Thrift::TransportException => e
+          Marshal.dump [:connection_error, Time.now], STDOUT
+          print_exception e if @log_exceptions
+        end
+      end
+    end
+  end
+
+  def print_exception(e)
+    STDERR.puts "ERROR: #{e.message}"
+    STDERR.puts "\t#{e.backtrace * "\n\t"}"
+  end
+end
+
+log_exceptions = true if ARGV[0] == '-log-exceptions' and ARGV.shift
+tls = true if ARGV[0] == '-tls' and ARGV.shift
+
+host, port, clients_per_process, calls_per_client, protocol_type = ARGV
+
+Client.new(host, port.to_i, clients_per_process.to_i, calls_per_client.to_i, log_exceptions, tls, protocol_type).run