trainsh 0.2.0

checksums.yaml

@@ -0,0 +1,7 @@
+---
+SHA256:
+  metadata.gz: 6b809837d484a4a100b8d6b6d4718d623bb91990ea72d7181b5e70dbe265282a
+  data.tar.gz: 12a87fc192b92df5f3f0528c620d898c24dc5d7ec849b51081c7d996d57e51fa
+SHA512:
+  metadata.gz: adef421ee124699ee90b841a57c0ef0653e7377a2d9cb6b3f6b0faa50948cc903e36fe38af4893ac8d60e8a9c94eb1adf3f8c66cd733c163700fac1480d148a4
+  data.tar.gz: 98947781c875c65f82563caeafba4637764c65758ebf8edf60fd16bf0765afe3a286032045957c20c0291248baf75f46dc165f25605492eb920b620a1d7737bc

data/CHANGELOG.md

@@ -0,0 +1,5 @@
+# Changelog
+
+## Version 0.2.0
+
+- Renamed to TrainSH

data/README.md

@@ -0,0 +1,143 @@
+# TrainSH
+
+## Summary
+
+Interactive Shell for Remote Systems
+
+Based on the Train ecosystem, provide a shell to manage systems via a multitude of transports.
+
+Train default supports:
+
+- Docker
+- Local
+- SSH (Unix, Windows, Cisco)
+- WinRM (Windows)
+
+3rd party plugins support:
+
+- AWS Systems Manager
+- LXD
+- Telnet
+- Serial/USB interfaces
+- VMware Guest Operations (VMware Tools)
+- ...
+
+## Example uses
+
+When specifying a password within an URL take care of special characters or the connection will fail.
+
+```shell
+trainsh connect local://
+```
+
+```shell
+trainsh connect winrm://Administrator:Passw0rd@10.20.30.40
+```
+
+```shell
+trainsh connect awsssm://i-123456789abc0
+```
+
+```shell
+trainsh connect vsphere-gom://example-vm
+```
+
+If the transport has additional options like `key_files`, they need to be added as URL parameters (`ssh://10.20.30.40/?key_files=~/.ssh/id_rsa2`).
+
+## Shell commands
+
+There are three separate categories of commands when in the Shell:
+
+- remote commands
+- local commands, which are prefixed with `.`
+- built-in commands, wich are prefixed with `!`
+
+Anything you type without a prefix gets executed 1:1 on the remote system. Please notice that Train is headless, so any interactive programs will not work but lock up your shell! If you need to edit remote files or use a pager (like `less`), please look into the Built-In Commands section.
+
+Local commands get executed 1:1 on your local system, so you are able to check things locally or change paths, for example.
+
+There is also the Sessionprefix `@`, which is described briefly in the "Prompt and Sessions" section.
+
+## Built-In Commands
+
+`!!!`
+Quit TrainSH. Aliases: `quit`, `exit`, `logout`, `disconnect`.
+
+`!clear-history`
+Clear your TrainSH history, for example to remove clutter or sensitive information
+
+`!connect <uri>`
+Connect to another system. The URI needs to match the format of the used Train transport, which is usually `transportname://host` but varies. See the Train transport's documentation for details.
+
+`!detect`
+Re-runs the OS detection which is running automatically on start. This will determine the OS, OS-family and general platform information via Train.
+
+`!download <remote> <local>`
+Download a file to the local system. You need to specify the target, if you want to keep the name just use `.` as local part.
+
+`!edit <remotefile>`
+Downloads the remote file as temporary file and opens the system default editor locally (`EDITOR` and `VISUAL` environment variables, with fallback to `vi`). Upon exiting the file, it will be uploaded again and overwrite the remote file.
+
+`!env`
+Prints the environment variables of your remote shell. This will be filled on first command invocation to save IO. **Currently unsupported for Windows remote systems**
+
+`!history`
+Output your TrainSH command history. As this uses the popular Readline library, you can also navigate your history with the Up/Down arrows or use Ctrl-R for reverse search. You can do auto completion for built-in commands.
+
+`!host`
+Outputs the remote hostname.
+
+`!ping`
+Executes a simple command to measure roundtrip/overhead time.
+
+`!pwd`
+Output the remote working directory. This will be filled on first command invocation to save IO.
+
+`!read <remotefile>`
+Download the specified file and display it in the system default pager (`PAGER` environment variable, with fallback to `less`).
+
+`!reconnect`
+Quits and reopens the current session.
+
+`!sessions`
+List all currently active sessions (See "Prompt and Sessions" section). Password information is redacted for security reasons.
+
+`!session <session_id>`
+Change to another session by passing its ID (=number)
+
+`!upload <local> <remote>`
+Upload files to the target machine
+
+## Prompt and Sessions
+
+`OK trainsh(@0 local://trc4023)>`
+
+The prompt consists roughly of three areas:
+
+- Exit code of last command ("OK" or the exit code in format `Exx` with xx being the numeric code)
+- Session indication
+- Input area
+
+The session indication includes the ID of the session, so `@0` means session 0, `@1` means session 1 and so on. The second part shows the Train URI for the remote system for easy identification.
+
+Any TrainSH invocation has at minimum one active session but if you want, you can add more sessions with the `!connect <uri>` built-in. Every session has its own Train backend and storage of current working directory, environment variables etc. You can list active sessions with `!sessions` and switch between them using `!session <session_id>`.
+
+If you want to execute commands on another session ad-hoc, you can prefix it with the session id: `@1 uname -a` will execute the `uname -a` command on session ID 1.
+
+Depending on the transport and target, the time between sending a command and retrieving the result will vary widely. In TrainSH this is called the "ping", which measures the minimum overhead/latency for the session. It varies massively between Train plugins and is not only related to the network distance, but also to the way of command execution - which might involve a number of HTTPS requests or the time to invoke a remote shell (examples: AWS SSM and VSphere GOM transports).
+
+### Under the Hood
+
+As Train is headless/stateless system, there will be various pre- and postfixed commands to make your life easier. This means that any state-related commands like changing the current directory or modification of environment variables would be unavailable for the next command - as it technically is a separate shell.
+
+To make this easier, internal commands get attached to your input like this:
+
+- Prefix: Get remote hostname (discovery task, just on first execution)
+- Prefix: Set previous environment variables
+- Prefix: Set previous path
+- Command
+- Postfix: Retrieve and save exit code of command
+- Postfix: Retrieve and save new path
+- Postfix: Retrieve and save new environment variables
+
+Output of commands gets separated by outputting a highly random string between, which should not result in false positives. If a false positive occurs for some reason, TrainSH will fail and output an error.

