a4tools 1.2.7

data/lib/a4tools/version.rb

@@ -0,0 +1,3 @@
+module A4Tools
+  VERSION = "1.2.7"
+end

data/lib/acres_client.rb

@@ -0,0 +1,376 @@
+require 'json'
+require 'uri'
+require 'net/https'
+require 'faye/websocket'
+require 'eventmachine'
+require 'thread'
+
+
+module A4Tools
+  module EventGenerator
+    def on(key, &callback)
+      @callbacks ||= {}
+      @callbacks[key] ||= []
+      @callbacks[key].push callback
+    end
+
+    def signal(key, value=nil)
+      return if @callbacks.nil?
+      [ key, :all ].each do |k|
+        next unless @callbacks.has_key? k
+        @callbacks[k].each { |callback| callback.call(key, value) }
+      end
+    end
+
+    def passthrough(target)
+      target.on(:all) { |trigger, value| signal(trigger, value) }
+    end
+  end
+
+  class Transporter
+    include EventGenerator
+
+    def initialize
+      @callbacks = {}
+    end
+
+    def connect(timeout=5)
+      signal(:connect)
+      true
+    end
+
+    def disconnect
+      signal(:disconnect)
+    end
+  end
+
+  class HTTPTransporter < Transporter
+    def initialize(uri)
+      super()
+      @uri = uri
+      @http = Net::HTTP.new(@uri.host, @uri.port)
+      @http.use_ssl = @uri.scheme == 'https'
+      @http.verify_mode = OpenSSL::SSL::VERIFY_NONE
+    end
+
+    def response_body(result)
+      return nil unless result.code.to_i >= 200 and result.code.to_i < 300
+
+      jsonrpc = symbolify JSON.parse(result.body)
+      return nil unless jsonrpc[:jsonrpc] == "2.0"
+      return nil unless jsonrpc[:error].nil?
+      return nil if jsonrpc[:result].nil?
+
+      return jsonrpc[:result][:body] unless jsonrpc[:result][:body].nil?
+
+      return jsonrpc[:result]
+    end
+
+    def send_message(msg)
+      req = Net::HTTP::Post.new(@uri.to_s,
+        initheader = { 'Content-Type' => 'application/json', 'Accept' => 'application/json' }
+        )
+      req.body = msg
+      signal(:sent, msg)
+      response = @http.request(req)
+      signal(:message, response.body)
+
+      response
+    end
+  end
+
+  class WebSocketTransporter < Transporter
+    attr_reader :ready
+
+    def initialize(uri)
+      super()
+      @uri = uri
+      @queue = []
+      @ready = false
+      @mutex = Mutex.new
+      @condition = ConditionVariable.new
+    end
+
+    def connect(timeout=5)
+      return true if @ready
+      start_socket
+      @mutex.synchronize { @condition.wait(@mutex, timeout) }
+      @ready
+    end
+
+    def disconnect
+      @client.kill unless @client.nil?
+      @client = nil
+      @ws = nil
+      true
+    end
+
+    def start_socket
+      @client = Thread.new do
+        EM.run do
+          @ws = Faye::WebSocket::Client.new(@uri.to_s)
+
+          @ws.on :open do |event|
+            @mutex.synchronize do
+              @ready = true
+              @condition.signal
+            end
+            
+            signal(:connect)
+            empty_queue
+          end
+
+          @ws.on :error do |event|
+            @mutex.synchronize { @condition.signal }
+          end
+
+          @ws.on :message do |event|
+            signal(:message, event.data)
+          end
+
+          @ws.on :close do |event|
+            @ready = false
+            @ws = nil
+            signal(:disconnect)
+          end
+        end
+      end
+    end
+
+    def empty_queue
+      @queue.each { |msg| send_message(msg) }
+      @queue = []
+    end
+
+    def send_message(msg)
+      unless @ready then
+        @queue.push msg
+        return
+      end
+
+      signal(:sent, msg)
+      @ws.send(msg)
+    end
+  end
+
+  class AcresClient
+    include EventGenerator
+
+    attr_reader :uri, :token, :server_info, :history, :start_time, :connect_time, :connected, :ready
+    attr_accessor :username, :password, :version
+
+    def initialize(destination, username=nil, password=nil)
+      if destination.is_a? String then
+        @uri = URI(destination)
+      else
+        @uri = URI(destination[:url] + destination[:ctx] + "/json?wrap")
+      end
+
+      @username = username
+      @password = password
+      @history = []
+
+      case @uri.scheme
+      when 'http', 'https'
+        @transport = HTTPTransporter.new(@uri)
+      when 'ws', 'wss'
+        @transport = WebSocketTransporter.new(@uri)
+      end
+
+      passthrough(@transport)
+      @transport.on(:message) { |trigger, message| snoop_token(message) }
+      @transport.on(:message) { |trigger, message| add_message_to_history(:server, message) }
+      @transport.on(:sent) { |trigger, message| add_message_to_history(:client, message) }
+      @transport.on(:connect) { |trigger, message| @ready = true }
+      @transport.on(:disconnect) do |trigger, message|
+        @ready = false
+        @start_time = nil
+      end
+
+      @connected = false
+      @connect_time = nil
+      @start_time = nil
+      @authenticated = false
+      @token = nil
+    end
+
+    def add_message_to_history(sender, message, timestamp=nil)
+      timestamp ||= Time.now
+      @start_time ||= timestamp
+      history.push({ time: timestamp, sender: sender, message: (symbolify(JSON.parse(message)) rescue nil), raw:message })
+    end
+
+    def snoop_token(message)
+      begin
+        response = symbolify JSON.parse(message)
+        result = response[:result]
+        return if attempt_snoop(result)
+        attempt_snoop(result[:body]) unless result.nil? or result[:body].nil?
+      rescue
+        ""
+      end
+    end
+
+    def attempt_snoop(result)
+      if not(result.nil?) and result.has_key? :tok and result.has_key? :serverInfo then
+        # this is a connection token
+        @connected = true
+        @token = result[:tok] if result.has_key? :tok
+        @server_info = result[:serverInfo] if result.has_key? :serverInfo
+        signal(:connect)
+        true
+      else
+        false
+      end
+    end
+
+    def transport_connect
+      @transport.connect
+    end
+
+    def disconnect
+      @transport.disconnect
+    end
+
+    def connect
+      return nil unless transport_connect
+
+      request = {
+        appInfo: app_info,
+        deviceInfo: device_info
+      }
+
+      result = send_message(wrapped_message("connect", "com.acres4.common.info.ConnectionRequest", request))
+      response = response_body(result)
+      return nil unless response
+
+      response
+    end
+
+    def connect_if_needed
+      return true if @connected
+      return true unless connect.nil?
+      return false
+    end
+
+    def authenticate(username=nil, password=nil)
+      return nil unless connect_if_needed
+
+      request = {
+        tok: @token,
+        username: username || @username,
+        password: make_password(password || @password),
+        automaticReconnect: false
+      }
+
+      result = send_message(wrapped_message("login", "com.acres4.common.info.ClientLoginRequest", request))
+      response = response_body(result)
+      @authenticated = not(response.nil?)
+      response
+    end
+
+    def authenticate_if_needed(username=nil, password=nil)
+      return true if @authenticated
+      return true unless authenticate(username, password).nil?
+      return false
+    end
+
+    def make_password(password)
+      {
+        algorithm:"CLEARTEXT",
+        contents:password,
+        parameters:[]
+      }
+    end
+
+    def next_msg_id
+      @msg_id = @msg_id.nil? ? 0 : @msg_id + 1
+    end
+
+    def wrapped_message(method, cls, body)
+      cls ||= talk.guess_class(body)
+      body[:__class] = cls.to_s;
+      body[:tok] = @token unless @token.nil?
+
+      wrapper = {
+        className:cls,
+        body:body,
+        namedObjectEncodingType:0,
+        serializedEncoding:nil,
+        __class:"com.acres4.common.info.NamedObjectWrapper"
+      }
+
+      jsonrpc_message(method, nil, "com.acres4.common.info.NamedObjectWrapper", wrapper)
+    end
+
+    def inject_token(message, force=false, type=nil)
+      return nil if message.nil?
+      return message unless force or message[:tok].nil?
+      type ||= talk.guess_class(message)
+      unless type.nil? then
+        cls = talk.class_named(type)
+        has_tok = (cls[:field].select do |f|
+          is_token_class = talk.name_matches?("com.acres4.common.info.ConnectionToken", f[:type].first)
+          f[:name] == "tok" and is_token_class
+        end).length >= 1
+
+        message[:tok] = @token if has_tok
+      end
+
+      message
+    end
+
+    def jsonrpc_message(method, interface=nil, cls=nil, body={})
+      body[:__class] = (cls || talk.guess_class(body)) unless body.nil?
+
+      json = {
+        __class:"com.acres4.common.info.JSONRPCRequest",
+        method:method,
+        params:body,
+        id:next_msg_id,
+        jsonrpc:"2.0"
+      }
+
+      json[:intf] = interface unless interface.nil? # don't even include it if we didn't specify it
+      json
+    end
+
+    def empty_query(method, interface=nil)
+      jsonrpc_message(method, interface)
+    end
+
+    def send_message(message)
+      message = message.to_json unless message.is_a? String
+      @transport.send_message(message)
+    end
+
+    def response_body(result)
+      return nil unless result.code.to_i >= 200 and result.code.to_i < 300
+
+      jsonrpc = JSON.parse(result.body)
+      return nil unless jsonrpc["jsonrpc"] == "2.0"
+      return nil unless jsonrpc["error"].nil?
+      return nil if jsonrpc["result"].nil?
+
+      return symbolify jsonrpc["result"]["body"] unless jsonrpc["result"]["body"].nil?
+
+      return symbolify jsonrpc["result"]
+    end
+
+    def app_info
+      info = ObjectBuilder[:app_info_for_script].value
+      info[:currentTalkVersion] = @version unless @version.nil?
+      info
+    end
+
+    def device_info
+      ObjectBuilder[:device_info_for_system].value
+    end
+  end
+end
+
+require 'clients/caching_client.rb'
+require 'clients/deployment_client.rb'
+require 'clients/kai_config_client.rb'
+require 'clients/usher_client.rb'
+require 'clients/usher_mgmt_client.rb'

