a4tools 1.2.7

data/lib/net_shell/builtin_commands/kai_event.rb

@@ -0,0 +1,151 @@
+category "Kai"
+description "Generate machine events"
+usage "[event_code machine_location]"
+
+tab do
+  events.events.map { |event| event[:key] }
+end
+
+tab :machine do
+  machine_list
+end
+
+opt :amount, "Cash value associated with event. Used for jackpot and handpays.", :type => :integer
+opt :tier, "Player tier level name", :type => :string
+opt :first_name, "Player first name", :type => :string
+opt :last_name, "Player last name", :type => :string
+opt :employee, "Employee card ID", :type => :integer
+opt :patron, "Patron card I", :type => :integer
+opt :machine, "Machine location", :type => :string
+
+opt :allow_duplicate, "Allow duplicate machines when spamming with random machine IDs"
+opt :spam, "Spam the event repeatedly", :type => :integer, :default => 1
+opt :spam_interval, "Specify number of seconds between spams in milliseconds", :type => :integer, :default => 1000
+
+opt :list_names, "List Kai events, alphabetized by name"
+
+run do
+  if args.length == 1 then
+    list = events.events
+    (list.sort! { |a,b| a[:key] <=> b[:key] }) if params[:list_names]
+    (events.events.map do |event|
+      code = sprintf("%5d", event[:code]).style(:event_code)
+      key = sprintf("%35s", event[:key].to_s).style(:event_key)
+
+      "#{code}  #{key} -- #{event[:description]}"
+    end).join("\n")
+  else
+    machine = args[2] rescue random_machine
+    code = event_code(args[1])
+    return show_error("Unknown event code #{code}") if code.nil?
+    return show_error("Unable to connect QA test interface") unless qa.connect_if_needed
+    return show_error("Only have #{machine_list.length} machines to choose from; either reduce spam count or allow duplicates") if params[:spam] > machine_list.length and not params[:allow_duplicate]
+
+    index = 0
+    allowed_list = machine_list
+    params[:spam].times do
+      index = index + 1
+      machine = params[:machine] || allowed_list.sample
+      allowed_list.delete(machine) unless params[:allow_duplicate]
+
+      message = build_request(args[1..-2].sample, machine)
+      puts "Sending event #{index} of #{params[:spam]}: #{event_description(message)}"
+      send_event(message)
+      sleep params[:spam_interval] * 1.0/1000.0 unless index == params[:spam]
+    end
+
+    ""
+  end
+end
+
+##
+
+def event_description(event)
+  name = event_name(event[:eventList][0][:event][:idEventCode]) || event[:eventList][0][:event][:idEventCode]
+  location = event[:eventList][0][:location]
+  "#{name} @ #{location}"
+end
+
+def machine_list
+  @shell.client(:config).machines rescue []
+end
+
+def random_machine
+  machine_list.sample
+end
+
+def send_event(message)  
+  qa.inject_token(message)
+  jsonrpc = qa.jsonrpc_message(:qaTestEvent, "qatest", nil, message)
+  qa.send_message(jsonrpc).body
+end
+
+def build_request(code, machine)
+  {
+    __class: "com.acres4.common.info.mercury.qatest.QATestEventRequest",
+    tok:nil,
+    eventList:[ qa_event_table_item(code, machine) ]
+  }
+end
+
+def qa_event_table_item(code, machine)
+  {
+    event:event_table_item(code),
+    location:machine
+  }
+end
+
+def event_table_item(code)
+  {
+    idEventCode:code,
+    hostEvent:host_event(code),
+    collectStats:false,
+    receiptTime:Time.now.to_i,
+    playerRating:player_rating
+  }
+end
+
+def host_event(code)
+  {
+    priKey:0,
+    hostDeviceId:nil,
+    eventCode:code.to_s,
+    idPatron:params[:patron] || 0,
+    idEmployee:params[:employee] || 0,
+    amount:params[:amount] || 0,
+    meters:nil,
+    eventTime:Time.now.to_i,
+    hostTime:Time.now.to_i
+  }
+end
+
+def player_rating
+  return nil unless params[:patron] or params[:firstName] or params[:lastName] or params[:loyaltyTierStr]
+
+  {
+    idPatron:params[:patron] || 0,
+    firstName:params[:first_name] || "Little",
+    lastName:params[:last_name] || "Timmy",
+    loyaltyTierStr:params[:tier] || "Wood"
+  }
+end
+
+def event_by_identifier(identifier)
+  identifier ||= args[1]
+  identifier = identifier.to_i if identifier.is_a? String and identifier.match(/^[0-9]+$/)
+  events.events.each do |event|
+    return event if(event[:key].to_s == identifier.to_s or event[:code] == identifier)
+  end
+
+  pp identifier
+  pp args[1]
+  nil
+end
+
+def event_code(identifier=nil)
+  event_by_identifier(identifier)[:code]
+end
+
+def event_name(identifier=nil)
+  event_by_identifier(identifier)[:key]
+end

data/lib/net_shell/builtin_commands/persist.rb

