a4tools 1.2.7

data/lib/net_shell/builtin_commands/disconnect.rb

@@ -0,0 +1,15 @@
+category "Protocol manipulation"
+description "Disconnect from remote server"
+help <<-EOS
+Immediately disconnects from the remote server, closing open websockets if appropriate.
+EOS
+
+validate do
+  return "must connect first" if client.nil?
+end
+
+run do
+  client.disconnect
+  ""
+end
+

data/lib/net_shell/builtin_commands/excerpt.rb

@@ -0,0 +1,97 @@
+category "Protocol manipulation"
+description "Access an individual field in a JSON object"
+usage "field_path"
+
+help "Finds a field path inside a JSON object supplied over standard input. For example, use 'tok.rand' to find the 'rand' field inside the 'tok' object inside the object."
+
+validate { args.length <= 2 }
+
+tab :type do
+  talk.definition[:class].map { |defn| talk.truncated_name(defn[:name]) }
+end
+
+tab :class do
+  talk.definition[:class].map { |defn| talk.truncated_name(defn[:name]) }
+end
+
+opt :class, "Excerpt the first field of the given class name", :type => :string
+opt :no_hint, "Do not force result object to contain an __class field"
+opt :type, "Assume the object has the specified type", :type => :string
+opt :no_bypass, "Do not automatically bypass JSONRPCRequest, JSONRPCResponse and NamedObjectWrapper toplevels"
+
+run do
+  object, type = toplevel_value
+  return show_error("Invalid JSON") if object.nil?
+
+  data, type = talk.locate_data(object, args[1], params[:type])
+  return show_error("Unable to locate field in JSON.") if data.nil?
+
+  result = if data.is_a? Hash or data.is_a? Array then
+    unless params[:class].nil?
+      data = find_class(params[:class], data, type)
+      return show_error("Unable to locate class type in JSON") if data.nil?
+      type = params[:class]
+    end
+    data[:__class] = talk.expand_name(type) if data.is_a? Hash and not params[:no_hint]
+    JSON.generate(data)
+  else
+    data
+  end
+end
+
+###
+
+def find_class(target, data, type=nil)
+  return find_class_in_array(target, data, type) if data.is_a? Array
+
+  type ||= talk.guess_class(data)
+  cls = talk.class_named(type) rescue nil
+  
+  if cls.nil? then
+    data.each do |key, value|
+      searchval = find_class(target, value)
+      return searchval unless searchval.nil?
+    end
+  else
+    cls[:field].each do |field|
+      value = data[field[:name].to_sym]
+      fieldtype = talk.expand_name(field[:type].first)
+      next if value.nil? or fieldtype.nil?
+      return value if talk.name_matches?(fieldtype, target)
+    end
+  end
+
+  nil
+end
+
+def find_class_in_array(target, data, type)
+  data.each do |datum|
+    result = find_class(target, datum, type)
+    return result unless result.nil?
+  end
+
+  return nil
+end
+
+def toplevel_value
+  json = @input.read_all
+  object = symbolify(JSON.parse(json)) rescue nil
+  type = (talk.expand_name(params[:type]) rescue nil) || talk.guess_class(object) rescue nil
+  
+  return nil if type.nil? or object.nil?
+  return [object, type] if params[:no_bypass]
+  return bypass(object, type)
+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/exit.rb

@@ -0,0 +1,7 @@
+category "Shell management"
+description "Exits netshell"
+
+run do
+  status = args.length >= 2 ? args[1].to_i : 0
+  exit status
+end

data/lib/net_shell/builtin_commands/get.rb

@@ -0,0 +1,38 @@
+category "Shell management"
+description "Get contents of environment variables"
+usage "[variable_name]"
+help <<-EOS
+List the value of environment variable ENV, or all environment variables if not specified.
+
+Environment variables are NOT imported from your system's native shell.
+EOS
+
+validate do
+  case args.length
+  when 1
+    true
+  when 2
+    if @shell.get_env(args[1]).nil?
+      "#{args[1]}: key not set"
+    else
+      true
+    end
+  else
+    false
+  end
+  true
+end
+
+tab 0 do
+  @shell.env.keys
+end
+
+run do
+  if args.length == 2 then
+    @shell.get_env(args[1])
+  else
+    list = []
+    @shell.env.each { |key, value| list.push "#{key.to_s.style(:environment)}: \"#{value.to_s.bold}\"" }
+    list.join("\n")
+  end
+end

data/lib/net_shell/builtin_commands/help.rb

