nchan_tools 0.1.1

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 03c7684cee5fb57143e8411351aea95d4bcb989cf8f2d66ebe716655f8f07b09
+  data.tar.gz: ed22f3cdd7eb55acab2ad29684daacd4e09edf0a3ffda1c4e2d5309affa896f3
+SHA512:
+  metadata.gz: 3009d9a05e5f8d6d81302cf81389be78ef165621fd433fd08beb1d16d0dcba5fa7cbcc6dd56a83a86a6d4756dcd609fa33136031bb4a50077f0d811405aef0ce
+  data.tar.gz: cae127fd3166e2442625f3a177e6060561fb8fb0056dc63cc14f03b89404c80a87e1cfd9ee2ed3a0078f91e6665c4b090492f257e5e308368af1cff32a0e23c1

data/.gitignore

@@ -0,0 +1,8 @@
+/.bundle/
+/.yardoc
+/_yardoc/
+/coverage/
+/doc/
+/pkg/
+/spec/reports/
+/tmp/

data/CODE_OF_CONDUCT.md

@@ -0,0 +1,7 @@
+In the spirit of inclusiveness, cooperation and community, this software is 
+distributed with the strictly enforced CYHTFYW Code of Conduct. Failure to 
+comply with this code may result in punitive action and loss of privilege.
+
+## CYHTFYW Code of Conduct:
+
+1. Conduct yourself however the fuck you want.

data/Gemfile

@@ -0,0 +1,6 @@
+source "https://rubygems.org"
+
+git_source(:github) {|repo_name| "https://github.com/#{repo_name}" }
+
+# Specify your gem's dependencies in nchan_tools.gemspec
+gemspec

data/LICENSE.txt

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2018 Leo Ponomarev
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.

data/README.md

@@ -0,0 +1,3 @@
+# NchanTools
+
+these here be development tools for Nchan. Documentation forthcoming someday maybe.

data/Rakefile

@@ -0,0 +1,2 @@
+require "bundler/gem_tasks"
+task :default => :spec

data/bin/console

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require "bundler/setup"
+require "nchan_tools"
+
+# You can add fixtures and/or initialization code here to make experimenting
+# with your gem easier. You can also use a different console, if you like.
+
+# (If you use this, don't forget to add pry to your Gemfile!)
+# require "pry"
+# Pry.start
+
+require "irb"
+IRB.start(__FILE__)

data/bin/setup

@@ -0,0 +1,8 @@
+#!/usr/bin/env bash
+set -euo pipefail
+IFS=$'\n\t'
+set -vx
+
+bundle install
+
+# Do any other automated setup that you need to do here

data/exe/nchan-benchmark

