a4tools 1.2.7

data/lib/net_shell/builtin_commands/usherm_connect.rb

@@ -0,0 +1,21 @@
+category "Usher"
+description "Connect to UsherM"
+usage "[username] [password]"
+
+help <<-EOS
+Connects to UsherM server. This connection is not related to the connection opened in #{"connect".style(:command)}; only the #{"usherm".style(:command)} family of commands make use of this connection.
+
+If username and password are omitted, they are defaulted from the #{"usherm_user".style(:environment)} and #{"usherm_pass".style(:environment)} environment variables, if set.
+
+If the #{"usherm_user".style(:environment)} and #{"usherm_pass".style(:environment)} environment variables are set when the shell starts, this connection is created automatically.
+EOS
+
+run do
+  cmd_user = args[1] rescue nil
+  cmd_pass = args[2] rescue nil
+  username = cmd_user || @shell.get_env(:usherm_user)
+  password = cmd_pass || @shell.get_env(:usherm_pass)
+  return show_error(usage_msg) unless password
+  @shell.set_client(:usherm, UsherMgmtClient.new(nil, username, password))
+  ""
+end

data/lib/net_shell/colors.rb

@@ -0,0 +1,149 @@
+require 'colorize'
+
+class String
+  def style_category
+    return self.colorize(:blue).bold
+  end
+
+  def style_class
+    return self.colorize(:light_black) if self == "none"
+
+    comps = split(".")
+    (comps.map do |comp|
+      if comp == comps.last then
+        comp.colorize(:red).bold
+      else
+        comp.colorize(:light_black)
+      end
+      
+    end).join(".")
+  end
+
+  def style_constant_name
+    self.colorize(:red)
+  end
+
+  def style_constant_value
+    self.colorize(:green).bold
+  end
+
+  def style_collection_name
+    comps = split(".")
+    (comps.map do |comp|
+      if comp == comps.last then
+        comp.colorize(:green).bold
+      else
+        comp.colorize(:light_black)
+      end
+      
+    end).join(".")
+  end
+
+  def style_protocol_name
+    self.colorize(:light_blue).bold
+  end
+
+  def style_method_name
+    self.colorize(:blue)
+  end
+
+  def style_field_name
+    self.colorize(:red)
+  end
+
+  def style_field_datatype
+    self.colorize(:magenta)
+  end
+
+  def style_origin
+    self.colorize(:magenta)
+  end
+
+  def style_command
+    self.colorize(:magenta).bold
+  end
+
+  def style_environment
+    self.colorize(:red)
+  end
+
+  def style_datacenter
+    self.colorize(:green)
+  end
+
+  def style_host
+    self.colorize(:red)
+  end
+
+  def style_ip
+    self.colorize(:blue)
+  end
+
+  def style_service
+    self.colorize(:magenta)
+  end
+
+  def style_product
+    self.colorize(:red).bold
+  end
+
+  def style_event_code
+    self.colorize(:blue).bold
+  end
+
+  def style_event_key
+    self.colorize(:red)
+  end
+
+  def style_error
+    self.colorize(:red).bold
+  end
+
+  def style_userdefined
+    self.colorize(:light_black).bold
+  end
+
+  def style_id
+    self.colorize(:green)
+  end
+
+  def style_build_name
+    self.bold
+  end
+
+  def style_branch
+    self.colorize(:red)
+  end
+
+  def style_timestamp
+    self.colorize(:blue)
+  end
+
+  def style_author
+    self.colorize(:light_black)
+  end
+
+  def style_cidr
+    ip, whack = self.split("/")
+    return self.colorize(:red) if ip.nil? or whack.nil?
+    ip.colorize(:red) + "/" + whack.colorize(:magenta)
+  end
+
+  def style_heading
+    self.bold
+  end
+
+  def style_client
+    self.bold
+  end
+
+  def style(type)
+    method = ("style_" + type.to_s).to_sym
+    return send(method) if self.methods.include?(method)
+    self
+  end
+
+  def unstyle
+    self.uncolorize
+  end
+end