data/lib/trainsh.rb

@@ -0,0 +1,5 @@
+# require_relative 'trainsh/config'
+require_relative 'trainsh/constants'
+require_relative 'trainsh/errors'
+# require_relative 'trainsh/log'
+require_relative 'trainsh/version'

data/lib/trainsh/cli.rb

@@ -0,0 +1,261 @@
+require_relative '../trainsh'
+require_relative 'session'
+
+require_relative 'mixin/builtin_commands'
+require_relative 'mixin/file_helpers'
+require_relative 'mixin/sessions'
+
+# TODO
+# require_relative 'detectors/target/env.rb'
+# require_relative 'detectors/target/kitchen.rb'
+
+require 'colored'
+require 'fileutils'
+require 'readline'
+require 'train'
+require 'thor'
+
+module TrainSH
+  class Cli < Thor
+    include Thor::Actions
+    check_unknown_options!
+    # add_runtime_options!
+
+    def self.exit_on_failure?
+      true
+    end
+
+    map %w[version] => :__print_version
+    desc 'version', 'Display version'
+    def __print_version
+      say "#{TrainSH::PRODUCT} #{TrainSH::VERSION} (Ruby #{RUBY_VERSION}-#{RUBY_PLATFORM})"
+    end
+
+    EXIT_COMMANDS = %w[!!! exit quit logout disconnect].freeze
+    INTERACTIVE_COMMANDS = %w[more less vi vim nano].freeze
+
+    no_commands do
+      include TrainSH::Mixin::BuiltInCommands
+      include TrainSH::Mixin::FileHelpers
+      include TrainSH::Mixin::Sessions
+
+      def __disconnect
+        session.close
+
+        say 'Disconnected'
+      end
+
+      # TODO
+      # def __detect_url(url)
+      #   url || kitchen_url || ENV['target']
+      # end
+
+      def __detect
+        raise 'No session in __detect' unless session
+
+        platform = session.platform
+
+        say format('Platform: %<title>s %<release>s (%<arch>s)',
+                   title:   platform.title,
+                   release: platform.release,
+                   arch:    platform.arch)
+        say format('Hierarchy: %<hierarchy>s',
+                   hierarchy: platform.family_hierarchy.reverse.join('/'))
+        say 'Measuring ping over connection...'
+
+        # Idle command will also trigger discovery commands on first run
+        session.run_idle
+
+        say format('Ping: %<ping>dms', ping: session.ping) if session.ping
+      end
+
+      def target_detectors
+        Dir[File.join(__dir__, 'lib', '*.rb')].sort.each { |file| require file }
+
+        TrainSH::Detectors::TargetDetector.descendants
+      end
+
+      def execute(input)
+        case input[0]
+        when '.'
+          execute_locally input[1..]
+        when '!'
+          execute_builtin input[1..]
+        when '@'
+          execute_via_session input[1..]
+        else
+          execute_via_train input
+        end
+      end
+
+      def execute_locally(input)
+        system(input)
+      end
+
+      def execute_via_train(input, session_id = current_session_id)
+        return if interactive_command? input
+
+        command_result = @sessions[session_id].run(input)
+
+        say command_result.stdout unless command_result.stdout && command_result.stdout.empty?
+        say command_result.stderr.red unless command_result.stderr && command_result.stderr.empty?
+      end
+
+      def execute_builtin(input)
+        cmd, *args = input.split
+
+        ruby_cmd = cmd.tr('-', '_')
+
+        if builtin_commands.include? ruby_cmd
+          send("#{BUILTIN_PREFIX}#{ruby_cmd}".to_sym, *args)
+        else
+          say format('Unknown built-in "%<cmd>s"', cmd: cmd)
+        end
+      end
+
+      def execute_via_session(input)
+        session_id, *data = input.split
+
+        session_id = validate_session_id(session_id)
+        if session_id.nil?
+          say 'Expecting valid session id, e.g. `!session 2`'.red
+          return
+        end
+
+        input = data.join(' ')
+        if input.empty?
+          say 'Specify command to execute, e.g. `@0 ls`'
+          return
+        end
+
+        execute_via_train(input, session_id)
+      end
+
+      def interactive_command?(cmd)
+        return unless INTERACTIVE_COMMANDS.any? { |banned| cmd.start_with? banned }
+
+        say 'Cannot execute interactive commands on non-tty sessions'.red
+      end
+
+      def exit_command?(cmd)
+        EXIT_COMMANDS.include? cmd
+      end
+
+      def prompt
+        exitcode = current_session.exitcode
+        exitcode_prefix = exitcode.zero? ? 'OK '.green : format('E%02d ', exitcode).red
+
+        format(::TrainSH::PROMPT,
+               exitcode:        exitcode,
+               exitcode_prefix: exitcode_prefix,
+               session_id:      current_session_id,
+               backend:         current_session.backend || 'unknown',
+               host:            current_session.host || 'unknown',
+               path:            current_session.pwd || '?')
+      end
+
+      def auto_complete(partial)
+        choices = []
+
+        choices.concat(builtin_commands.map { |cmd| "!#{cmd.tr('_', '-')}" })
+        choices.concat(sessions.map { |session_id| "@#{session_id}" })
+        choices.concat %w[!!!]
+
+        choices.filter { |choice| choice.start_with? partial }
+      end
+
+      # def get_log_level(level)
+      #   valid = %w{debug info warn error fatal}
+      #
+      #   if valid.include?(level)
+      #     l = level
+      #   else
+      #     l = "info"
+      #   end
+      #
+      #   Logger.const_get(l.upcase)
+      # end
+    end
+
+    # class_option :log_level, desc: "Log level", aliases: "-l", default: :info
+    class_option :messy, desc: 'Skip deletion of temporary files for speedup', default: false, type: :boolean
+
+    desc 'connect URL', 'Connect to a destination interactively'
+
+    def connect(url)
+      exit unless use_session(url)
+
+      say format('Connected to %<url>s', url: session.url).bold
+      say 'Running platform detection...'
+      __detect
+
+      # History persistence (TODO: Extract)
+      user_conf_dir = File.join(ENV['HOME'], TrainSH::USER_CONF_DIR)
+      history_file = File.join(user_conf_dir, 'history')
+      FileUtils.mkdir_p(user_conf_dir)
+      FileUtils.touch(history_file)
+      File.readlines(history_file).each { |line| Readline::HISTORY.push line.strip }
+      at_exit {
+        history_file = File.join(user_conf_dir, 'history')
+        File.open(history_file, 'w') { |f|
+          f.write Readline::HISTORY.to_a.join("\n")
+        }
+      }
+
+      # Catch Ctrl-C and exit cleanly
+      stty_save = `stty -g`.chomp
+      trap('INT') do
+        puts '^C'
+        system('stty', stty_save)
+        exit
+      end
+
+      # Autocompletion
+      Readline.completion_proc = method(:auto_complete).to_proc
+      Readline.completion_append_character = ' '
+
+      while (input = Readline.readline(prompt, true))
+        if input.empty?
+          Readline::HISTORY.pop
+          next
+        end
+
+        Readline::HISTORY.pop if input.start_with? '!history'
+
+        break if exit_command? input
+        next if interactive_command? input
+
+        execute input
+      end
+    end
+
+    # desc 'copy FILE/DIR|URL FILE/DIR|URL', 'Copy files or directories'
+    # def copy(url_or_file, url_or_file)
+    #   # TODO?
+    # end
+
+    desc 'detect URL', 'Retrieve remote OS and platform information'
+    def detect(url)
+      exit unless use_session(url)
+      __detect
+    end
+
+    # desc 'exec URL -- (COMMAND)', 'Execute remote commands'
+    # method_option :file, aliases: '-f', desc: "command file to read"
+    # def exec
+    #   # TODO
+    #   # TODO: Also accept getting commands from STDIN and from a file
+    # end
+
+    desc 'list-transports', 'List available transports'
+    def list_transports
+      # TODO: Train only lazy-loads and does not have a full registry
+      #       https://github.com/inspec/train/blob/be90ca53ea1c1e8aa7439c504fbee86f4b399d83/lib/train.rb#L38-L61
+
+      # TODO: Filter for only "OS" transports as well
+      transports = %w[local ssh winrm docker]
+
+      say "Available transports: #{transports.sort.join(', ')}"
+    end
+  end
+end

