talkshow 1.4.2

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA1:
+  metadata.gz: 0defe1121946da84d88bfc719622b659c34d5033
+  data.tar.gz: c3e5c0855a41a9e698e543dcf3d1599bc067a80e
+SHA512:
+  metadata.gz: b3df5f71a04d10ceb8c07b713aff6de3c950c19ebbf1ac0606583ea34d94458de2a5a2cf22ff8cb40b42ec2594df659763342b08cdb3a5f91d4f33a5baef1784
+  data.tar.gz: 2fa658549eea26110bf46d37889768c44b1f6286ecffc790390c222d57cf164505292dd538710c4ecedcdd07dbe8e6c0785b73ed95f9c4c887c6a2d149407c84

data/lib/talkshow.rb

@@ -0,0 +1,241 @@
+require 'net/http'
+require 'thread'
+require 'json'
+require 'talkshow/server'
+require 'talkshow/timeout'
+require 'talkshow/javascript_error'
+require 'talkshow/queue'
+
+
+#Main class for talking to a talkshow instrumented js application.
+#
+#This is the only class you need to worry about, and there are only
+#a few important methods.
+#
+# Create the Talkshow client object:
+#   ts = Talkshow.new()
+# Start up the server
+#   ts.start_server()
+# Start executing javascript:
+#   ts.execute( 'alert "Hello world!"' )
+class Talkshow
+  attr_accessor :type
+  attr_accessor :thread
+  
+  # Create a new Talkshow object to get going:
+  def initialize
+  end
+
+  # Start up the Talkshow webserver
+  # This will be triggered if you don't do it -- but it takes a few
+  # seconds to start up the thin server, so you are better off
+  # issuing this yourself
+  def start_server(options = {})
+
+    # Backward compatibility
+    if options.is_a? String
+      url = options
+      port = nil
+      logfile = nil
+    else
+      url = options[:url]
+      port = options[:port]
+      logfile = options[:logfile]
+    end
+
+    url = ENV['TALKSHOW_REMOTE_URL'] if ENV['TALKSHOW_REMOTE_URL']
+    port = ENV['TALKSHOW_PORT'] if ENV['TALKSHOW_PORT']
+    logfile = ENV['TALKSHOW_LOG'] if ENV['TALKSHOW_LOG']
+
+    Talkshow::Server.set_port port if port
+    Talkshow::Server.set_logfile logfile if logfile
+    
+    if !url
+      @type = :thread
+      @question_queue = ::Queue.new
+      @answer_queue = ::Queue.new
+      @thread = Thread.new do
+        Talkshow::Server.question_queue(@question_queue)
+        Talkshow::Server.answer_queue(@answer_queue)
+        Talkshow::Server.run!
+      end
+    else
+      @type = :remote
+      @question_queue = Talkshow::Queue.new(url)
+      @answer_queue = Talkshow::Queue.new(url)
+    end
+    
+  end
+
+  # Stop the webserver
+  def stop_server
+    @thread.exit
+  end
+
+  # Invoke a function in the javascript application
+  # invoke requires a function name (including the namespace).
+  # Arguments are specified as an array reference.
+  #
+  # Some examples:
+  #     ts.invoke( 'alert' )
+  #     ts.invoke( 'alert', ['Hello world'])
+  #     ts.invoke( 'window.alert', ['Hello world'] )
+  def invoke( function, args, timeout=6 )
+    send_question( {
+        type: 'invocation',
+        function: function,
+        args: args
+      }, timeout)
+  end
+
+  # Send a javascript instruction to the client
+  def execute( command, timeout=6 )
+    send_question( { type: 'code', message: command }, timeout)
+  end
+  
+  # Load in a javascript file and execute remotely
+  def execute_file( filename )
+    text = File.read(filename)
+    execute(text)
+  end
+  
+  private
+ 
+  def soft_pop
+    begin
+      @answer_queue.pop(true)
+    rescue => e
+      nil
+    end
+  end
+  
+  def non_blocking_pop(timeout)
+    sleep_time = 0.1
+    answer = nil
+    catch(:done) do
+      (timeout/sleep_time).to_i.times { |i|
+        answer = soft_pop
+        throw :done if answer
+        sleep sleep_time
+      }
+    end
+    answer
+  end
+
+
+  # listen for an answer for a specific id, with a timeout, and also reconstitute
+  # any chunked responses
+  def listen_for_answer(id, timeout)
+ 
+    if ENV['TIMEOUT_MULTIPLIER']
+      timeout = ENV['TIMEOUT_MULTIPLIER'].to_i * timeout
+    end
+
+    answer = non_blocking_pop(timeout)
+    if !answer
+      raise Talkshow::Timeout.new
+    end
+    
+    mismatch_retry = 3
+    if answer[:id].to_i != id.to_i && mismatch_retry >= 0
+      puts "Talkshow warning: message mismatch (#{answer[:id]} vs #{id})" unless answer[:id].to_i == 0
+      answer = non_blocking_pop(timeout)
+      mismatch_retry -= 1
+    end
+
+    if !answer
+      raise Talkshow::Timeout.new
+    end
+    
+    chunks = answer[:chunks]
+    if chunks
+      answers = [answer]
+
+      i = 1
+      nil_count = 0
+      while ( i < chunks.to_i && nil_count < 3 ) do
+        candidate = non_blocking_pop(1)
+        if !candidate
+          nil_count += 1
+          next
+        end
+        if candidate[:id].to_i != id.to_i
+          puts "Talkshow warning: message mismatch (#{candidate[:id]} vs #{id.to_i})"
+          next
+        end
+        
+        nil_count = 0
+        i += 1
+        answers << candidate
+      end
+      
+      if answers.count < chunks.to_i
+        raise "Couldn't reconstitute whole message"
+      end
+      
+      sorted_answers = answers.sort_by{ |a| a[:payload].to_i }
+      data = sorted_answers.collect { |a| a[:data] }.join
+      answer[:data] = data
+      answer[:payload] = nil
+    end
+        
+    answer
+  end
+
+  
+  # Send message to js application
+  # Message is a hash that looks like:
+  #   {
+  #     type =>    message_type,
+  #     message => command,
+  #   }
+  # Timeout is optional, but a negative timeout returns without
+  # looking for an answer
+  def send_question( message, timeout )
+    
+    # Start the server if it hasn't been started already
+    self.start_server if (self.type == :thread && !self.thread)
+    
+    @answer_queue.clear();
+    message[:id] = rand(99999)
+
+    @question_queue.push( message )
+    
+    # Negative timeout - fire and forget
+    # Should only be used if it is known not to return an answer
+    return nil if timeout < 0
+
+    answer = listen_for_answer(message[:id], timeout)
+
+    if answer[:status] == 'error'
+      raise Talkshow::JavascriptError.new( answer[:data] )
+    end
+
+    case answer[:object]
+    when 'boolean'
+      answer[:data] == 'true'
+    when 'number'
+      if answer[:data].include?('.')
+        answer[:data].to_f
+      else
+        answer[:data].to_i
+      end
+    when 'undefined'
+      if answer[:data] == 'undefined'
+        nil
+      else
+        answer[:data]
+      end
+    when 'string'
+      answer[:data].to_s
+    else
+      begin
+        JSON.parse(answer[:data])
+      rescue StandardError => e
+        answer[:data]
+      end
+    end
+  end
+
+end
+