@@ -0,0 +1,214 @@
+#!/usr/bin/env ruby
+
+require 'securerandom'
+require 'nchan_tools/pubsub'
+require "optparse"
+require 'timers'
+require 'json'
+require "pry"
+require "HDRHistogram"
+
+verbose = false
+
+opt_parser=OptionParser.new do |opts|
+  opts.on("-v", "--verbose", "somewhat rather extraneously wordful output") do
+    verbose = true
+  end
+end
+opt_parser.banner="Usage: benchan.rb [options] url1 url2 url3..."
+opt_parser.parse!
+
+urls = []
+urls += ARGV
+begin
+  urls += STDIN.read_nonblock(100000).split /\s*\n+\s*/
+rescue IO::WaitReadable
+end
+
+urls.uniq!
+
+class Benchan
+  def initialize(urls)
+    @urls = urls
+    @n = urls.count
+    @initializing = 0
+    @ready = 0
+    @running = 0
+    @finished = 0
+    @subs = []
+    @results = {}
+    @failed = {}
+    
+    @hdrh_publish = nil
+    @hdrh_receive = nil
+    
+    subs = []
+  end
+  
+  def run
+    puts "connecting to #{@n} Nchan server#{@n > 1 ? "s" : ""}..."
+    @urls.each do |url|
+      sub = Subscriber.new(url, 1, client: :websocket, timeout: 900000, extra_headers: {"Accept" => "text/x-json-hdrhistogram"})
+      sub.on_failure do |err|
+        unless @results[sub]
+          unless @results[sub.url]
+            @failed[sub] = true
+            abort err, sub
+          end
+        end
+        false
+      end
+      sub.on_message do |msg|
+        msg = msg.to_s
+        case msg
+        when "READY"
+          puts   "  #{sub.url} ok"
+          @ready +=1
+          if @ready == @n
+            control :run
+            puts "start benchmark..."
+          end
+        when "RUNNING"
+          puts   "  #{sub.url} running"
+        when /^RESULTS\n/
+          msg = msg[8..-1]
+          parsed = JSON.parse msg
+          @results[sub.url] = parsed
+          1+1
+        else
+          binding.pry
+          1+1
+        end
+      end
+      @subs << sub
+      sub.run
+      sub.wait :ready, 1
+      if @failed[sub]
+        puts "  #{sub.url} failed"
+      else
+        puts "  #{sub.url} ok"
+      end
+    end
+    return if @failed.count > 0
+    puts "initializing benchmark..."
+    control :initialize
+    self.wait
+    puts "finished."
+    puts ""
+  end
+  
+  def wait
+    @subs.each &:wait
+  end
+  
+  def control(msg)
+    @subs.each { |sub| sub.client.send_data msg.to_s }
+  end
+  
+  def abort(err, src_sub = nil)
+    puts "  #{err}"
+    @subs.each do |sub|
+      sub.terminate unless sub == src_sub
+    end
+  end
+  
+  def hdrhistogram_stats(name, histogram)
+    fmt = <<-END.gsub(/^ {6}/, '')
+      %s
+        min:                         %.3fms
+        avg:                         %.3fms
+        99%%ile:                      %.3fms
+        max:                         %.3fms
+        stddev:                      %.3fms
+        samples:                     %d
+    END
+    fmt % [ name,
+      histogram.min, histogram.mean, histogram.percentile(99.0), histogram.max, histogram.stddev, histogram.count
+    ]
+  end
+  
+  def results
+    channels = 0
+    runtime = []
+    subscribers = 0
+    message_length = []
+    messages_sent = 0
+    messages_send_confirmed = 0
+    messages_send_unconfirmed = 0
+    messages_send_failed = 0
+    messages_received = 0
+    messages_unreceived = 0
+    hdrh_publish = nil
+    hdrh_receive = nil
+    @results.each do |url, data|
+      channels += data["channels"]
+      runtime << data["run_time_sec"]
+      subscribers += data["subscribers"]
+      message_length << data["message_length"]
+      messages_sent += data["messages"]["sent"]
+      messages_send_confirmed += data["messages"]["send_confirmed"]
+      messages_send_unconfirmed += data["messages"]["send_unconfirmed"]
+      messages_send_failed += data["messages"]["send_failed"]
+      messages_received += data["messages"]["received"]
+      messages_unreceived += data["messages"]["unreceived"]
+      
+      if data["message_publishing_histogram"]
+        hdrh = HDRHistogram.unserialize(data["message_publishing_histogram"], unit: :ms, multiplier: 0.001)
+        if hdrh_publish
+          hdrh_publish.merge! hdrh
+        else
+          hdrh_publish = hdrh
+        end
+      end
+      if data["message_delivery_histogram"]
+        hdrh = HDRHistogram.unserialize(data["message_delivery_histogram"], unit: :ms, multiplier: 0.001)
+        if hdrh_receive
+          hdrh_receive.merge! hdrh
+        else
+          hdrh_receive = hdrh
+        end
+      end
+    end
+    
+    message_length.uniq!
+    runtime.uniq!
+    
+    fmt = <<-END.gsub(/^ {6}/, '')
+      Nchan servers:                 %d
+      runtime:                       %s
+      channels:                      %d
+      subscribers:                   %d
+      subscribers per channel:       %.1f
+      messages:
+        length:                      %s
+        sent:                        %d
+        send_confirmed:              %d
+        send_unconfirmed:            %d
+        send_failed:                 %d
+        received:                    %d
+        unreceived:                  %d
+        send rate:                   %.3f/sec
+        receive rate:                %.3f/sec
+        send rate per channel:       %.3f/min
+        receive rate per subscriber: %.3f/min
+    END
+    out = fmt % [
+      @n, runtime.join(","), channels, subscribers, subscribers.to_f/channels,
+      message_length.join(","), messages_sent, messages_send_confirmed, messages_send_unconfirmed, messages_send_failed, 
+      messages_received, messages_unreceived,
+      messages_sent.to_f/runtime.max,
+      messages_received.to_f/runtime.max,
+      (messages_sent.to_f* 60)/(runtime.max*channels),
+      (messages_received.to_f * 60)/(runtime.max * subscribers)
+    ]
+    
+    out << hdrhistogram_stats("message publishing latency", hdrh_publish) if hdrh_publish
+    out << hdrhistogram_stats("message delivery latency", hdrh_receive) if hdrh_receive
+    
+    puts out
+  end
+end
+
+benchan = Benchan.new urls
+benchan.run
+benchan.results