data/lib/trainsh/config.rb

@@ -0,0 +1,15 @@
+require 'mixlib/config'
+
+module TrainSH
+  module Config
+    extend Mixlib::Config
+    config_strict_mode true
+
+    default :log_level, :info
+
+    default :pager, ENV['PAGER'] || 'less'
+    default :editor, ENV['EDITOR'] || ENV['VISUAL'] || 'vi'
+
+    default :user_config, "~/#{ENV['USER_CONF_DIR']}"
+  end
+end

data/lib/trainsh/constants.rb

@@ -0,0 +1,21 @@
+module TrainSH
+  PRODUCT = 'TrainSH'.freeze
+
+  # The executable for interactive use
+  EXEC = 'trainsh'.freeze
+
+  # Prefix for environment variables
+  ENV_PREFIX = 'TRAINSH_'.freeze
+
+  # The user's configuration directory
+  USER_CONF_DIR = '.trainsh'.freeze
+
+  # Minimum version for remote file manipulation
+  TRAIN_MUTABLE_VERSION = '3.5.0'.freeze
+
+  # Prompt (TODO: Make configuratble)
+  PROMPT = '%<exitcode_prefix>strainsh(@%<session_id>d %<backend>s://%<host>s)> '.freeze
+
+  # Variable to remotely persist exit code
+  EXITCODE_VAR = 'CMD_EXIT'.freeze
+end