data/lib/talkshow/daemon.rb

@@ -0,0 +1,99 @@
+require 'net/http'
+require "uri"
+
+require 'thread'
+require 'json'
+require 'daemon'
+
+require 'talkshow'
+require 'talkshow/web_control'
+require 'talkshow/server'
+
+class Talkshow::Daemon
+  attr_accessor :thread
+  attr_accessor :port_requests
+  attr_accessor :processes
+  
+  # Create a new Talkshow object to get going
+  def initialize
+    Dir.mkdir './logs' if !Dir.exists?('./logs')
+    Dir.mkdir './pids' if !Dir.exists?('./pids')
+    @processes = {}
+    @port_requests = ::Queue.new
+  end
+
+  def start_server
+    @thread = Thread.new do
+      Talkshow::WebControl.port_requests(@port_requests)
+      Talkshow::WebControl.processes(@processes)
+      Talkshow::WebControl.run!
+    end
+    p @thread
+    sleep 10
+  end
+
+  # Stop the webserver
+  def stop_server
+    @thread.exit
+  end
+
+  def run
+    self.start_server
+    loop do
+      deal_with_port_requests
+      sleep 5
+      check_processes
+    end
+  end
+
+  def deal_with_port_requests
+    begin
+      port = @port_requests.pop(true)
+    rescue
+      port = nil
+    end
+    if port
+      if @processes[port]
+        puts "Port request -- checking aliveness"
+        if check_status(port) == 'dead'
+          @processes[port] = spawn_process(port)
+        end
+      else
+        puts "New port request"
+        @processes[port] = spawn_process(port)
+      end
+    end
+  end
+  
+  def spawn_process(port)
+    `TALKSHOW_PORT=#{port} bundle exec ./bin/talkshow_server.rb > logs/talkshow.#{port}.log 2>&1 &`
+    sleep 5
+    'starting'
+  end
+  
+  def check_status(port)
+    uri = URI.parse("http://localhost:#{port}/status")
+    begin
+      response = Net::HTTP.get_response(uri)
+    rescue
+      status = 'dead'
+    end
+    
+    if !status
+      if response.code.to_i == 200
+        status = 'ok'
+      else
+        status = "dead #{response.code}"
+      end
+    end
+    status
+  end
+  
+  def check_processes()
+    @processes.each do |port, status|
+      @processes[port] = check_status(port)
+    end
+  end
+
+end
+