@@ -0,0 +1,40 @@
+category "Shell management"
+description "Show help for a command"
+
+tab 0 do
+  @shell.built_ins
+end
+
+help <<-EOS
+Show help for a specific built-in command, or outline all built-in commands if none is available.
+EOS
+
+run { args.length == 1 ? list_all_commands : list_command(args[1]) }
+
+###
+
+def list_all_commands
+  (categories.map { |cat| list_category(cat) }).join("\n\n")
+end
+
+def list_command(name)
+  return show_error("#{name}: command not found") unless @shell.has_built_in?(name)
+  cmd = @shell.built_in(name).new(@shell)
+  cmd.educate
+end
+
+def categories
+  (@shell.built_ins.map { |name| @shell.built_in(name).category_text }).sort.uniq
+end
+
+def list_category(category)
+  commands = @shell.built_ins.select { |name| @shell.built_in(name).category_text == category }
+  cat = category.style(:category)
+  cmds = (commands.sort.map do |name|
+    cmd = @shell.built_in(name).new(@shell)
+    usermark = cmd.user_defined? ? "@".style(:userdefined) : " "
+    "#{sprintf("%25s", name.to_s).style(:command)}#{usermark} -- #{cmd.description}"
+  end).join("\n")
+
+  [cat, cmds].join("\n")
+end

data/lib/net_shell/builtin_commands/host.rb

@@ -0,0 +1,126 @@
+category "Usher"
+description "Show information about Usher hosts"
+usage "hostname"
+help <<-EOS
+Shows information for a given usher host. If no usher host is specified, lists all hosts.
+EOS
+
+validate do
+  return show_error("must connect usherm first") if usherm.nil?
+  args.length < 3
+end
+
+tab 0 do
+  (usherm[:usherSystemId][:systemHosts].map { |host| host[:hostName] }) rescue []
+end
+
+run do
+  usherm.ensure_fresh
+  if args.length == 1 then
+    (usherm[:usherSystemId][:systemHosts].map do |host|
+      concise_host(host)
+    end).join("\n")
+  elsif args.length == 2 then
+    host = usherm.host_named(args[1])
+    return show_error("#{args[1]}: unknown host") if host.nil?
+    verbose_host(host)
+  end
+end
+
+###
+
+def string_for_range(start, last, params={})
+  if start == last then
+    last
+  else
+    "#{start}-#{last}"
+  end
+end
+
+def collapse_ranges(elements)
+  return "None" if elements.nil? or elements.empty?
+  elements = (elements.map { |element| element.to_i }).sort
+
+  ranges = []
+  start = elements.first
+  last = nil
+
+  elements.each do |element|
+    if not(last.nil?) and element != last + 1
+      ranges.push(string_for_range(start, last))
+      start = element
+    end
+    last = element
+  end
+
+  ranges.push(string_for_range(start, last))
+  ranges.join(", ")
+end
+
+def provider_line(id_provider)
+  provider = usherm.provider(id_provider)
+  return "Non-existent provider #{id_provider}" if provider.nil?
+  return nil if provider[:isSpecial]
+
+  sites = collapse_ranges(provider[:idSites])
+
+  ipLines = ["Internal", "External"].map do |zone|
+    hosts = provider["usherHosts#{zone}".to_sym] || []
+    zone + ": " + if hosts.empty? then
+      "None"
+    else
+      urls = hosts.map { |host| host[:url] }
+      urls.join(", ")
+    end
+  end
+
+  out = "\t\t#{provider[:product].style(:product)}: Site #{sites}\n"
+  out += (ipLines.map { |line| "\t\t\t#{line}"}).join("\n") + "\n"
+  out
+end
+
+def acl_line(acl)
+  service = usherm.service_for_id(acl[:idService])
+  return "Non-existent service #{acl[:idService]}" if service.nil?
+
+  proto = service[:isUdp] ? "UDP" : "TCP"
+  external_addr = [acl[:ip], acl[:port]].compact.join(":")
+  "\t\t#{service[:name].style(:service)}, #{proto} #{service[:port]} (#{external_addr} external)"
+end
+
+def verbose_host(host)
+  datacenter = usherm.datacenter(host[:idDataCenter])
+  out = "Host #{host[:hostName].style(:host)} (#{host[:idSystemHost]})\n"
+  out += "\tInternal #{host[:ipAddrInt].style(:ip)}\n"
+  out += "\tExternal #{host[:ipAddrExt].style(:ip)}\n"
+  if datacenter.nil?
+    out += "\tDatacenter: not found in usher (#{host[:idDataCenter]})\n"
+  else
+    out += "\tDatacenter: #{datacenter[:dataCenterName].style(:datacenter)} (#{host[:idDataCenter]})\n"
+  end
+  out += "\tHost environment: #{usherm.env_type(host[:systemHostEnvironment])}\n"
+  out += "\tUsher system type: #{usherm.system_type(host[:usherResponseType])}\n"
+  out += (host[:providers].map { |id_provider| provider_line(id_provider) }).compact.join("\n")
+
+  out += "\tACLs:\n"
+  acls = usherm.acls_for_host_id(host[:idSystemHost])
+  if acls.empty?
+    out += "\t\tNo ACLs for this host."
+  else
+    out += (acls.map { |acl| acl_line(acl) }).compact.join("\n")
+  end
+
+  out
+end
+
+def concise_host(host)
+  datacenter = usherm.datacenter(host[:idDataCenter])
+  dcnote = if datacenter.nil?
+    "unknown (#{host[:idDataCenter]})"
+  else
+    "#{datacenter[:dataCenterName].style(:datacenter)}"
+  end
+
+  "#{host[:hostName].style(:host)} -- #{dcnote} #{usherm.env_type(host[:systemHostEnvironment])}"
+end
+

