a4tools 1.2.7

data/lib/net_shell/builtin_commands/send.rb

@@ -0,0 +1,74 @@
+category "Protocol manipulation"
+description "Send a request to the remote server"
+
+usage [
+  "                  send a raw message to the server",
+  "interface method  send a message to the server, wrapped with a JSON-RPC request for the specified method"
+]
+
+validate { args.length == 1 || args.length == 3 }
+
+help <<-EOS
+Messages are supplied as JSON via stdin. Messages can therefore be read using input redirection or piped from another command, like #{"build".style(:command)} or #{"cached".style(:command)}.
+EOS
+
+tab 1 do
+  set = talk.definition[:protocol].inject([]) do |set, proto|
+    set + proto[:method].select { |method| talk.name_similar?(method[:name], args[2] || "") }
+  end
+
+  set.map { |m| m[:name] }
+end
+
+opt :no_inject, "Don't automatically inject the current connection token"
+opt :dry, "Don't send the message; just print what would be sent to the console"
+opt :spam, "Send the message repeatedly", :type => :integer, :default => 1
+opt :spam_interval, "Time to wait between spams in milliseconds", :type => :integer, :default => 1000
+
+run do
+  return show_error("must connect first") if @shell.shared[:client].nil?
+  @shell.allow_alerts
+
+  message = input.read_all
+  index = 0
+
+  params[:spam].times do
+    index = index + 1
+    if args.length == 3 then
+      send_wrapped(message)
+    else
+      send_raw(message)
+    end
+
+    puts "Sending message #{index} of #{params[:spam]}" if params[:spam] > 1
+    sleep params[:spam_interval] * 1.0/1000.0 if index < params[:spam]
+  end
+
+  ""
+end
+
+def send_raw(message)
+  send(message)
+end
+
+def send_wrapped(message)
+  message = symbolify(JSON.parse(message)) if message.is_a? String
+  method, protocol = talk.method_named(args[2])
+  return show_error("#{args[1]}: unknown method") if method.nil?
+  cls = talk.class_named(method[:request])
+  return show_error("#{args[1]}: unable to locate request class") if cls.nil?
+
+  client.inject_token(message) unless params[:no_inject]
+  jsonrpc = client.jsonrpc_message(method[:name], args[1], talk.guess_class(message), message)
+
+  message = JSON.generate(jsonrpc)
+  send(message)
+end
+
+def send(message)
+  if params[:dry] then
+    puts message
+  else
+    client.send_message(message)
+  end
+end

data/lib/net_shell/builtin_commands/set.rb

@@ -0,0 +1,29 @@
+category "Shell management"
+description "Set environment variables"
+usage "variable value"
+
+help <<-EOS
+Sets an environment variable to a specified value. Environment variables may also be set by creating
+  ~/.netshell/env
+
+At shell initialization, this directory (if it exists) will be scanned. For each filename in the directory, an environment variable with that name will be created, and populated with the contents of that file.
+
+Environment variables are NOT imported from your system's native shell.
+EOS
+
+validate { args.length == 2 or args.length == 3 }
+
+tab(0) do
+  @shell.env.keys
+end
+
+run do
+  value = if args.length == 3 then
+    args[2 .. -1].join(" ")
+  else
+    @input.read_all.chomp
+  end
+  @shell.set_env(args[1].to_sym, value)
+  ""
+end
+

data/lib/net_shell/builtin_commands/show.rb