@@ -0,0 +1,24 @@
+category "Shell management"
+description "Persist an environment variable"
+usage "variable1 variable2 ..."
+
+help "Causes an evironment variable to persist between netshell sessions."
+
+tab do
+  @shell.env.keys.reject { |key| args.include? key.to_s }
+end
+
+validate { (args.length >= 2 and not params[:all]) or (args.length == 1 and params[:all]) }
+
+opt :all, "Persist all variables"
+
+run do
+  variables = if params[:all]
+    [] # causes persist to save everything
+  else
+    args[1..-1]
+  end
+
+  @shell.persist_env(variables)
+  ""
+end

data/lib/net_shell/builtin_commands/pwd.rb

@@ -0,0 +1,6 @@
+category "Shell management"
+description "Current working directory"
+help "Display current directory."
+
+validate { args.length == 1 }
+run { Dir.pwd }

data/lib/net_shell/builtin_commands/recap.rb

@@ -0,0 +1,188 @@
+category "Protocol manipulation"
+description "Print message history for current connection"
+usage [
+  "#{command}             show all messages",
+  "#{command} n           show nth message before most recent",
+  "#{command} start end   show messages from start to end"
+]
+
+help <<-EOS
+Examples:
+List all messages
+ #{command}
+
+List most recent message
+ #{command} 0
+
+List most recent 3 messages
+ #{command} 2 0
+
+List first message in conversation
+ #{command} -1
+
+List first 5 messages in conversation
+ #{command} -5 -1
+EOS
+
+opt :client, "Recap this history for a client other than the active client", :type => :string
+opt :summary, "Only list class names in text mode"
+opt :json, "Output as JSON"
+opt :raw, "Don't wrap JSON objects with metadata objects."
+opt :array, "Force JSON to always be an array, even if only a single object is returned"
+opt :reverse, "Index messages from end of conversation (so message 0 is most recent)"
+
+validate do
+  return "Must have an active client" if client.nil? and not params[:client]
+  return "#{params[:client]}: unknown client" if params[:client] and not @shell.clients.include? params[:client].to_sym
+  true
+end
+
+tab :client do
+  @shell.clients
+end
+
+run { use_json? ? json_output : text_output }
+
+###
+
+def target_client
+  params[:client] ? @shell.client(params[:client]) : client
+end
+
+def messages
+  messages = target_client.history
+end
+
+def range_for_args(args)
+  case args.length
+  when 0,1
+    range = (0 .. -1)
+  when 2
+    range = args[1].to_i .. args[1].to_i
+  when 3
+    low = [args[1], args[2]].min
+    high = [args[1], args[2]].max
+    range = low.to_i .. high.to_i
+  end
+end
+
+def sender(msg)
+  case msg[:sender]
+  when :client
+    "client".light_blue
+  when :server
+    "server".magenta
+  end
+end
+
+def timecode(msg)
+  delta = msg[:time] - target_client.start_time
+  all_seconds = delta.to_i
+
+  milliseconds = 1000.0*(delta - all_seconds)
+  hours = (all_seconds / 3660).to_i
+  minutes = ((all_seconds - 3660*hours) / 60).to_i
+  seconds = (all_seconds - 3600*hours - 60*minutes).to_i
+
+  return sprintf("%3d:%02d:%02d.%03d", hours, minutes, seconds, milliseconds).light_black
+end
+
+def text_output
+  index = -1
+  set = params[:reverse] ? messages : messages.reverse
+  (set.reverse[range_for_args(args)].map do |msg|
+    index += 1
+    index_str = sprintf("%3d", index)
+    "#{index_str} #{timecode(msg)} #{sender(msg)} #{render_text(msg[:message])}"
+  end).join("\n")
+end
+
+def json_output
+  set = params[:reverse] ? messages : messages.reverse
+  set = (set.reverse[range_for_args(args)].map do |msg|
+    if params[:raw] then
+      msg[:message]
+    else
+      msg.reject { |k,v| k == :raw }
+    end
+  end)
+
+  set = set[0] if set.length == 1 and not params[:array]
+  set.to_json
+end
+
+def use_json?
+  params[:json] or params[:raw] or params[:array]
+end
+
+def render_text(message)
+  if params[:summary] then
+    render_summary(message)
+  else
+    message.is_a?(Hash) ? JSON.generate(message) : message
+  end
+end
+
+def render_summary(message)
+  toplevel, cls = pick_toplevel(message)
+  puts toplevel if cls.nil?
+  cls ||= talk.guess_class(toplevel)
+  class_name = cls.style(:class) || "Unknown"
+  id_str = message[:id] ? sprintf("%3d", message[:id]) : "   "
+
+  sprintf("%s %20s %s %s",
+    id_str.style(:id),
+    method(message).style(:method_name),
+    class_name.style(:class),
+    human_readable_size(message.to_json.length)
+    )
+end
+
+def human_readable_size(size)
+  titles = [ "B", "KiB", "MiB", "GiB", "TiB" ]
+  titles.each_index do |idx|
+    title = titles[idx]
+    unit = 1024**idx
+    boundary = 1024*unit
+    return "#{size/unit} #{title}" if size < boundary or title == titles.last
+  end
+end
+
+def method(message)
+  return message[:method] if message.has_key? :method
+  request = find_request_with_id(message[:id])
+  request[:method] rescue "unknown"
+end
+
+def find_request_with_id(id)
+  target_client.history.each do |msg|
+    next if msg[:message].nil? or msg[:message][:id].nil? or not(msg[:message].has_key? :params)
+    return msg[:message] if msg[:message][:id].to_i == id.to_i
+  end
+
+  nil
+end
+
+def pick_toplevel(message)
+  message = symbolify(JSON.parse(message)) if message.is_a? String
+  if message[:jsonrpc] == "2.0" then
+    return bypass(message, "com.acres4.common.info.JSONRPCRequest") if message.has_key? :params
+    return [message, "Error"] unless message[:error].nil?
+    return bypass(message, "com.acres4.common.info.JSONRPCResponse") if message.has_key? :result
+  end
+
+  [message, talk.guess_class(message)]
+end
+
+def bypass(object, type)
+  case type
+  when "com.acres4.common.info.NamedObjectWrapper"
+    return bypass(object[:body], object[:className])
+  when "com.acres4.common.info.JSONRPCRequest"
+    return bypass(object[:params], talk.guess_class(object[:params]))
+  when "com.acres4.common.info.JSONRPCResponse"
+    return bypass(object[:result], talk.guess_class(object[:result]))
+  else
+    return [object, type]
+  end
+end