data/lib/trainsh/detectors/target.rb

@@ -0,0 +1,17 @@
+module TrainSH
+  module Detectors
+    class TargetDetector
+      def self.descendants
+        ObjectSpace.each_object(Class).select { |klass| klass < self }
+      end
+
+      def to_s
+        self.class.to_s
+      end
+
+      def url
+        raise "Implement `url` for target detector #{self}"
+      end
+    end
+  end
+end

data/lib/trainsh/detectors/target/env.rb

@@ -0,0 +1,11 @@
+require_relative '../target'
+
+module TrainSH
+  module Detectors
+    class EnvTarget < TargetDetector
+      def url
+        ENV['target']
+      end
+    end
+  end
+end

data/lib/trainsh/detectors/target/kitchen.rb

@@ -0,0 +1,44 @@
+require_relative '../target'
+
+module TrainSH
+  module Detectors
+    class KitchenTarget < TargetDetector
+      def url
+        # return unless kitchen_available?
+        # return unless kitchen_instance
+
+        # kitchen_config['transport']
+      end
+
+      # private
+
+      # def kitchen_available?
+      #   `kitchen`
+      #   true
+      # rescue
+      #   false
+      # end
+
+      # attr_writer :kitchen_instances
+      # def kitchen_instances
+      #   return if @kitchen_instances
+
+      #   @kitchen_instances ||= YAML.load(`KITCHEN_LOCAL_YAML=".kitchen.ec2.yaml" kitchen list --json`)
+      # end
+
+      # def kitchen_config
+      #   return if @kitchen_config
+
+      #   parsed_output = YAML.load(`KITCHEN_LOCAL_YAML=".kitchen.ec2.yaml" kitchen diagnose customize-amazon2`)
+      #   @kitchen_config = kitchen_config['instances'].keys.first
+      # end
+
+      # def kitchen_instance_name
+      #   kitchen_instances.select! { |instance| instance['last_action'] != nil }
+
+      #   return nil if kitchen_instances.count != 1
+      #   kitchen_instances.first['instance']
+      # end
+    end
+  end
+end