@@ -0,0 +1,183 @@
+category "Talk"
+description "Show details for a Talk entity"
+usage [
+  "entity                show information about an entity",
+  "enumeration constant  show information about a constant in a particular enumeration",
+  "glossary term         show information about a term in a particular glossary",
+  "class field           show information about a class in a particular field",
+  "protocol method       show information about a method in a particular protocol"
+]
+
+help "Displays Talk information about a specified entity. Entities can be classes, glossaries, enumerations, protocols, constants, fields, terms, or methods."
+
+validate { args.length <= 3 }
+
+tab 0 do
+  talk.things_named_like(args.last).map { |thing| talk.truncated_name thing[:name] } rescue []
+end
+
+opt :class, "List all classes"
+opt :enumeration, "List all enumerations"
+opt :glossary, "List all glossaries"
+opt :protocol, "List all protocols"
+opt :recurse, "List all entities referenced by queried entity"
+opt :reverse, "List entities in reverse (with original query at top)"
+
+run do
+  if args.length > 1 then
+    @subqueries = []
+    top_level = show(args[1 .. -1]) 
+    return show_error("#{args[1 .. -1].join(' ')}: symbol not found") if top_level.nil?
+
+    sections = [ top_level ]
+
+    if params[:recurse] then
+      until @subqueries.empty? do
+        query = @subqueries.first
+        @subqueries = @subqueries[1..-1]
+        sections.push show([query])
+      end
+    end
+    
+    sections.reverse! unless params[:reverse]
+    sections.each do |section|
+      puts section
+    end
+    ""
+  else
+    show_list
+  end
+end
+
+###
+
+def add_queries(*new_queries)
+  @subqueries ||= []
+  @seen ||= {}
+  new_queries.each do |q|
+    next if q == "none" # given by methods
+    @subqueries.push q unless @seen.has_key? q
+    @seen[q] = true
+  end
+end
+
+def show_list
+  s = ""
+  query_for_params.each do |section|
+    next if talk.definition[section].nil?
+    s += descriptions[section] + " (#{talk.definition[section].length})\n"
+    s += (talk.definition[section].map { |item| "\t#{item[:name].style(style_for_section(section))}\n\t#{item[:description]}\n" }).join("\n") + "\n\n"
+  end
+  s
+end
+
+def query_for_params
+  query = []
+  options = [ :class, :enumeration, :glossary, :protocol ]
+  options.each { |opt| query.push(opt) if params[opt] }
+
+  query = options if query.empty?
+  query
+end
+
+def style_for_section(section)
+  case section
+  when :class
+    :class
+  when :protocol
+    :protocol_name
+  when :enumeration, :glossary
+    :collection_name
+  else
+    :none
+  end
+end
+
+def descriptions
+  { class:"Classes", glossary:"Glossaries", enumeration:"Enumerations", protocol:"Protocols" }
+end
+
+def list(query)
+  query = [ :class, :enumeration, :glossary, :protocol ] if query.empty?
+  query.map! { |e| e.to_sym }
+
+end
+
+##
+
+def show_field(query)
+  return nil if query.length < 2
+  cls = (query[0].is_a? Hash) ? query[0] : talk.class_named(query[0])
+  return nil if cls.nil?
+  field = talk.field_named(cls, query[1])
+  return nil if field.nil?
+
+  add_queries(field[:type].first)
+
+  "Field #{field[:name]}: #{(field[:type].map { |t| talk.truncated_name t }).join('')}\n\tClass #{cls[:name]}\n\t#{field[:description]}\n"
+end
+
+def show_class(query)
+  cls = (query[0].is_a? Hash) ? query[0] : talk.class_named(query[0])
+  return nil if cls.nil?
+
+  fields = cls[:field].map do |f|
+    add_queries(f[:type].first)
+    "\t#{f[:name].style(:field_name)}, #{(f[:type].map { |t| talk.truncated_name t }).join('').style(:field_datatype)}\n\t\t#{f[:description]}\n"
+  end
+
+  "Class #{cls[:name].style(:class)}\n\t#{cls[:description]}\n\n" + fields.join("\n")
+end
+
+def origin_line(method)
+  return "Asynchronous from server\n\t\t".style(:origin) if method[:origin] == "server"
+  return ""
+end
+
+def show_protocol(query)
+  proto = (query[0].is_a? Hash) ? query[0] : talk.protocol_named(query[0])
+  return nil if proto.nil?
+
+  methods = proto[:method].map do |m|
+    add_queries(m[:request], m[:response])
+    "\t#{m[:name].style(:method_name)}: #{m[:request].style(:class)} -> #{m[:response].style(:class)}\n\t\t#{origin_line(m)}#{m[:description]}\n"
+  end
+
+  "Protocol #{proto[:name].style(:protocol_name)}\n\t#{proto[:description]}\n" + methods.join("\n")
+end
+
+def show_method(query)
+  method, protocol = (query.length == 1) ? talk.method_named(query[0], nil) : talk.method_named(query[1], query[0])
+  return nil if method.nil?
+
+  add_queries(method[:request], method[:response])
+  "Method #{method[:name].style(:method_name)}: #{method[:request].style(:class)} -> #{method[:response].style(:class)}\n\tProtocol #{protocol[:name].style(:protocol_name)}\n\t#{method[:description]}\n\n"
+end
+
+def show_constant(query)
+  constant, container = (query.length > 1) ? talk.constant_named(query[1], query[0]) : talk.constant_named(query[0], nil)
+  return nil if constant.nil?
+
+  origin = (container.has_key? :term) ? "Glossary #{container[:name]}" : "Enumeration #{container[:name]}"
+
+  "Constant #{constant[:name].style(:constant_name)}: #{constant[:value].to_s.style(:constant_value)}\n\t#{origin}\n\t#{constant[:description]}\n\n"
+end
+
+def show_glossary(query)
+  glossary = (query[0].is_a? Hash) ? query[0] : talk.glossary_named(query[0])
+  return nil if glossary.nil?
+
+  "Glossary #{glossary[:name].style(:collection_name)}\n\t#{glossary[:description]}\n\n" + (glossary[:term].map { |t| "\t#{t[:name].style(:constant_name)} (\"#{t[:value].style(:constant_value)}\")\n\t\t#{t[:description]}\n"}).join("\n")
+end
+
+def show_enumeration(query)
+  enumeration = (query[0].is_a? Hash) ? query[0] : talk.enumeration_named(query[0])
+  return nil if enumeration.nil?
+
+  "Enumeration #{enumeration[:name].style(:collection_name)}\n\t#{enumeration[:description]}\n\n" + (enumeration[:constant].map { |c| "\t#{c[:value].to_i.to_s.style(:constant_value)} #{c[:name].style(:constant_name)}\n\t\t#{c[:description]}\n"}).join("\n")
+end
+
+def show(query)
+  show_field(query) || show_method(query) || show_class(query) || show_protocol(query) || show_constant(query) || show_glossary(query) || show_enumeration(query)
+end
+