data/exe/nchan-pub

@@ -0,0 +1,96 @@
+#!/usr/bin/env ruby
+require 'securerandom'
+require 'nchan_tools/pubsub'
+require "optparse"
+server= "localhost:8082"
+msg=false
+loop=false
+repeat_sec=0.5
+content_type=nil
+eventsource_event=nil
+msg_gen = false
+on_response=Proc.new {}
+method=:POST
+runonce=false
+accept = nil
+timeout = 3
+verbose = nil
+url=nil
+websocket = nil
+
+opt=OptionParser.new do |opts|
+  opts.on("-s", "--server SERVER (#{server})", "server and port.") {|v| server=v}
+  opts.on("--url FULL_URL", "publishing url") {|v| url=v}
+  opts.on("-v", "--verbose", "Blabberhttp"){verbose=true}
+  opts.on("-l", "--loop [SECONDS]", "re-send message every N seconds (#{repeat_sec})") do |v| 
+    loop=true
+    repeat_sec=Float(v) unless v.nil?
+  end
+  opts.on("-M", "--method [#{method}]", "method for request to server"){|v| method= v.upcase.to_sym}
+  opts.on("-m", "--message MSG", "publish this message instead of prompting"){|v| msg=v}
+  opts.on("-1", "--once", "run once then exit"){runonce=true}
+  opts.on("-a", "--accept TYPE", "set Accept header"){|v| accept=v}
+  opts.on("-c", "--content-type TYPE", "set content-type for all messages"){|v| content_type=v}
+  opts.on(      "--eventsource_event EVENT", "event: line for eversource subscribers"){|v| eventsource_event=v}
+  opts.on("-e",  "--eval RUBY_BLOCK", '{|n| "message #{n}" }'){|v| msg_gen = eval " Proc.new #{v} "}
+  opts.on("-w", "--websocket", "user websocket to publish"){websocket = true}
+  opts.on("-d", "--delete", "delete channel via a DELETE request"){method = :DELETE}
+  opts.on("-p", "--put", "create channel without submitting message"){method = :PUT}
+  opts.on("-t", "--timeout SECONDS", "publishing timeout (sec). default #{timeout} sec"){|v| timeout = v.to_i}
+  opts.on("-r",  "--response", 'Show response code and body') do
+    on_response = Proc.new do |code, body|
+      puts code
+      puts body
+    end
+  end
+end
+opt.banner="Usage: pub.rb [options] url"
+opt.parse!
+
+url ||= "http://#{server}#{ARGV.last}"
+
+puts "Publishing to #{url}."
+
+
+loopmsg=("\r"*20) + "sending message #"
+
+pub = Publisher.new url, nostore: true, timeout: timeout, verbose: verbose, websocket: websocket
+pub.accept=accept
+pub.nofail=true
+repeat=true
+i=1
+if loop then
+  puts "Press enter to send message."
+end
+while repeat do
+  if msg or msg_gen
+    if loop
+      sleep repeat_sec
+      print "#{loopmsg} #{i}"
+    elsif !runonce
+      STDIN.gets
+    end
+    if msg
+      pub.submit msg, method, content_type, eventsource_event, &on_response
+    elsif msg_gen
+      this_msg = msg_gen.call(i).to_s
+      puts this_msg
+      pub.submit this_msg, method, content_type, eventsource_event, &on_response
+    end
+  else
+    if loop
+      puts "Can't repeat with custom message. use -m option"
+    end
+    puts "Enter message, press enter twice."
+    message = ""
+    while((line = STDIN.gets) != "\n") do #doesn't work when there are parameters. wtf?
+      message << line
+    end
+    message=message[0..-2] #remove trailing newline
+    
+    pub.submit message, method, content_type, eventsource_event, &on_response
+    puts ""
+  end
+  i+=1
+  exit 0 if runonce
+end

data/exe/nchan-sub