data/lib/net_shell/command.rb

@@ -0,0 +1,97 @@
+require 'trollop'
+
+module A4Tools
+  class Command
+    attr_accessor :args, :input, :output, :error, :shell
+    attr_reader :status
+
+    def initialize(args, input=nil, output=nil, error=nil, shell=nil)
+      @input = input || StandardInput.new
+      @output = output || StandardOutput.new
+      @error = error || StandardOutput.new
+      @args = args
+      @shell = shell
+    end
+
+    def is_built_in?
+      built_in_methods.include? args[0].to_sym
+    end
+
+    def run_built_in
+      built_in = @shell.built_in(args[0]).new(@shell)
+      built_in.execute(@input, @output, @error, args)
+
+      @status = built_in.status
+    end
+
+    def built_in_methods
+      @shell.built_ins
+    end
+
+    def tab_complete_built_in
+      case args.length
+      when 0..1
+        built_in_methods
+      else
+        @shell.tab_complete_built_in(args)
+      end
+    end
+
+    def get_option_set
+      if args.length <= 1 or is_built_in?
+        tab_complete_built_in.map { |opt| opt.to_s || "" }
+      else
+        []
+      end
+    end
+
+    def tab_complete
+      fragment = args.last || ""
+      get_option_set.select { |opt| opt.to_s.start_with? fragment }
+    end
+
+    def make_commandline(args)
+      (args.map do |arg|
+        if arg.match(/\s/).nil? then
+          arg
+        else
+          arg.shellescape
+        end
+      end).join(" ")
+    end
+
+    def run_external
+      begin
+        cmdline = make_commandline(args)
+        Open3.popen3(cmdline) do |stdin, stdout, stderr, wait_thr|
+          begin
+            pid = wait_thr[:pid]
+
+            stdin.write(@input.read)
+            stdin.close
+
+            @status = wait_thr.value
+
+            @output.write(stdout.read)
+            stdout.close
+            stderr.close
+          rescue Errno::EPIPE
+            @error.write("-netshell: #{args[0]}: #{stderr.read}\n")
+            @status = 127
+          end
+        end
+      rescue Errno::ENOENT
+        @output.write("-netshell: #{args[0]}: command not found\n")
+        @status = 127
+      end
+
+      @status
+    end
+
+    def run
+      return "" if args.empty? or args[0].nil?
+      return run_built_in if is_built_in?
+      return run_external
+    end
+  end
+end

data/lib/net_shell/io.rb

@@ -0,0 +1,132 @@
+require 'open3'
+
+class StringBuffer
+  attr_accessor :string
+  def initialize
+    @string = ""
+  end
+
+end
+
+module A4Tools
+  class StandardOutput
+    attr_accessor :color
+
+    def write(s)
+      s = s.unstyle unless @color
+      $stdout.write s.gsub("\t", "  ").gsub("\n","\r\n")
+    end
+
+    def close
+    end
+
+    def print(s="")
+      write s.to_s
+    end
+
+    def puts(s="")
+      write s.to_s+"\n"
+    end
+  end
+
+  class PipeBuffer
+    attr_accessor :color
+    attr_reader :buffer
+
+    def initialize
+      @buffer = ""
+    end
+
+    def read
+      @color ? @buffer : @buffer.unstyle
+    end
+
+    def read_all
+      @color ? @buffer : @buffer.unstyle
+    end
+
+    def write(s)
+      @buffer += s
+    end
+
+    def puts(s)
+      if s.is_a? Array then
+        s.each { |e| puts e.to_s }
+      else
+        write(s.to_s+"\n")
+      end
+    end
+
+    def printf(s, *a)
+      write(sprintf(s.to_s, *a))
+    end
+
+    def print(s="")
+      write(s.to_s)
+    end
+
+    def close
+    end
+  end
+
+  class FileOverwriteOutput < StandardOutput
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def access_type
+      "w"
+    end
+
+    def write(s)
+      s = s.unstyle unless @color
+      @fd ||= File.open(@filename, access_type)
+      @fd.write(s)
+      @fd.flush
+    end
+
+    def close
+      @fd.close
+    end
+  end
+
+  class FileAppendOutput < FileOverwriteOutput
+    def access_type
+      "a"
+    end
+  end
+
+  class StandardInput
+    def read
+      begin
+        STDIN.read_nonblock(256)
+      rescue IO::WaitReadable
+        ""
+      rescue EOFError
+        nil
+      end
+    end
+
+    def read_all
+      buffer = ""
+      while (line = read) != nil
+        buffer += line
+      end
+      buffer.chomp
+    end
+  end
+
+  class FileReadInput
+    def initialize(filename)
+      @filename = filename
+    end
+
+    def read
+      IO.read(@filename)
+    end
+
+    def read_all
+      IO.read(@filename)
+    end
+  end
+end