data/lib/net_shell/builtin_commands/site.rb

@@ -0,0 +1,122 @@
+category "Usher"
+description "List everything about a site"
+usage "siteId1 siteId2 ..."
+
+opt :no_deploy, "Do not show deployment information"
+
+tab do
+  sites = (usherm[:usherSystemId][:usherSites].map { |site| site[:idSite] } +
+    usherm[:usherSystemId][:usherSites].map { |site| site[:name] }) rescue []
+  sites.reject { |site| args.include? site.to_s }
+end
+
+run do
+  usherm.ensure_fresh
+  deployment.ensure_fresh
+  if args.length >= 2 then
+    args[1..-1].each do |arg|
+      site_id = site_id_for_arg(arg)
+      if site_id.nil? then
+        puts "Unknown site '#{site_id}'"
+        next
+      end
+
+      show_site(site_id)
+      puts
+    end
+  else
+    show_all_sites
+  end
+
+  ""
+end
+
+###
+
+def site_id_for_arg(arg)
+  return arg.to_i if arg.is_a? Fixnum or arg.match(/^[0-9]+$/)
+  usherm[:usherSystemId][:usherSites].each { |site| return site[:idSite] if site[:name] == arg  }
+  nil
+end
+
+def show_all_sites
+  sites = (usherm[:usherSystemId][:usherSites].map { |site| site[:idSite] }).sort
+  sites.each do |site_id|
+    site = usherm.site_with_id(site_id)
+    site_id_str = sprintf("%6d", site_id).style(:id)
+    puts "##{site_id_str}: #{site[:name]} (#{site[:siteDescription]})"
+  end
+end
+
+def show_site(site_id)
+  site = usherm.site_with_id(site_id)
+  show_usher_site(site_id, site)
+  show_host_info(site_id)
+  show_publications(deployment.query(:buildPublicationList,site_id)) unless params[:no_deploy]
+end
+
+def yes_no(b)
+  b ? "yes" : "no"
+end
+
+def timestamp(ts)
+  DateTime.strptime(ts.to_s,'%s').strftime("%Y-%m-%d %H:%M:%S").style(:timestamp)
+end
+
+def expiration(mod)
+  mod[:permanent] ? "Never" : timestamp(mod[:expiration])
+end
+
+def show_usher_site(site_id, site)
+  if site.nil?
+    puts "Site #{site_id.to_s.style(:id)}: Unknown (not in usher)"
+    return
+  end
+
+  puts "Site".style(:heading) +" #{site[:idSite].to_s.style(:id)}: #{site[:name]} (#{site[:siteDescription]})"
+  puts "\t         Timezone: #{site[:zoneinfoId].style(:timezone)}"
+  mod = site[:moduleProvision]
+  if mod then
+    mask = sprintf("%16x", mod[:modules]).style(:mask)
+    puts "\t          Modules: #{mask}"
+    puts "\t     Max machines: #{mod[:maxAllowedMachines]}"
+    puts "\t           Active: #{yes_no(mod[:active])}"
+    puts "\tPermanent license: #{yes_no(mod[:permanent])}"
+    puts "\t       Expiration: #{expiration(mod)}"
+    puts "\t Renewal attempts: #{mod[:renewalAttemtps]}"
+  end
+  site[:siteRange].each do |range|
+    puts "\t             CIDR: #{range[:cidrBlock].style(:cidr)} #{range[:siteRangeDescription]}"
+  end
+end
+
+def show_host_info(site_id)
+  puts "\tHosts".style(:heading)
+  usherm.providers_for_site(site_id).each do |provider|
+    host = usherm.host_with_id(provider[:idSystemHost])
+    product = sprintf("%20s", provider[:product]).style(:product)
+    puts "\t\t#{product}: #{host[:hostName].style(:host)}"
+  end
+end
+
+def show_publications(publications)
+  puts "\tDeployments".style(:heading)
+  publications[:orders].keys.sort.each do |app|
+    next if params[:app] and not talk.name_matches?(app, params[:app])
+    list_site_app(app.to_s, publications[:orders][app])
+  end
+end
+
+def list_site_app(app, orders)
+  pub = orders.first
+  return if params[:jeb] and pub[:buildInfo][:buildId] != params[:jeb]
+  return if params[:commit] and pub[:buildInfo][:commitId] != params[:commit]
+  return if params[:branch] and not(pub[:buildInfo][:branches].include? params[:branch])
+  puts "\t\t#{timestamp(pub[:publicationTime])} #{app.style(:class)} -- #{build_info(pub[:buildInfo])}"
+end
+
+def build_info(build)
+  name = build[:buildId].style(:build_name)
+  branches = build[:branches].join(",").style(:branch)
+  "#{name} [#{branches}]"
+end