data/lib/trainsh/errors.rb

@@ -0,0 +1,2 @@
+module TrainSH
+end

data/lib/trainsh/log.rb

@@ -0,0 +1,7 @@
+require 'mixlib/log'
+
+module TrainSH
+  class Log
+    extend Mixlib::Log
+  end
+end

data/lib/trainsh/mixin/builtin_commands.rb

@@ -0,0 +1,156 @@
+require 'train/errors'
+
+module TrainSH
+  module Mixin
+    module BuiltInCommands
+      BUILTIN_PREFIX = 'builtincmd_'.freeze
+
+      def builtin_commands
+        methods.sort.filter { |method| method.to_s.start_with? BUILTIN_PREFIX }.map { |method| method.to_s.delete_prefix BUILTIN_PREFIX }
+      end
+
+      def builtincmd_clear_history(_args = nil)
+        Readline::HISTORY.clear
+      end
+
+      def builtincmd_connect(url = nil)
+        if url.nil? || url.strip.empty?
+          say 'Expecting session url, e.g. `!connect docker://123456789abcdef0`'.red
+          return false
+        end
+
+        use_session(url)
+      end
+
+      # def builtincmd_copy(source = nil, destination = nil)
+      #   # TODO: Copy files between sessions
+      # end
+
+      def builtincmd_detect(_args = nil)
+        __detect
+      end
+
+      def builtincmd_download(remote_path = nil, local_path = nil)
+        if remote_path.nil? || local_path.nil?
+          say 'Expecting remote path and local path, e.g. `!download /etc/passwd /home/ubuntu`'
+          return false
+        end
+
+        return unless train_mutable?
+
+        session.download(remote_path, local_path)
+      rescue ::Train::NotImplementedError
+        say 'Backend for session does not implement download operation'.red
+      end
+
+      def builtincmd_edit(path = nil)
+        if path.nil? || path.strip.empty?
+          say 'Expecting remote path, e.g. `!less /tmp/somefile.txt`'.red
+          return false
+        end
+
+        tempfile = read_file(path)
+
+        localeditor = ENV['EDITOR'] || ENV['VISUAL'] || 'vi' # TODO: configuration, Windows, ...
+        say format('Using local editor `%<editor>s` for %<tempfile>s', editor: localeditor, tempfile: tempfile.path)
+
+        system("#{localeditor} #{tempfile.path}")
+
+        new_content = File.read(tempfile.path)
+
+        write_file(path, new_content)
+        tempfile.unlink
+      rescue ::Train::NotImplementedError
+        say 'Backend for session does not implement file operations'.red
+      end
+
+      def builtincmd_env(_args = nil)
+        puts session.env
+      end
+
+      def builtincmd_read(path = nil)
+        if path.nil? || path.strip.empty?
+          say 'Expecting remote path, e.g. `!read /tmp/somefile.txt`'.red
+          return false
+        end
+
+        tempfile = read_file(path)
+        return false unless tempfile
+
+        localpager = ENV['PAGER'] || 'less' # TODO: configuration, Windows, ...
+        say format('Using local pager `%<pager>s` for %<tempfile>s', pager: localpager, tempfile: tempfile.path)
+        system("#{localpager} #{tempfile.path}")
+
+        tempfile.unlink
+      rescue ::NotImplementedError
+        say 'Backend for session does not implement file operations'.red
+      end
+
+      def builtincmd_history(_args = nil)
+        puts Readline::HISTORY.to_a
+      end
+
+      def builtincmd_host(_args = nil)
+        say session.host
+      end
+
+      def builtincmd_ping(_args = nil)
+        session.run_idle
+        say format('Ping: %<ping>dms', ping: session.ping)
+      end
+
+      def builtincmd_pwd(_args = nil)
+        say session.pwd
+      end
+
+      def builtincmd_reconnect(_args = nil)
+        session.reconnect
+      end
+
+      def builtincmd_sessions(_args = nil)
+        say 'Active sessions:'
+
+        @sessions.each_with_index do |session, idx|
+          say format('[%<idx>d] %<session>s', idx: idx, session: session.url)
+        end
+      end
+
+      def builtincmd_session(session_id = nil)
+        session_id = validate_session_id(session_id)
+
+        if session_id.nil?
+          say 'Expecting valid session id, e.g. `!session 2`'.red
+          return false
+        end
+
+        # TODO: Make this more pretty
+        session_url = @sessions[session_id].url
+
+        use_session(session_url)
+      end
+
+      def builtincmd_upload(local_path = nil, remote_path = nil)
+        if remote_path.nil? || local_path.nil?
+          say 'Expecting remote path and local path, e.g. `!download /home/ubuntu/passwd /etc`'
+          return false
+        end
+
+        return unless train_mutable?
+
+        session.upload(local_path, remote_path)
+      rescue ::Errno::ENOENT
+        say "Local file/directory '#{local_path}' does not exist".red
+      rescue ::NotImplementedError
+        say 'Backend for session does not implement upload operation'.red
+      end
+
+      private
+
+      def train_mutable?
+        return true if session.respond_to?(:upload)
+
+        say "Support for remote file modification needs at least Train #{::TrainSH::TRAIN_MUTABLE_VERSION} (is: #{::Train::VERSION})".red
+      end
+    end
+  end
+end