data/lib/net_shell/builtin_commands/inject.rb

@@ -0,0 +1,42 @@
+category "Protocol manipulation"
+description "Inject a JSON string from the command line into another JSON object from STDIN"
+usage "field_path json"
+
+validate { args.length == 3 }
+
+run do
+  path = args[1].split(".")
+  last = path.pop
+  json = @input.read_all
+
+  parent = nil
+  toplevel = object = symbolify(JSON.parse(json)) rescue nil
+  injected = JSON.parse(args[2]) rescue args[2]
+
+  return show_error("Invalid source object") if injected.nil?
+  return show_error("Invalid replacement object") if injected.nil?
+
+  until path.empty? do
+    field_name = path.first
+    path = path[1..-1]
+    object = field_value(object, field_name)
+    return show_error("Path not in JSON object") if object.nil?
+  end
+  
+  return json if object.nil?
+  object[last.to_sym] = injected
+  toplevel.to_json
+end
+
+###
+
+def field_value(object, field_name)
+  m = field_name.to_s.match(/^([a-zA-Z0-9_]+)\[([0-9]+)\]$/)
+  if m.nil? then
+    return object[field_name.to_sym] rescue nil
+  else
+    name = m[1]
+    value = object[name.to_sym][m[2].to_i] rescue nil
+    return value
+  end
+end

data/lib/net_shell/builtin_commands/jsoncache.rb

@@ -0,0 +1,80 @@
+category "Protocol manipulation"
+description "Access a pre-cached request object"
+usage "[identifier]"
+help <<-EOS
+Reading cache
+#{command.style(:command)} builds object instances based on definitions. These definitions can either be Ruby scripts providing dynamic content, or JSON strings with static content.
+
+The definitions included by default are located in lib/object_builder/definitions, and the filenames reflect the identifiers used by #{command.style(:command)}. Adding a file to this directory will cause it to be included automatically. Files ending in .rb will be interpreted as ruby scripts; all others will be treated as raw JSON.
+
+Writing cache
+Using the --store option #{command.style(:command)} can write objects to the cache.
+EOS
+
+validate do
+  return args.length <= 3 if params[:store]
+  return args.length == 2 if params[:persist]
+  args.length <= 2
+end
+
+tab 0 do
+  (ObjectBuilder.identifiers_like(args[1]).map { |id| id.to_s }) + ObjectBuilder.supported_classes
+end
+
+opt :store, "Store a JSON object supplied on STDIN to the specified identifier", :type => :string
+opt :persist, "Write an identifier to disk"
+opt :field, "Read a specific field from the JSON string", :type => :string
+opt :type, "Assume the top-level datatype is of a specified type", :type => :string
+
+run do
+  return store if params[:store]
+  return persist if params[:persist]
+  read
+end
+
+###
+
+def acquire_object
+  obj = JSON.parse(@input.read_all) rescue nil
+  talk.locate_data(obj, params[:field], params[:type]) rescue nil
+end
+
+def store
+  description = args[1] rescue "Defined from console"
+  obj, type = acquire_object
+  return show_error("Unable to acquire field from JSON") if obj.nil?
+
+  obj[:__class] = type unless type.nil?
+
+  ObjectBuilder.load_object(obj, params[:store], description)
+  ""
+end
+
+def persist
+  builder = ObjectBuilder[args[1]]
+  return show_error("#{args[1]}: no such identifier") if  builder.nil?
+  File.write(File.join(@shell.shelldir(:json), args[1]), builder.value.to_json)
+  ""
+end
+
+def read
+  if args.length == 1 then
+    builders = ObjectBuilder.builders
+    return show_error("no builders defined") if builders.empty?
+    return show_builder_list(builders)
+  end
+
+  builder = ObjectBuilder[args[1]]
+  return builder.value.to_json unless builder.nil?
+
+  builders = ObjectBuilder.builders_for_name(args[1])
+  return "#{args[0]}: #{args[1]}: no such identifier or class in cache" if builders.empty?
+  show_builder_list(builders)
+end
+
+def show_builder_list(builders)
+  (builders.map do |builder|
+    "#{builder.name.to_s.style(:class)} #{builder.identifier.to_s.green}: #{builder.description}"
+  end).join("\n")
+end
+