data/lib/net_shell/builtin_commands/ssh.rb

@@ -0,0 +1,62 @@
+require 'socket'
+require 'thread'
+
+category "System administration"
+description "Open an SSH connection to the specified host."
+usage "host [user]"
+
+help "Opens an SSH session to the specified host. No command line arguments are passed."
+
+validate do
+  return "must connect usherm first" if usherm.nil?
+  args.length == 2
+end
+
+tab 0 do
+  (usherm[:usherSystemId][:systemHosts].map { |host| host_supports_ssh?(host) ? host[:hostName] : nil }).compact rescue []
+end
+
+run do
+  params = parse_params(args)
+  usherm.ensure_fresh
+  acl = usherm.acl_for_service(params[:host], "ssh")
+  return show_error("#{params[:host]}: usher does not list ssh ACL for host") unless acl
+  try_acl(params, acl) ? "" : "#{args[0]}: #{params[:host]}: unable to connect to host on any address"
+end
+
+###
+
+def try_acl(params, acl)
+  host = usherm.host_named(params[:host])
+  service = usherm.service_for_id(acl[:idService])
+  options = [
+    { host:host[:ipAddrInt], port:service[:port] },
+    { host:host[:ipAddrExt], port:acl[:port] }
+  ]
+
+  result = try_connection_options(options)
+  unless result.nil? then
+    process = fork { exec "ssh -l #{params[:user]} -p #{result[:port]} #{result[:ip]}" }
+    Process.waitpid(process)
+  end
+
+  not result.nil?
+end
+
+def host_supports_ssh?(host)
+  not usherm.acl_for_service(host, "ssh").nil?
+end
+
+def parse_params(args)
+  if args.length == 3
+    return { host:args[1], user:args[2] }
+  else
+    if args[1].include? "@" then
+      comps = args[1].split("@")
+      return { host:comps[1], user:comps[0] }
+    else
+      return { host:args[1], user:"acres4" }
+    end
+  end
+end
+