data/lib/net_shell/net_shell.rb

@@ -0,0 +1,396 @@
+require 'io/console'
+require 'net_shell/command'
+require 'net_shell/io'
+require 'net_shell/colors'
+require 'net_shell/prompt'
+require 'net_shell/builtin_command.rb'
+require 'digest/sha1'
+require 'shellwords'
+
+module A4Tools
+  class NetShell
+    attr_accessor :env, :shared, :processing
+
+    def initialize
+      @history = []
+      @env = {}
+      @shared = { traffic:[] }
+      $config = @env
+      $localtalk = File.join(config_dir, "talk.json")
+
+      set_env(:color, "1")
+      set_env(:show_async, "1")
+      set_env(:serial, stored_serial)
+
+      read_env
+      setup_builtins
+      setup_support
+    end
+
+    ###
+    # Netshell setup
+    ###
+
+    def setup_support
+      setup_stored_json
+      setup_deployment_connection
+      setup_usherm_connection
+    end
+
+    def setup_stored_json
+      ObjectBuilder.load_path(shelldir(:json))
+    end
+
+    def config_dir
+      path = File.expand_path("~/.netshell")
+      Dir.mkdir(path) unless File.directory? path
+      path
+    end
+
+    def shelldir(dir)
+      path = File.join(config_dir, dir.to_s)
+      Dir.mkdir(path) unless File.directory? path
+      path
+    end
+
+    ###
+    # Built-in commands
+    ###
+
+    def allow_alerts(allow=true)
+      @allow_alerts = true
+    end
+
+    def setup_builtins
+      @built_ins ||= {}
+      dir = File.expand_path("builtin_commands", File.dirname(__FILE__))
+      all = load_builtins_from_directory(dir, false) + load_builtins_from_directory(shelldir(:bin), true)
+      @built_ins.delete_if { |command, subclass| not(all.include? subclass)  }
+    end
+
+    def load_builtins_from_directory(dir, userdef)
+      Dir[File.join(dir, "*.rb")].map do |file|
+        subclass = built_in(File.basename(file, ".rb"))
+        if subclass.nil? or subclass.sha1 != Digest::SHA1.hexdigest(IO.read(file))
+          subclass = BuiltinCommand.load_command(file, userdef)
+          register_built_in(subclass.command, subclass)
+        end
+        subclass
+      end
+    end
+
+    def has_built_in?(name)
+      return built_in(name) != nil
+    end
+
+    def built_in(name)
+      @built_ins[name.to_sym]
+    end
+
+    def built_ins(full=false)
+      full ? @built_ins.values : @built_ins.keys
+    end
+
+    def register_built_in(command, cls)
+      @built_ins[command.to_sym] = cls
+    end
+
+    def tab_complete_built_in(args)
+      return [] unless has_built_in?(args[0])
+
+      built_in = built_in(args[0]).new(self)
+      built_in.parse(args)
+      built_in.tab
+    end
+
+    ###
+    # Environment management
+    ###
+
+    def path_for_env(key)
+      File.join(shelldir(:env), key)
+    end
+
+    def persist_env(*keys)
+      keys = @env.keys if keys.empty?
+      keys = keys[0] if keys[0].is_a? Array
+
+      present = keys.reject { |key| get_env(key).nil? }
+      absent = keys.select { |key| get_env(key).nil? }
+      present.each { |key| File.write(path_for_env(key), get_env(key)) }
+      unpersist_env(absent)
+    end
+
+    def unpersist_env(*keys)
+      keys = keys[0] if keys[0].is_a? Array
+      keys.each do |key|
+        path = path_for_env(key)
+        File.delete(path) if File.exist? path
+      end
+    end
+
+    def read_env
+      Dir[File.join(shelldir(:env), "*")].each { |file| set_env(File.basename(file), File.open(file).read.chomp) }
+    end
+
+    def set_env(key, value)
+      if value.nil?
+        @env.delete(key.to_sym)
+      else
+        @env[key.to_sym] = value
+      end
+    end
+
+    def get_env(key)
+      @env[key.to_sym]
+    end
+
+    def env_is_true?(key)
+      value = get_env(key)
+      value != nil and value != "0"
+    end
+
+    ###
+    # Shared variables
+    ###
+
+    def username
+      @env[:usherm_user]
+    end
+
+    def password
+      @env[:usherm_pass]
+    end
+
+    def setup_usherm_connection
+      return if username.nil? or password.nil?
+      set_client(:usherm, UsherMgmtClient.new(nil, username, password))
+      puts "\rAutomatically connecting to Usher as #{username}"
+    end
+
+    def setup_deployment_connection
+      return if username.nil? or password.nil?
+      set_client(:deployment, DeploymentClient.new("http://deployments.acres4.net:8080/deployment/json?wrap", username, password))
+      puts "\rAutomatically connecting to Deployment as #{username}"
+    end
+
+    def clients
+      @clients.keys
+    end
+
+    def client(key)
+      @clients[key.to_sym]
+    end
+
+    def set_client(key, client)
+      @clients ||= {}
+      @clients[key] = client
+      client.refresh_async rescue ""
+      client.on(:error) { |trigger, message| alert("#{key.to_s}: #{message}") }
+    end
+
+    def set_active_client(key)
+      @shared[:client] = @clients[key.to_sym]
+    end
+
+    def active_client
+      @shared[:client]
+    end
+
+    def active_client_name
+      @clients.each { |key, client| return key if client == @shared[:client] }
+      nil
+    end
+
+    ###
+    # Command prompt
+    ###
+
+    def bad_command(args)
+      "Unrecognized command: #{args[0]}"
+    end
+
+    def is_input_redirect?(arg)
+      arg == "<"
+    end
+
+    def is_output_redirect?(arg)
+      [ ">", ">>" ].include? arg
+    end
+
+    def is_redirect?(arg)
+      is_input_redirect?(arg) || is_output_redirect?(arg)
+    end
+
+    def get_input(args)
+      index = args.find_index { |arg| is_input_redirect? arg }
+      return StandardInput.new if (index.nil? or index > args.length - 2)
+
+      case args[index]
+      when "<"
+        FileReadInput.new(args[index+1])
+      end
+    end
+
+    def get_output(args)
+      index = args.find_index { |arg| is_output_redirect? arg }
+      default = StandardOutput.new
+      default.color = @env[:color] != "0"
+      return default if (index.nil? or index > args.length - 2)
+
+      case args[index]
+      when ">"
+        FileOverwriteOutput.new(args[index+1])
+      when ">>"
+        puts "Appending to #{args[index+1]}"
+        FileAppendOutput.new(args[index+1])
+      end
+    end
+
+    def get_error(args)
+      error = StandardOutput.new
+      error.color = @env[:color] != "0"
+      error
+    end
+
+    def clean_args(args)
+      index = args.find_index { |arg| is_redirect? arg }
+      return args if index.nil?
+      args[0 .. index-1]
+    end
+
+    def split_args(cmdline)
+      return [] if cmdline.nil? or cmdline.empty?
+      cmdline.gsub(/`\b/, "\"`").gsub(/\b`/, "`\"").shellsplit_partial
+    end
+
+    def process_backtick(line)
+      line = line[1..-2] if line[0] == '`' and line[-1] == '`'
+      cmd = command_for_line(line)
+      cmd.input = StandardInput.new
+      cmd.output = PipeBuffer.new
+      cmd.run
+      cmd.output.read.chomp
+    end
+
+    def transform_args(args)
+      args.map do |arg|
+        if arg[0] == "$" then
+          get_env(arg[1..-1]) || ""
+        elsif arg[0] == '`' and arg[-1] == '`' then
+          process_backtick(arg)
+        else
+          arg
+        end
+      end
+    end
+
+    def command_for_line(cmdline, allow_trailing_space=false)
+      cmdline ||= ""
+      args = transform_args(split_args(cmdline))
+      args.push "" if allow_trailing_space and cmdline.match(/\s+$/)
+      Command.new(clean_args(args), get_input(args), get_output(args), get_error(args), self)
+    end
+
+    def exec(cmdline)
+      return if cmdline.match(/^\s+$/)
+      commands = cmdline.split("|").map { |subcommand| command_for_line(subcommand) }
+
+      last_cmd = nil
+      commands.each do |cmd|
+        cmd.input = last_cmd.output unless last_cmd.nil?
+        cmd.output = PipeBuffer.new unless cmd == commands.last
+        break if cmd.run != 0
+        last_cmd = cmd
+      end
+    end
+
+    def add_to_alert_queue(msg)
+      @alert_queue ||= []
+      @alert_queue.push(msg)
+    end
+
+    def flush_alert_queue
+      return if @alert_queue.nil?
+      @alert_queue.each { |alert_msg| alert(alert_msg) }
+      @alert_queue = nil
+    end
+
+    def alert(msg)
+      if @processing and not @allow_alerts
+        add_to_alert_queue(msg)
+        return
+      end
+
+      @prompt.clear_line
+      @prompt.refresh_prompt
+      puts "\r#{msg}"
+      @prompt.redraw_line if @alert_queue.nil? and not @processing
+    end
+
+    def prompt_text
+      client = self.shared[:client]
+      return "net> " if client.nil? or not client.ready
+      return "#{client.uri}> " if client.server_info.nil?
+
+      "#{client.uri} #{client.server_info[:appName]}> "
+    end
+
+    def enter
+      @prompt = Prompt.new(:history_file => File.join(config_dir, "history"))
+      @prompt.tab = lambda do |cmdline|
+        setup_builtins
+        command_for_line(cmdline.split("|").last, true).tab_complete
+      end
+      @prompt.prompt = lambda { prompt_text }
+      @processing = false
+
+      while(true) do
+        line = @prompt.read_line
+        setup_builtins
+        @processing = true
+        @allow_alerts = false
+        exec(line)
+        @processing = false
+        flush_alert_queue
+      end
+    end
+
+    ###
+    # Network listener
+    ###
+
+    def wrap_message(message, sender)
+      { time: Time.now, sender: sender, message: message }
+    end
+
+    def notify_outgoing_message(client, message)
+    end
+
+    def notify_connect(client)
+      return unless client == active_client
+    end
+
+    def notify_disconnect(client)
+      return unless client == active_client
+      alert("Disconnected from #{client.uri}")
+    end
+
+    def notify_incoming_message(client, message)
+      return unless client == active_client
+      alert("server:".magenta + " #{message}") if env_is_true?(:show_async)
+    end
+
+    def stored_serial
+      file = File.join(config_dir, "serial")
+
+      begin
+        return IO.read(file)
+      rescue
+        serial = Digest::SHA1.hexdigest(Random.new.bytes(16)).to_s
+        File.write(file, serial) rescue nil
+        return serial
+      end
+    end
+  end
+end