data/lib/net_shell/builtin_commands/references.rb

@@ -0,0 +1,63 @@
+category "Talk"
+description "Find references to a Talk class"
+usage "class_name"
+help "Lists all classes and protocols referencing a particular Talk class."
+
+validate { args.length == 2 }
+
+tab 0 do
+  talk.things_named_like(args[1], [:class]).map { |thing| talk.truncated_name thing[:name] }
+end
+
+run do
+  search_cls = talk.class_named(args[1])
+  return show_error("#{args[1]}: no such class in talk") if search_cls.nil?
+  full_name = search_cls[:name]
+
+  methods = list_methods(full_name)
+  fields = list_fields(full_name)
+
+  if methods.length > 0 then
+    puts "Methods (#{methods.length})"
+    methods.each { |method| show_method(method[:protocol], method[:method]) }
+  end
+
+  if fields.length > 0 then
+    puts "Fields (#{fields.length})"
+    fields.each { |field| show_field(field[:class], field[:field]) }
+  end
+
+  ""
+end
+
+###
+
+def list_methods(name)
+  methods = []
+  talk.definition[:protocol].each do |proto|
+    proto[:method].each do |method|
+      methods.push({protocol:proto, method:method}) if(talk.name_matches?(name, method[:request]) or talk.name_matches?(name, method[:response]))
+    end
+  end
+
+  methods
+end
+
+def list_fields(name)
+  fields = []
+  talk.definition[:class].each do |cls|
+    cls[:field].each do |field|
+      fields.push({class:cls, field:field}) if talk.name_matches?(name, field[:type].first)
+    end
+  end
+
+  fields
+end
+
+def show_method(protocol, method)
+  puts "\t#{protocol[:name].style(:protcol_name)}: #{method[:name].style(:method_name)} #{method[:request].style(:class)} -> #{method[:response].style(:class)}"
+end
+
+def show_field(cls, field)
+  puts "\t#{cls[:name].style(:class)}: #{field[:name].style(:field_name)}#{field[:type][1..-1].join("")}"
+end

data/lib/net_shell/builtin_commands/select.rb

@@ -0,0 +1,36 @@
+category "Protocol manipulation"
+description "Select a connection for console"
+usage "select [conenction]"
+
+
+tab(0) { @shell.clients }
+
+run do
+  if args.length == 1 then
+    (@shell.clients.sort.map { |key| render_client(key) }).join("\n")
+  else
+    return show_error("#{args[1]}: no such client") unless @shell.clients.include?(args[1].to_sym)
+    @shell.set_active_client(args[1])
+    ""
+  end
+end
+
+def render_client(key)
+  target = @shell.client(key)
+  fmt_key = sprintf("%20s", key.to_s)
+  host = usherm.host_for_url(target.uri) || "unknown host"
+  info = source_id(target)
+
+  "#{fmt_key.style(:target)}: #{info} #{target.uri.to_s.style(:url)} (#{host.style(:host)})"
+end
+
+def source_id(target)
+  app_info = target.server_info || {}
+  version = target.version || app_info[:currentTalkVersion]
+  protocol = sprintf("%-6s", (version || "")).style(:protocol_name)
+  name = sprintf("%20s", ((app_info[:appName] rescue nil) || "")).style(:name)
+  commit = sprintf("%7s", ((app_info[:sourceRevision][0..6] rescue nil) || "")).style(:commit)
+  branch = sprintf("%-30s", ((app_info[:supportingRevisions].first[:branches].first rescue nil) || "")).style(:branch)
+
+  "#{protocol} #{commit} #{branch}"
+end