data/lib/trainsh/mixin/file_helpers.rb

@@ -0,0 +1,23 @@
+require 'tempfile' unless defined?(Tempfile)
+
+module TrainSH
+  module Mixin
+    module FileHelpers
+      def read_file(path)
+        remotefile = session.file(path)
+        say format('Remote file %<filename>s does not exist', filename: path) unless remotefile.exist?
+
+        localfile = Tempfile.open
+        localfile.write(remotefile.content || '')
+        localfile.close
+
+        localfile
+      end
+
+      def write_file(path, content)
+        remotefile = session.file(path)
+        remotefile.content = content
+      end
+    end
+  end
+end

data/lib/trainsh/mixin/sessions.rb

@@ -0,0 +1,54 @@
+require_relative '../session'
+
+module TrainSH
+  module Mixin
+    module Sessions
+      def use_session(url)
+        @sessions = [] if @sessions.nil?
+
+        existing_id = @sessions.index { |session| session.url == url }
+
+        if existing_id.nil?
+          @current_session_id = @sessions.count
+          @sessions << TrainSH::Session.new(url)
+        else
+          @current_session_id = existing_id
+        end
+      rescue Train::PluginLoadError
+        say format('No Train plugin found for url %<url>s', url: url).red
+        nil
+      end
+
+      def session(session_id = current_session_id)
+        @sessions[session_id]
+      end
+
+      # ?
+      def sessions
+        (0..@sessions.count - 1).to_a
+      end
+
+      def current_session_id
+        @current_session_id ||= 0
+      end
+
+      def current_session
+        @sessions[current_session_id]
+      end
+
+      def validate_session_id(session_id)
+        unless session_id.match?(/^[0-9]+$/)
+          say 'Expected session id to be numeric'.red
+          return
+        end
+
+        if @sessions[session_id.to_i].nil?
+          say format('No session id [%s] found', session_id).red
+          return
+        end
+
+        session_id.to_i
+      end
+    end
+  end
+end