data/lib/talkshow/javascript_error.rb

@@ -0,0 +1,4 @@
+class Talkshow
+  class Talkshow::JavascriptError < StandardError
+  end
+end

data/lib/talkshow/queue.rb

@@ -0,0 +1,32 @@
+require "net/http"
+require "uri"
+require 'json'
+
+class Talkshow::Queue
+  attr_accessor :url
+  
+  def initialize(url)
+    @uri = URI.parse(url)
+    @http = Net::HTTP.new(@uri.host, @uri.port)
+  end
+  
+  def clear
+    response = @http.request(Net::HTTP::Get.new('/answerqueue/clear'))
+    response
+  end
+
+  def pop(ignored)
+    response = @http.request(Net::HTTP::Get.new('/answerqueue/pop'))
+    object = JSON.parse(response.body, :symbolize_names => true)
+    object[:message]
+  end
+ 
+  def push(obj)
+    serialized_object = obj.to_json.to_s
+    request = Net::HTTP::Post.new('/questionqueue/push')
+    request.set_form_data( {'message' => serialized_object } )
+    response = @http.request(request)
+    nil
+  end
+  
+end

data/lib/talkshow/server.rb

@@ -0,0 +1,218 @@
+require 'sinatra/base'
+require 'net/http'
+require 'thread'
+require 'json'
+require 'logger'
+
+
+class Queue
+  # Take a peek at what's in the array
+  def peek
+    @que
+  end
+end
+
+# Sinatra server that is launched by your test code
+# to talk to the instrumented javascript application
+class Talkshow
+  class Talkshow::Server < Sinatra::Base
+    configure do
+      set :port, ENV['TALKSHOW_PORT'] if ENV['TALKSHOW_PORT']
+      set :protection, except: :path_traversal
+    end
+
+    def self.set_port port
+      set :port, port
+    end
+
+    @@logfile = './talkshowserver.log'
+    def self.set_logfile file
+      @@logfile = file
+      @logger.close if @logger
+      @logger = nil
+    end
+
+    def self.question_queue(queue = nil)
+      if queue
+        @@question_queue = queue
+      end
+      @@question_queue
+    end
+    
+    def self.answer_queue(queue = nil)
+      if queue
+        @@answer_queue = queue
+      end
+      @@answer_queue
+    end
+    
+    
+    def logger
+      if !@logger
+        @logger = Logger.new(@@logfile)
+      end
+      @logger
+    end
+    
+    # Make this available externally
+    set :bind, '0.0.0.0'
+
+    get '/' do
+      questions = Talkshow::Server.question_queue.peek.to_json
+      answers = Talkshow::Server.answer_queue.peek.to_json
+
+      <<HERE
+<html>
+  <body>
+    <div>
+      <h1>Talkshow process: #{$$}</h1>
+      <h2>Port: #{settings.port}</h2>
+    </div>
+    <div>
+      <p>#{questions}</p>
+    </div>
+    <div>
+      <p>#{answers}</p>
+    </div>
+  </body>
+</html>
+HERE
+    end
+    
+    get '/status' do
+      200
+    end
+    
+    get '/talkshowhost' do
+      "Talkshow running on " + request.host.to_s
+    end
+  
+    get '/question/:poll_id' do
+      t = Time.new()
+  
+      json_hash = {
+        :time => t.to_s,
+      }
+  
+      content = nil;
+      if Talkshow::Server.question_queue.empty?
+        logger.debug("question: nop")
+        json_hash[:type] = "nop"
+        json_hash[:message] = ""
+  
+      else
+        content = Talkshow::Server.question_queue.pop if !Talkshow::Server.question_queue.empty?
+        id = content[:id]
+        json_hash[:id] = id
+        logger.info( "question ##{id}: #{content.to_s}" )
+        
+        type = content[:type]
+        json_hash[:type] = type
+            
+        if type == 'code'
+          json_hash[:content] = content[:message]
+        elsif type == 'invocation'
+          json_hash[:function] = content[:function]
+          json_hash[:args] = content[:args]
+        end
+      end
+  
+      callback = params[:callback]
+      
+      json = json_hash.to_json
+  
+      logger.info( json )
+      
+      if callback
+        content_type 'text/javascript'
+        "#{callback}( #{json} );"
+      else
+        content_type :json
+        json
+      end
+    end
+ 
+    # Deal with an answer, push it back to the main thread 
+    def handle_answer(params, data)
+      if params[:status] != 'nop'
+                
+        Talkshow::Server.answer_queue.push( {
+                                            :data    => data,
+                                            :object  => params[:object],
+                                            :status  => params[:status],
+                                            :chunks  => params[:chunks],
+                                            :payload => params[:payload],
+                                            :id      => params[:id]
+                                           } )
+      end
+      
+      logger.info( "/answer ##{params[:id]}"+ ( params[:chunks] ? "(#{params[:payload].to_i+1}/#{params[:chunks]})" : '') +": #{data}" )
+      if params[:id] == 0
+        logger.info( "Reset received, talkshow reloaded")
+      end
+      
+      content_type 'text/javascript'
+      'ts.ack();'
+    end
+ 
+    # Capture an answer 
+    get '/answer/:poll_id/:id/:status/:object/:data' do
+      handle_answer(params, params[:data])
+    end
+
+    # Capture the case when a response has no data (empty string)
+    get '/answer/:poll_id/:id/:status/:object/' do
+      handle_answer(params, '')
+    end
+    
+    # Capture older talkshow.js implementations that didn't escape urls properly
+    get '/answer/:poll_id/:id/:status/:object/*' do
+      logger.warn("WARNING: Unescaped url passed as data component for route '#{request.fullpath}'")
+      data = params[:splat].join('/')
+      handle_answer(params, data)
+    end 
+
+    # Functions for remotely clearing queues
+    get '/answerqueue/clear' do
+      Talkshow::Server.answer_queue.clear()
+    end
+
+    get '/questionqueue/clear' do
+      Talkshow::Server.question_queue.clear()
+    end
+
+    # Push something onto the answer queue remotely
+    post '/questionqueue/push' do
+      logger.info( '/questionqueue/push' )
+      message = JSON.parse(params[:message], :symbolize_names => true)
+      logger.debug("Message pushed: #{message}")
+      Talkshow::Server.question_queue.push(message)
+    end
+
+    # Pop something from the answer queue
+    get '/answerqueue/pop' do
+      logger.info('answerqueue/pop')
+      begin
+        message = Talkshow::Server.answer_queue.pop(true)
+      rescue
+        message = nil
+      end
+      { :message => message }.to_json
+    end
+    
+    get '/questionqueue' do
+      Talkshow::Server.question_queue.peek.to_json
+    end
+
+    get '/answerqueue' do
+      Talkshow::Server.answer_queue.peek.to_json
+    end
+
+    # Catch anything else and shout about it
+    get '/*' do
+      puts "[Talkshow server warning] Unhandled route: '#{request.fullpath}'"
+      logger.error("WARNING: Unhandled route: '#{request.fullpath}'")
+    end
+  
+  end
+end

