a4tools 1.2.7

data/lib/net_shell/builtin_commands/build.rb

@@ -0,0 +1,251 @@
+category "Protocol manipulation"
+description "Interactively build a JSON object of a given class"
+usage "class_name"
+help <<-EOS
+Launches an interactive prompt to build the indicated Talk class. At the conclusion of this prompt, a JSON string will be printed to stdout.
+
+This command is somewhat magical in that the interactive prompts do not appear on the command's standard output, nor does it gather prompt input from standard input; only the JSON appears on standard output.
+
+Therefore, you can pipe the output of #{command.style(:command)} directly to #{"send".style(:command)} or some other command.
+EOS
+
+
+validate { args.length == 2 }
+tab 0 do
+  talk.things_named_like(args[1], :class).map { |thing| talk.truncated_name thing[:name] }
+end
+
+run do
+  cls = talk.class_named(args[1])
+  return show_error("#{args[1]}: no such class defined") if cls.nil?
+
+  obj = build(cls)
+  obj[:__class] = talk.class_named(args[1])[:name] rescue args[1]
+  JSON.generate(obj)
+end
+
+###
+
+def prompt_for_path(path)
+  path.join(".").style(:class) + ") "
+end
+
+def prompt_for_value(path, type)
+  "#{path.join(".").style(:class)} #{type.style(:field_datatype)}) "
+end
+
+def get_action(allowed)
+  char = STDIN.gets.chomp rescue nil
+  char = nil unless char.nil? or allowed.include? char
+  char
+end
+
+def get_value_real(value)
+  case value
+  when nil, "null", ""
+    nil
+  else
+    value.to_f
+  end
+end
+
+def get_value_integer(value)
+  case value
+  when nil, "null", ""
+    nil
+  else
+    value.to_i
+  end
+end
+
+def get_value_boolean(value)
+  case value
+  when "0", "false"
+    false
+  when "1", "true"
+    true
+  when "", "null"
+    nil
+  else
+    true
+  end
+end
+
+def get_value_string(value)
+  case value
+  when nil, "null"
+    nil
+  else
+    value
+  end
+end
+
+def get_value(field, path)
+  type = field[:type].first
+  console_print prompt_for_value(path, type)
+
+  value = STDIN.gets
+  if value.nil? then
+    value = "null" # nil => CTRL+D. Take advantage that all get_value_* interpret null as nil-value to make CTRL+D -> null shortcut.
+    console_puts # need a newline since none was actually typed
+  end
+
+  value = value.chomp
+  if(value == "?") then
+    show_field_help(field)
+    return get_value(field, path)
+  end
+
+  return get_value_integer(value) if([ "uint8", "uint16", "uint32", "uint64", "int8", "int16", "int32", "int64" ].include?(type))
+  return get_value_real(value) if([ "real" ].include?(type))
+  return get_value_boolean(value) if([ "bool" ].include?(type))
+  return get_value_string(value) if([ "string" ].include?(type))
+end
+
+def in_array?(field, depth)
+  field[:type][-1 - depth] == "[]"
+end
+
+def in_hash?(field, depth)
+  field[:type][-1 - depth] == "{}"
+end
+
+def in_container?(field, depth)
+  in_array?(field, depth) or in_hash?(field, depth)
+end
+
+def prompt_for_action(field, path, type, actions)
+  while true do
+    console_puts "#{path.join('.').style(:class)}: #{type.style(:field_datatype)}. #{actions.map { |a| "[#{a[0].bold}]#{a[1..-1]}" }.join(', ')}"
+    console_print prompt_for_path(path)
+    action = get_action(actions.map { |a| a[0] })
+    return (actions.select { |a| a[0] == action }).first unless action.nil?
+  end
+end
+
+def type_at_depth(field, depth)
+  field[:type][0 .. -1 - depth].join("")
+end
+
+def show_field_help(field, depth=-1)
+  depth = field[:type].length - 1 if depth < 0
+  console_puts "#{talk.truncated_name(type_at_depth(field, depth)).style(:field_datatype)} #{field[:name].style(:field_name)}\n\t#{field[:description]}"
+end
+
+def handle_array_start(field, path, depth)
+  actions = [ "build", "null", "?" ]
+
+  case prompt_for_action(field, path, type_at_depth(field, depth), actions)
+  when "?"
+    show_field_help(field, depth)
+    return handle_array_start(field, path, depth)
+  when nil, "null"
+    return nil
+  when "build"
+    collection = []
+    building = true
+    index = 0
+    while true do
+      element = handle_array_element(field, path[0..-2] + ["#{path.last}[#{index}]"], depth+1)
+      return collection if element.nil?
+      collection.push element[:value]
+      index += 1
+    end
+  end
+end
+
+def handle_array_element(field, path, depth)
+  actions = [ "build", "null", "done", "?" ]
+  case prompt_for_action(field, path, type_at_depth(field, depth), actions)
+  when "?"
+    show_field_help(field, depth)
+    return handle_array_element(field, path, depth)
+  when nil, "null"
+    return { value:nil }
+  when "done"
+    return nil
+  when "build"
+    return { value:handle_field(field, path, depth+1, true) }
+  end
+end
+
+def populate(field, path)
+  while true do
+    idx = 0
+    builders = ObjectBuilder.builders_for_name(field[:type].first)
+    builders.each do |builder|
+      console_puts("#{idx.to_s.style(:constant_value)} #{builder.identifier.to_s.style(:method_name)}: #{builder.description}")
+      idx += 1
+    end
+
+    console_print prompt_for_path(path)
+    action = STDIN.gets.chomp rescue nil
+
+    return handle_complex(field, path) if action.nil? # CTRL+D cancels populate
+    index = action.match(/^[0-9]+$/) ? action.to_i : nil
+    return builders[index].value if not index.nil? and index < builders.length
+  end
+end
+
+def has_cache?(field)
+  ObjectBuilder.supported_classes(false).each do |name|
+    return true if talk.name_matches?(name, field[:type].first)
+  end
+  false
+end
+
+def handle_complex(field, path, assume_build=false)
+  return build(talk.class_named(field[:type].first), path) if assume_build
+
+  actions = if has_cache?(field) then
+    [ "build", "populate", "null", "?" ]
+  else
+    [ "build", "null", "?" ]
+  end
+
+  case prompt_for_action(field, path, field[:type].first, actions)
+  when "build"
+    build(talk.class_named(field[:type].first), path)
+  when nil, "null"
+    nil
+  when "populate"
+    populate(field, path)
+  when "?"
+    show_field_help(field, field[:type].length-1)
+    return handle_complex(field, path)
+  end
+end
+
+def handle_primitive(field, path)
+  get_value(field, path)
+end
+
+def handle_field(field, path, depth=0, assume_build=false)
+  path += [field[:name]] if depth == 0
+  if depth+1 < field[:type].length then
+    if in_array?(field, depth)
+      return handle_array_start(field, path, depth)
+    else
+      # TODO: handle dictionary
+      return nil
+    end
+  end
+
+  if talk.primitive? field[:type].first
+    return handle_primitive(field, path)
+  else
+    return handle_complex(field, path, assume_build)
+  end
+end
+
+def build(cls, path=[])
+  if path.empty? then
+    console_puts "Building #{talk.truncated_name cls}..."
+  else
+    console_puts "#{talk.truncated_name cls} #{path.last}\n\t#{cls[:description]}"
+  end
+
+  result = {}
+  cls[:field].each { |field| result[field[:name]] = handle_field(field, path) }
+  result
+end

data/lib/net_shell/builtin_commands/cd.rb

@@ -0,0 +1,12 @@
+category "Shell management"
+description "Change working directory"
+usage "directory"
+validate { args.length <= 2 }
+help "Behaves much like cd in your favorite shell."
+
+run do
+  p = File.expand_path(args.length == 2 ? args[1] : "~")
+  return show_error("Directory does not exist") unless File.directory?(p)
+  Dir.chdir(p)
+  ""
+end

data/lib/net_shell/builtin_commands/connect.rb

@@ -0,0 +1,122 @@
+category "Protocol manipulation"
+description "Connect to a remote server"
+usage "url [client_name]"
+
+help <<-EOS
+Connect to a remote server, indicated by the URL.
+Supported schemes: http, https, ws, wss.
+
+Once connected, commands like #{"send".style(:command)} will use the connected server as a target. Connecting also resets the #{"recap".style(:command)} log.
+
+Comet support is not included; therefore, http and https provide synchronous communication only. ws and wss support fully asynchronous communication.
+
+#{command.style(:command)} does make special effort to validate that a URL is accessible. For http and https clients, this means that attempts to use this connection will fail. Due to the nature of websockets, #{command.style(:command)} will display an error on exit if these services are unavailable.
+EOS
+
+validate { args.length >= 2 }
+
+opt :kai, "Connect the Kai Mercury, Central and QATest clients to a particular site ID or host"
+
+tab 0 do
+  if params[:kai] then
+    (usherm[:usherSystemId][:usherSites].map { |site| site[:idSite] } +
+      usherm[:usherSystemId][:usherSites].map { |site| site[:name] }) rescue []
+  else
+    []
+  end
+end
+
+run do
+  if params[:kai] then
+    connect_kai
+  else
+    connect_raw
+  end
+end
+
+###
+
+def connect_raw
+  key = args[2].to_sym rescue :user
+  clients = []
+  client = AcresClient.new(args[1])
+  return show_error("Unable to contact server at #{args[1]}") unless client.transport_connect
+  
+  @shell.set_client(key, client)
+  client.on(:connect) { |trigger, msg| @shell.notify_connect(client) }
+  client.on(:sent) { |trigger,msg| @shell.notify_outgoing_message(client, msg) }
+  client.on(:message) { |trigger,msg| @shell.notify_incoming_message(client, msg) }  
+  client.on(:disconnect) { |trigger,msg| @shell.notify_disconnect(client) }
+
+  @shell.set_active_client(key)
+  ""
+end
+
+def connect_kai
+  dest = args[1]
+  
+  if dest.match(/^([a-zA-Z]+):\/\/[a-zA-Z0-9\-\.]+(:[0-9]+)?(\/)?/) then
+    connect_to_url(dest)
+  elsif dest.match(/^[0-9]+$/) then
+    connect_to_site_id(dest.to_i)
+  else
+    connect_to_usher_host(dest)
+  end
+end
+
+def request_caches
+  version = @shell.client(:config).site_version
+  client_interfaces.keys.each { |key| @shell.client(key).version = version }
+  @shell.client(:config).machines
+end
+
+def connect_to_url(base)
+  client_interfaces.each do |key, uri|
+    url = URI.join(base, uri).to_s
+    @shell.set_client(key, client_for_key(key, url))
+  end
+
+  request_caches
+  "Connected to #{@shell.client(:config).version.style(:host)} server"
+end
+
+def connect_to_site_id(site_id)
+  site = usherm.site_with_id(site_id)
+  return show_error("Site ##{site_id}: No such site ID in usher") if site.nil?
+  provider = usherm.provider_for_product(site_id, "Mercury")
+  return show_error("Site ##{site_id}: Does not offer Mercury") if provider.nil?
+  url = usherm.url_for_provider(provider)
+  return show_error("Site ##{site_id}: Site appears to be down") if url.nil?
+  puts "Connecting to Kai at #{url}"
+  connect_to_url(url)
+end
+
+def connect_to_usher_host(host)
+  site = usherm.site_with_name(host)
+  return show_error("Site #{host}: Does not appear to be listed in usher") if site.nil?
+  connect_to_site_id(site[:idSite])
+end
+
+def client_for_key(key, url)
+  case key
+  when :mercury
+    AcresClient.new(url, @shell.get_env(:kai_user), @shell.get_env(:kai_pass))
+  when :central
+    AcresClient.new(url, @shell.get_env(:usherm_user), @shell.get_env(:usherm_pass))
+  when :config
+    KaiConfigClient.new(url, @shell.get_env(:usherm_user), @shell.get_env(:usherm_pass))
+  when :qa
+    AcresClient.new(url, @shell.get_env(:kai_user), @shell.get_env(:kai_pass))
+  else
+    AcresClient.new(url, @shell.get_env(:usherm_user), @shell.get_env(:usherm_pass))
+  end
+end
+
+def client_interfaces
+  {
+    mercury:"/mercury/client?wrap",
+    central:"/central/central?wrap",
+    config:"/config/config?wrap",
+    qa:"/mercury/qatest?wrap"
+  }
+end

data/lib/net_shell/builtin_commands/deploy.rb

@@ -0,0 +1,280 @@
+require 'date'
+
+category "Deployment"
+description "Manage deployments"
+usage [
+  "list          -- list active publications",
+  "builds        -- list builds",
+  "publish       -- publish a build"
+]
+
+opt :url, "Deployment server URL"
+
+opt :app, "List builds for application", :type => :string
+opt :jeb, "List builds for jeb (i.e. three-word name)", :type => :string
+opt :branch, "List builds for branch", :type => :string
+opt :commit, "List builds for commit hash", :type => :string
+opt :yes, "Automatically include all apps in publication. No effect if --app is supplied."
+
+opt :site, "When used with list, only list publications to given site. When used with publish, indicates site to deploy to.", :type => :integer
+
+
+validate do
+  return false if args.length <= 1
+
+  case args[1]
+  when "builds"
+    args.length == 2
+  when "list"
+    true
+  when "publish"
+    return "Must supply at least one site ID" unless args.length >= 3
+    true
+  else
+    "#{args[1]}: unknown subcommand"
+  end
+end
+
+tab(:app) { all_apps }
+tab(:jeb) { all_jebs }
+tab(:branch) { all_branches }
+tab(:commit) { all_commits }
+
+tab 0 do
+  [:list, :builds, :publish]
+end
+
+run do
+  usherm.ensure_fresh
+  deployment.ensure_fresh
+  case args[1]
+  when "builds"
+    builds
+  when "list"
+    list
+  when "publish"
+    publish
+  end
+end
+
+###
+# Tab completors
+
+def all_apps
+  all_of_key(:appId)
+end
+
+def all_branches
+  all_of_key(:branches)
+end
+
+def all_commits
+  all_of_key(:commitId)
+end
+
+def all_jebs
+  all_of_key(:buildId)
+end
+
+def all_of_key(key)
+  instances = {}
+
+  deployment[:buildList][:builds].each do |build|
+    if build[key].is_a? Array then
+      build[key].each { |item| instances[item] = true }
+    else
+      instances[build[key]] = true
+    end
+  end
+
+  instances.keys
+end
+
+###
+# List
+
+def list
+  sites = if args.length >= 3 then
+    args[2..-1].map { |arg| arg.to_i }
+  else
+    (usherm[:usherSystemId][:usherSites].map { |site| site[:idSite] }).sort
+  end
+
+  sites.each do |site_id|
+    list_site(site_id, deployment.query(:buildPublicationList, site_id))
+  end
+  ""
+end
+
+def list_site(site_id, publications)
+  site = usherm.site_with_id(site_id) || {name:"Unknown site", siteDescription:"Not in usher"}
+  lines = []
+  
+  lines.push "Site #{site_id} -- #{site[:name]} (#{site[:siteDescription]})"
+  publications[:orders].keys.sort.each do |app|
+    next if params[:app] and not talk.name_matches?(app, params[:app])
+    lines.push list_site_app(app.to_s, publications[:orders][app])
+  end
+
+  puts lines.join("\n")+"\n" unless lines.length == 1
+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])
+  "\t#{timestamp(pub[:publicationTime])} #{app.style(:class)} -- #{build_info(pub[:buildInfo])}"
+end
+
+###
+# Builds
+
+def builds
+  show_build_set(build_set)
+  ""
+end
+
+def build_set
+  if params[:jeb] then
+    builds_for_jeb(params[:jeb])
+  elsif params[:commit] then
+    builds_for_commit(params[:commit])
+  elsif params[:branch] then
+    builds_for_branch(params[:branch])
+  elsif params[:app] then
+    builds_for_app(params[:app])
+  else
+    deployment[:buildList][:builds]
+  end
+end
+
+def builds_for_app(app)
+  deployment[:buildList][:builds].select { |build| talk.name_matches?(build[:appId], app) }
+end
+
+def builds_for_commit(commit)
+  set = 
+  if params[:app] then
+    builds_for_app(params[:app])
+  else
+    deployment[:buildList][:builds]
+  end
+
+  set.select { |build| build[:commitId].start_with? commit }
+end
+
+def builds_for_jeb(jeb)
+  set = 
+  if params[:app] then
+    builds_for_app(params[:app])
+  else
+    deployment[:buildList][:builds]
+  end
+  
+  set.select { |build| build[:buildId] == jeb }
+end
+
+def builds_for_branch(branch)
+  set = 
+  if params[:app] then
+    builds_for_app(params[:app])
+  else
+    deployment[:buildList][:builds]
+  end
+  
+  set.select { |build| build[:branches].include? branch }
+end
+
+def build_set_by_app(builds)
+  apps = {}
+  builds.each do |build|
+    apps[build[:appId]] ||= []
+    apps[build[:appId]].push build
+  end
+  apps
+end
+
+###
+# Publish
+
+def prompt_for_apps(set)
+  apps = build_set_by_app(set)
+  return apps.keys.sort.map { |app| apps[app].last } if params[:yes]
+
+  selected = []
+  apps.keys.sort.each do |app|
+    build = apps[app].last
+    cls = sprintf("%s", app).style(:class)
+    name = sprintf("%s", build[:buildId]).style(:build_name)
+    branch = build[:branches].join(",").style(:branch)
+    line = sprintf("%99s", "#{cls}: #{name} [#{branch}]")
+
+    while true do
+      print "#{line} [y/N]> "
+      input = STDIN.gets.chomp.upcase rescue nil
+      input = "N" if not input.nil? and input.empty?
+
+      selected.push build if input == "Y"
+      puts if input.nil?
+      break if ["Y", "N"].include? input
+    end
+  end
+
+  selected
+end
+
+def publish
+  sites = args[2..-1].map { |arg| arg.to_i }
+  selected = prompt_for_apps(build_set)
+  selected.each do |build|
+    puts "Publishing #{build[:appId].style(:class)} \"#{build[:buildId].style(:build_name)}\" to site #{sites.join(",")}..."
+    deployment.publish_build(build, sites)
+  end
+  "Done."
+end
+
+###
+# Other stuff
+def show_app(app, limit=50)
+  list = deployment.index_list_by_app[app]
+  return show_error("#{app}: No such app in deployment server") if list.nil?
+
+  list.each do |build|
+    puts show_build(build)
+  end
+
+  ""
+end
+
+def timestamp(ts)
+  DateTime.strptime(ts.to_s,'%s').strftime("%Y-%m-%d %H:%M:%S").style(:timestamp)
+end
+
+def build_id(build)
+  sprintf("%4d", build[:buildRecordId]).style(:identifier)
+end 
+
+def branches(build)
+  build[:branches].join(",").style(:branch)
+end
+
+def author(build)
+  build[:author].style(:author) rescue ""
+end
+
+def build_info(build)
+  name = sprintf("%36s", build[:buildId]).style(:build_name)
+  "#{name} [#{branches(build)}] -- #{author(build)}"
+end
+
+def show_app(app, builds)
+  puts "#{app.style(:class)}: #{builds.length} builds"
+  builds.each { |build| puts timestamp(build[:postDate]) + " " + build_info(build) }
+  puts
+end
+
+def show_build_set(set)
+  apps = build_set_by_app(set)
+  apps.keys.sort.each { |app| show_app(app, apps[app]) }
+end