data/lib/trainsh/session.rb

@@ -0,0 +1,190 @@
+require 'benchmark'
+require 'forwardable'
+
+require 'train'
+
+module TrainSH
+  class Command
+    MAGIC_STRING = 'mVDK6afaqa6fb7kcMqTpR2aoUFbYsRt889G4eGoI'.freeze
+
+    attr_writer :connection
+
+    def initialize(command, connection)
+      @command = command
+      @connection = connection
+
+      @prefixes = []
+      @postfixes = []
+    end
+
+    def prefix(prefix_command, &block)
+      @prefixes << {
+        command: prefix_command,
+        block: block
+      }
+    end
+
+    def postfix(postfix_command, &block)
+      @postfixes << {
+        command: postfix_command,
+        block: block
+      }
+    end
+
+    def run
+      result = @connection.run_command aggregate_commands
+      stdouts = parse(result)
+
+      prefixes_stdout = stdouts.first(@prefixes.count).reverse
+      @prefixes.each_with_index do |prefix, idx|
+        next if prefix[:block].nil?
+
+        prefix[:block].call prefixes_stdout[idx]
+      end
+      @prefixes.count.times { stdouts.shift } unless @prefixes.empty?
+
+      postfixes_stdout = stdouts.last(@postfixes.count)
+      @postfixes.each_with_index do |postfix, idx|
+        next if postfix[:block].nil?
+
+        postfix[:block].call postfixes_stdout[idx]
+      end
+      @postfixes.count.times { stdouts.pop } unless @postfixes.empty?
+
+      raise 'Pre-/Postfix command processing ended up with more than one remaining stdout' if stdouts.count > 1
+
+      result.stdout = stdouts.first
+      # result.stderr = "" # TODO
+      result.exit_status = 0 # TODO
+      result
+    end
+
+    def parse(result)
+      result.stdout
+            .gsub(/\r\n/, "\n")
+            .gsub(/ *$/, '')
+            .split(MAGIC_STRING)
+            .map(&:strip)
+    end
+
+    def aggregate_commands
+      separator = "\necho #{MAGIC_STRING}\n"
+
+      commands = @prefixes.reverse.map { |ary| ary[:command] }
+      commands << "#{@command}\n#{save_exit_code}"
+      commands.concat(@postfixes.map { |ary| ary[:command] })
+
+      commands.join(separator)
+    end
+
+    def save_exit_code
+      @connection.platform.windows? ? "$#{TrainSH::EXITCODE_VAR}=$LastExitCode" : "export #{TrainSH::EXITCODE_VAR}=$?"
+    end
+  end
+
+  class Session
+    extend Forwardable
+    def_delegators :@connection, :platform, :run_command, :backend_type, :file, :upload, :download
+
+    attr_reader :connection, :backend, :host
+
+    attr_accessor :pwd, :env, :ping, :exitcode
+
+    def initialize(url = nil)
+      connect(url) unless url.nil?
+    end
+
+    def connect(url)
+      @url = url
+
+      data = Train.unpack_target_from_uri(url)
+
+      # TODO: Wire up with "messy" parameter
+      data[:cleanup] = false
+
+      backend = Train.create(data[:backend], data)
+      return false unless backend
+
+      @backend = data[:backend]
+      @host = data[:host]
+
+      @connection = backend.connection
+      connection.wait_until_ready
+
+      at_exit { disconnect }
+    end
+
+    def disconnect
+      puts "Closing session #{url}"
+
+      connection.close
+    end
+
+    def reconnect
+      disconnect
+
+      connect(url)
+    end
+
+    # Redact password information
+    def url
+      Addressable::URI.parse(@url).omit(:password).to_s
+    end
+
+    def run(command, skip_affixes: false)
+      command = Command.new(command, @connection)
+
+      # Save exit code
+      command.postfix(exitcode_get) { |output| @exitcode = output.to_i }
+
+      # Request UTF-8 instead of UTF-16
+      # command.prefix("$PSDefaultParameterValues['Out-File:Encoding'] = 'utf8'") if platform.windows?
+
+      unless skip_affixes
+        command.prefix(pwd_set)
+        command.postfix(pwd_get) { |output| @pwd = output }
+        command.prefix(env_set)
+        command.postfix(env_get) { |output| @env = output }
+      end
+
+      # Discovery tasks
+      command.prefix(host_get) { |output| @host = output } if host.nil? || host == 'unknown'
+
+      command.run
+    end
+
+    def run_idle
+      @ping = ::Benchmark.measure { run('#', skip_affixes: true) }.real * 1000
+    end
+
+    private
+
+    def exitcode_get
+      "echo $#{TrainSH::EXITCODE_VAR}"
+    end
+
+    def host_get
+      'hostname'
+    end
+
+    def pwd_get
+      platform.windows? ? '(Get-Location).Path' : 'pwd'
+    end
+
+    def pwd_set(path = pwd)
+      return '' if path.nil?
+
+      platform.windows? ? "Set-Location #{path}" : "cd #{path}"
+    end
+
+    # TODO: Preserve Windows environment variables
+    def env_get
+      platform.windows? ? '' : 'export'
+    end
+
+    # TODO: Preserve Windows environment variables
+    def env_set
+      platform.windows? ? '' : env
+    end
+  end
+end