data/lib/talkshow/timeout.rb

@@ -0,0 +1,4 @@
+class Talkshow
+  class Talkshow::Timeout < StandardError
+  end
+end

data/lib/talkshow/web_control.rb

@@ -0,0 +1,85 @@
+require 'sinatra/base'
+require 'net/http'
+require 'thread'
+require 'json'
+require 'logger'
+
+require 'talkshow/server'
+require 'thread'
+
+
+
+class Talkshow
+  class Talkshow::WebControl < Sinatra::Base
+
+    set :bind, '0.0.0.0'
+    configure do
+      set :port, ENV['WEB_CONTROLLER_PORT']
+    end
+
+    # Thread safe
+    def self.port_requests(queue = nil)
+      if queue
+        @@port_requests = queue
+      end
+      @@port_requests
+    end
+
+    # Read-only, not thread safe
+    def self.processes(hash)
+      if hash
+        @@processes = hash
+      end
+      @@processes
+    end
+    
+    
+    def logger
+      if !@logger
+        @logger = Logger.new('talkshow_webcontrol.log')
+      end
+      @logger
+    end
+    
+    get '/' do
+      
+      process_table = "<table>"
+      @@processes.each do |port, status|
+        process_table += "<tr><td>#{port}</td><td>#{status}</td></tr>"
+      end
+      process_table += "</table>"
+      
+      <<HERE
+<html>
+<style>
+html { height: 100%;}
+body {background: #CCC; font-family: Arial, Helvetica, sans-serif; padding: 20px;}
+</style>  
+  <body>
+    <div>
+      <h1>Talkshow web control</h1>
+      <h2>PID: #{$$}</h2>
+      <h2>Port: #{settings.port}</h2>
+    </div>
+    <div>
+    <h2>Active Processes</h2>
+    #{process_table}
+    </div>
+  </body>
+</html>
+HERE
+    end
+    
+    get '/port/:port' do
+      port = params[:port].to_i
+      if port > 4000
+        Talkshow::WebControl.port_requests.push(port)
+      end
+    end
+    
+    get '/status' do
+      200
+    end
+    
+  end
+end

metadata

@@ -0,0 +1,94 @@
+--- !ruby/object:Gem::Specification
+name: talkshow
+version: !ruby/object:Gem::Version
+  version: 1.4.2
+platform: ruby
+authors:
+- Joseph Haig
+- David Buckhurst
+- Jenna Brown
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2016-04-01 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: sinatra
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: thin
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+- !ruby/object:Gem::Dependency
+  name: json
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '0'
+description: Ruby to Javascript communications bridge
+email: joe.haig@bbc.co.uk
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- lib/talkshow.rb
+- lib/talkshow/daemon.rb
+- lib/talkshow/javascript_error.rb
+- lib/talkshow/queue.rb
+- lib/talkshow/server.rb
+- lib/talkshow/timeout.rb
+- lib/talkshow/web_control.rb
+homepage: https://github.com/fmtvp/talkshow
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.5.0
+signing_key: 
+specification_version: 4
+summary: Talkshow ruby gem
+test_files: []