data/lib/clients/caching_client.rb

@@ -0,0 +1,151 @@
+module A4Tools
+  class AuthenticationError < StandardError
+  end
+
+  class UpdateError < StandardError
+  end
+
+  class CachingClient < AcresClient
+    attr_accessor :timeout
+
+    class << self
+      attr_accessor :cache_methods, :query_methods
+      def cache(name, params={}, &blk)
+        @cache_methods ||= {}
+        @cache_methods[name] = {
+          params:params,
+          block:blk
+        }
+      end
+
+      def query(name, params={}, &blk)
+        @query_methods ||= {}
+        @query_methods[name] = {
+          params:params,
+          block:blk
+        }
+      end
+    end
+
+    def initialize(destination, username=nil, password=nil, timeout=300)
+      super(destination, username, password)
+      @timeout = timeout
+      @query_cache = {}
+      @cache = {}
+      @update_thread = nil
+      @query_methods = self.class.query_methods.clone rescue {}
+    end
+
+    def send_update_request
+      new_cache = {}
+      return {} if self.class.cache_methods.nil?
+      self.class.cache_methods.each do |method, defn|
+        if defn[:params][:authenticate] then
+          raise(AuthenticationError, "Unable to authenticate") unless authenticate_if_needed
+        end
+
+        request = defn[:block].nil? ? nil : defn[:block].call
+        new_cache[method] = update_from_method(method, request)
+      end
+      new_cache
+    end
+
+    def update_from_method(method, request, type=nil)
+      type ||= talk.expand_name(talk.method_named(method.to_s)[0][:request])
+      inject_token(request, false, type)
+      body = request.nil? ? empty_query(method) : wrapped_message(method.to_s, type, request)
+      result = send_message(body)
+      begin
+        parsed = symbolify(JSON.parse(result.body))
+        raise(UpdateError, "#{method}: #{parsed[:error][:code]} #{parsed[:error][:message]}") unless parsed[:error].nil?
+        raise(UpdateError, "#{method}: Server did not include a response field") if parsed[:result].nil?
+        toplevel = parsed[:result]
+        if toplevel.has_key?(:body) and toplevel.has_key?(:className) then
+          toplevel = toplevel[:body]
+          toplevel[:__class] = parsed[:result][:className] # strip namedobjectwrapper
+        end
+        toplevel
+      rescue JSON::ParserError
+        truncated = result.body.length > 100 ? result.body[0..99] + "..." : result.body
+        raise(UpdateError, "#{method}: Server returned non-JSON response: (#{result.body.length} bytes) '#{truncated}'")
+      end
+    end
+
+    def [](key)
+      cache(key)
+    end
+
+    def cache(key, sync=false)
+      if sync then
+        refresh unless fresh? # force caller to wait until we've refreshed
+      else
+        refresh_async unless fresh? # kick off an async update if we're stale, but still return what we have
+      end
+      
+      @cache[key]
+    end
+
+    def query(method, *args)
+      defn = @query_methods[method]
+      raise UpdateError, "#{method}: Unsupported method" if defn.nil?
+
+      if defn[:params][:authenticate] then
+        raise(AuthenticationError, "Unable to authenticate as #{username}") unless authenticate_if_needed
+      end
+
+      @query_cache[method] ||= {}
+      item = @query_cache[method] || {}
+      return item[:cache] unless timestamp_expired?(item[:update])
+
+      request = defn[:block].nil? ? nil : defn[:block].call(*args)
+      result = update_from_method(method, request)
+      item[:update] = Time.now
+      item[:cache] = result
+      @query_cache[method] = item
+      result
+    end
+
+    # Force a cache update next time someone makes a request
+    def dirty
+      @cache_update_ts = nil
+      @query_methods.each { |method, defn| defn[:update] = nil }
+    end
+
+    def ensure_fresh
+      refresh unless fresh?
+    end
+
+    def fresh?
+      not timestamp_expired?(@cache_update_ts)
+    end
+
+    def timestamp_expired?(ts)
+      ts.nil? or (Time.now - ts) > @timeout
+    end
+
+    def refresh_async
+      # Create a new thread to get the update cache, unless one is already in flight
+      if @update_thread.nil? then
+        begin
+          Thread.new { refresh }
+        rescue AuthenticationError, UpdateError => exc
+          signal(:error, exc.message)
+        end
+      end
+      nil
+    end
+
+    def refresh
+      unless @update_thread.nil? then
+        # We already have an update thread in flight; block on that
+        @update_thread.join unless @update_thread == Thread.current
+        return @cache
+      end
+
+      @update_thread = Thread.current
+      @cache = send_update_request
+      @cache_update_ts = Time.now
+      @update_thread = nil
+    end
+  end
+end