data/lib/trainsh/version.rb

@@ -0,0 +1,3 @@
+module TrainSH
+  VERSION = '0.2.0'.freeze
+end

metadata

@@ -0,0 +1,214 @@
+--- !ruby/object:Gem::Specification
+name: trainsh
+version: !ruby/object:Gem::Version
+  version: 0.2.0
+platform: ruby
+authors:
+- Thomas Heinen
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2021-02-25 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: bump
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: bundler-audit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.7'
+- !ruby/object:Gem::Dependency
+  name: mdl
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.9'
+- !ruby/object:Gem::Dependency
+  name: overcommit
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.55'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.55'
+- !ruby/object:Gem::Dependency
+  name: rake
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '12.3'
+- !ruby/object:Gem::Dependency
+  name: rspec
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '3.10'
+- !ruby/object:Gem::Dependency
+  name: rubocop
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.92'
+  type: :development
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.92'
+- !ruby/object:Gem::Dependency
+  name: colored
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.2'
+- !ruby/object:Gem::Dependency
+  name: readline
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '0.0'
+- !ruby/object:Gem::Dependency
+  name: thor
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - "~>"
+      - !ruby/object:Gem::Version
+        version: '1.1'
+- !ruby/object:Gem::Dependency
+  name: train
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.5'
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ">="
+      - !ruby/object:Gem::Version
+        version: '3.5'
+description: Based on the Train ecosystem, provide a shell to manage systems via a
+  multitude of transports.
+email:
+- theinen@tecracer.de
+executables: []
+extensions: []
+extra_rdoc_files: []
+files:
+- CHANGELOG.md
+- README.md
+- lib/trainsh.rb
+- lib/trainsh/cli.rb
+- lib/trainsh/config.rb
+- lib/trainsh/constants.rb
+- lib/trainsh/detectors/target.rb
+- lib/trainsh/detectors/target/env.rb
+- lib/trainsh/detectors/target/kitchen.rb
+- lib/trainsh/errors.rb
+- lib/trainsh/log.rb
+- lib/trainsh/mixin/builtin_commands.rb
+- lib/trainsh/mixin/file_helpers.rb
+- lib/trainsh/mixin/sessions.rb
+- lib/trainsh/session.rb
+- lib/trainsh/version.rb
+homepage: https://github.com/tecracer-chef/trainsh
+licenses:
+- Nonstandard
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '2.6'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ">="
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubygems_version: 3.0.3
+signing_key: 
+specification_version: 4
+summary: Interactive Shell for Remote Systems
+test_files: []