@@ -0,0 +1,139 @@
+#!/usr/bin/env ruby
+
+require 'securerandom'
+require 'nchan_tools/pubsub'
+require "optparse"
+require 'timers'
+
+server= "localhost:8082"
+par=1
+
+opt = {
+  timeout:      60,
+  quit_message: 'FIN',
+  client:       :longpoll,
+  extra_headers: nil,
+  nostore:       true,
+  http2:         false
+}
+
+no_message=false
+print_content_type = false
+show_id=false
+origin = nil
+
+permessage_deflate = false
+ws_meta_subprotocol = false
+
+url = nil
+sub = nil
+
+opt_parser=OptionParser.new do |opts|
+  opts.on("-s", "--server SERVER (#{server})", "server and port."){|v| server=v}
+  opts.on("-p", "--parallel NUM (#{par})", "number of parallel clients"){|v| par = v.to_i}
+  opts.on("-t", "--timeout SEC (#{opt[:timeout]})", "Long-poll timeout"){|v| opt[:timeout] = v}
+  opts.on("-q", "--quit STRING (#{opt[:quit_message]})", "Quit message"){|v| opt[:quit_message] = v}
+  opts.on("-c", "--client STRING (#{opt[:client]})", "sub client (one of #{Subscriber::Client.unique_aliases.join ', '})") do |v|
+    opt[:client] = v.to_sym
+  end
+  opts.on("--content-type", "show received content-type"){|v| print_content_type = true}
+  opts.on("-i", "--id", "Print message id (last-modified and etag headers)."){|v| show_id = true}
+  opts.on("-n", "--no-message", "Don't output retrieved message."){|v| no_message = true}
+  opts.on("--origin STR", "Set Origin header if appplicable."){|v| origin = v}
+  opts.on("--url URL", "full subscriber url") do |v|
+    url = v
+  end
+  opts.on("--http2", "use HTTP/2"){opt[:http2] = true}
+  
+  opts.on("--websocket-permessage-deflate", "Try to use the websocket permessage-deflate extension."){opt[:permessage_deflate]=true}
+  opts.on("--websocket-permessage-deflate-max-window-bits NUM", "max-window-bits permessage-deflate setting") {|n|opt[:permessage_deflate_max_window_bits]=n.to_i}
+  opts.on("--websocket-permessage-deflate-server-max-window-bits NUM", "server-max-window-bits permessage-deflate setting") {|n|opt[:permessage_deflate_server_max_window_bits]=n.to_i}
+  opts.on("--websocket-meta-subprotocol", "Use the ws+meta.nchan websocket subprotocol"){opt[:subprotocol]="ws+meta.nchan"}
+  
+  opts.on("-v", "--verbose", "somewhat rather extraneously wordful output") do
+    opt[:verbose] = true
+    Typhoeus::Config.verbose=true
+  end
+end
+opt_parser.banner="Usage: sub.rb [options] url"
+opt_parser.parse!
+
+url ||= "#{opt[:http2] ? 'h2' : 'http'}://#{server}#{ARGV.last}"
+
+puts "Subscribing #{par} #{opt[:client]} client#{par!=1 ? "s":""} to #{url}."
+puts "Timeout: #{opt[:timeout]}sec, quit msg: #{opt[:quit_message]}"
+
+if origin
+  opt[:extra_headers] ||= {}
+  opt[:extra_headers]['Origin'] = origin
+end
+
+sub = Subscriber.new url, par, opt
+
+
+NOMSGF="\r"*30 + "Received message %i, len:%i"
+if no_message
+  class OutputTimer
+    include Celluloid
+    attr_reader :fired, :timer
+
+    def initialize(interval = 0.5)
+      @count = 0
+      @last_msg_length = 0 
+      @timer = every(interval) do
+        printf NOMSGF, @count, @last_msg_length
+      end
+    end
+    
+    def incoming(msg)
+      @count += 1
+      @last_msg_length = msg.message.length
+    end
+  end
+  
+  output_timer = OutputTimer.new
+end
+
+sub.on_message do |msg|
+  if no_message
+    output_timer.incoming(msg)
+  else
+    if msg.content_type
+      out = "(#{msg.content_type}) #{msg}"
+    else
+      out = msg.to_s
+    end
+    if show_id
+      out = "<#{msg.id}> #{out}"
+    end
+    puts out
+  end
+end
+
+sub.on_failure do |err_msg|
+  if Subscriber::IntervalPollClient === sub.client
+    unless err_msg.match(/\(code 304\)/)
+      false
+    end 
+  else
+    false
+  end
+end
+
+sub.run
+begin
+  sub.wait
+rescue Interrupt => e
+  #do nothing
+end
+
+output_timer.terminate if output_timer
+
+
+if sub.errors.count > 0
+  puts "Errors:"
+  sub.errors.each do |err|
+    puts err
+  end
+  exit 1
+end