easy_io 0.4.2 → 0.4.3

checksums.yaml

@@ -1,7 +1,7 @@
 ---
-SHA1:
-  metadata.gz: f4995afc12ae9df92f39bab54a14a07745c319b1
-  data.tar.gz: ee3b92492666e222aa9895eaace81c96c238acb1
+SHA256:
+  metadata.gz: 2b4ea31cfbbe102e2b9d4e14097c33da21c70e4de3b1a6b599c872503fd37741
+  data.tar.gz: d1df2063b2e92d513a37a9c14a0749c30586eb0f3fc7729100ddf7bd8add3b4b
 SHA512:
-  metadata.gz: 52189de578634351266752e2b67fa3c70ab71ff0713afa9ee9d4385fadc0542444e7d317b9ba2562e9ba583b5d0e64a32ffd4f13a6ec530e18df99a0c6789d4f
-  data.tar.gz: 5d5087dfbbc6c7e64019c38cce980d9f09011ac8fd99fbee01866c995d2b0be0626d37ecd89fbc866274209495894f65599eb41bd1cc84c0499fb704e14566b1
+  metadata.gz: 569f125fb4826b3db31d6d8e54e9e19ca8ab3d493a02d937197be114896ebb15314ef5e10a9459b0492dac904be8f2d45679d28eceae0df25482d38f584b5020
+  data.tar.gz: 8f5b5e0d8e5e28140c32a1f268cc3b8db9364fb51c33d90ed40ef2c54606967f15c55c037c1eb9fb9827c98cebce1ffd83ea0c3c55416bbfd6cce7c040e39ca3

data/lib/easy_io/disk.rb

@@ -70,7 +70,7 @@ module EasyIO
           end
           lock_success = file.flock(File::LOCK_EX | File::LOCK_NB)
           if lock_success
-            yield(file)
+            yield(file) if block_given?
             file.close
             break
           end
@@ -80,5 +80,34 @@ module EasyIO
         end
       end
     end
+
+    # When credentials are nil, the current user will be used
+    def cross_domain_copy(source_folder, destination_folder, source_credentials: nil, destination_credentials: nil, file_filter: '*')
+      # require 'win32/process'
+      Dir.glob("#{source_folder}/#{file_filter}").each do |source_entry|
+        destination_entry = source_entry.sub(source_folder, destination_folder)
+        _cross_domain_entry_copy(source_entry, destination_entry, source_credentials: source_credentials, destination_credentials: destination_credentials)
+      end
+    end
+
+    def _cross_domain_entry_copy(source_entry, destination_entry, source_credentials: nil, destination_credentials: nil)
+      source_credentials ||= :current_user
+      destination_credentials ||= :current_user
+
+      # TODO: loop and read to async buffer and write as it goes
+      if source_credentials == :current_user
+        # TODO: read to memeory
+      else
+        Process.create(command_line: ?, domain: source_credentials['domain'], with_logon: source_credentials['user_name'], password: source_credentials['password'])
+        # TODO: read to memory
+      end
+
+      if destination_credentials == :current_user
+        # TODO: write from memory
+      else
+        Process.create(etc)
+        # TODO: write from memory
+      end
+    end
   end
 end

data/lib/easy_io/run.rb

@@ -4,6 +4,7 @@ module EasyIO
   # execute a command with real-time output. Any stdout you want returned to the caller must come after the :output_separator which defaults to '#return_data#:'
   #   return_all_stdout: return all output to the caller instead after process completion
   def execute_out(command, pid_logfile: nil, working_folder: Dir.pwd, regex_error_filters: [], info_on_exception: '', exception_exceptions: [], powershell: false, show_command_on_error: false, raise_on_first_error: true, return_all_stdout: false, output_separator: nil)
+    raise "Invalid argument to execute_out! working_folder (#{working_folder}) is not a valid directory!" unless ::File.directory?(working_folder)
     output_separator ||= '#return_data#:'
     if return_all_stdout
       result = ''
@@ -22,6 +23,7 @@ module EasyIO
       FileUtils.mkdir_p(::File.dirname(ps_script_file)) unless ::File.directory? ::File.dirname(ps_script_file)
       ::File.write(ps_script_file, command)
     end
+
     popen_arguments = powershell ? ['powershell.exe', ps_script_file] : [command]
     Open3.popen3(*popen_arguments, chdir: working_folder) do |_stdin, stdout, stderr, wait_thread|
       unless pid_logfile.nil? # Log pid in case job or script dies
@@ -75,7 +77,7 @@ module EasyIO
     execute_out(ps_script, pid_logfile: pid_logfile, working_folder: working_folder, regex_error_filters: regex_error_filters, info_on_exception: info_on_exception, exception_exceptions: exception_exceptions, powershell: true, show_command_on_error: show_command_on_error, return_all_stdout: return_all_stdout, output_separator: output_separator)
   end
 
-  def run_remote_powershell_command(remote_host, command, credentials, set_as_trusted_host: false)
+  def run_remote_winrm_command(remote_host, command, credentials, set_as_trusted_host: false)
     add_as_winrm_trusted_host(remote_host) if set_as_trusted_host
 
     remote_command = <<-EOS
@@ -96,9 +98,76 @@ module EasyIO
     }
   end
 
-  def run_command_on_remote_hosts(remote_hosts, command, credentials, command_message: nil, shell_type: :cmd, tail_count: nil, set_as_trusted_host: false)
+  def run_remote_powershell_command(remote_host, command, credentials, set_as_trusted_host: false, transport: :ssh, output_stream: nil, output_file: nil, output_to_terminal: false)
+    return run_remote_winrm_command(remote_host, command, credentials, set_as_trusted_host: set_as_trusted_host) if transport == :winrm
+    command = 'powershell.exe ' unless command =~ /powershell/i
+    run_remote_command(remote_host, command, credentials, output_stream: output_stream, output_file: output_file, output_to_terminal: output_to_terminal)
+  end
+
+  def run_remote_command(remote_host, command, credentials, ssh_key: nil, output_stream: nil, output_file: nil, output_to_terminal: false, show_command_on_error: false)
+    require 'net/ssh'
+    start_params = if credentials['password'].nil?
+                     {
+                       host_key: 'ssh-rsa',
+                       keys: [ssh_key],
+                       verify_host_key: false,
+                     }
+                   else
+                     {
+                       password: credentials['password'],
+                     }
+                   end
+
+    retries ||= 3
+    return_code = nil
+    keep_stream_open = !output_stream.nil? # Leave the stream open if it was passed in
+    output_stream ||= ::File.open(output_file, ::File::RDWR | ::File::CREAT) unless output_file.nil?
+    stdout = ''
+
+    Net::SSH.start(remote_host, credentials['user'], **start_params) do |ssh|
+      command_thread = ssh.open_channel do |channel|
+        channel.exec(command) do |ch, success|
+          raise 'could not execute command' unless success
+
+          ch.on_data { |_c, data| stdout += data; process_command_output(data, output_stream, output_to_terminal) }
+          ch.on_extended_data { |_c, _type, data| stdout += data; process_command_output(data, output_stream, output_to_terminal) }
+          ch.on_request('exit-status') { |_ch, data| return_code = data.read_long }
+        end
+      end
+      command_thread.wait
+    end
+    {
+      'stdout' => stdout,
+      'exitcode' => return_code,
+    }
+  rescue Net::SSH::ConnectionTimeout => ex
+    EasyIO.logger.info 'Net::SSH::ConnectionTimeout - retrying...'
+    retry if (retries -= 1) >= 0
+    {
+      'exception' => ex,
+      'stderr' => (show_command_on_error ? "command: #{command}\n\n#{ex.message}" : ex.message) + "\n\n#{ex.backtrace}",
+      'exitcode' => return_code,
+    }
+  rescue => ex
+    {
+      'exception' => ex,
+      'stderr' => (show_command_on_error ? "command: #{command}\n\n#{ex.message}" : ex.message) + "\n\n#{ex.backtrace}",
+      'exitcode' => return_code,
+    }
+  ensure
+    output_stream.close unless keep_stream_open || !output_stream.respond_to?(:close)
+  end
+
+  def process_command_output(data, output_stream, output_to_terminal)
+    output_stream << data if output_stream
+    EasyIO.logger.info data if output_to_terminal
+  end
+
+  def run_command_on_remote_hosts(remote_hosts, command, credentials, command_message: nil, shell_type: nil, tail_count: nil, set_as_trusted_host: false, transport: :ssh)
     tail_count ||= 1 # Return the last (1) line from each remote_host's log to the console
-    supported_shell_types = [:cmd, :powershell] # TODO: implement shell_type :bash
+    shell_type ||= OS.windows? ? :cmd : :bash
+    shell_type = shell_type.to_sym unless shell_type.is_a?(Symbol)
+    supported_shell_types = OS.windows? ? [:cmd, :powershell] : [:bash]
     raise "Unsupported shell_type for running remote commands: '#{shell_type}'" unless supported_shell_types.include?(shell_type)
 
     threads = {}
@@ -108,20 +177,28 @@ module EasyIO
     EasyIO.logger.info "Output logs of processes run on the specified remote hosts will be placed in #{log_folder}..."
     remote_hosts.each do |remote_host|
       EasyIO.logger.info "Running `#{command_message || command}` on #{remote_host}..."
-      # threads_output[remote_host] = run_remote_powershell_command(remote_host, command, credentials, set_as_trusted_host: set_as_trusted_host)
       threads[remote_host] = Thread.new do
-        threads_output[remote_host] = run_remote_powershell_command(remote_host, command, credentials, set_as_trusted_host: set_as_trusted_host)
+        case shell_type
+        when :powershell
+          threads_output[remote_host] = run_remote_powershell_command(remote_host, command, credentials, set_as_trusted_host: set_as_trusted_host, transport: transport)
+        when :cmd, :bash
+          threads_output[remote_host] = run_remote_command(remote_host, command, credentials)
+        end
       end
     end
     threads.values.each(&:join) # Wait for all commands to complete
-    # threads.each { |remote_host, thread| pp thread }
+    exceptions = []
     threads_output.each do |remote_host, output|
       ::File.write("#{log_folder}/#{EasyFormat::File.windows_friendly_name(remote_host)}.#{::Time.now.strftime('%Y%m%d_%H%M%S')}.log", "#{output['stdout']}\n#{output['stderr']}")
       tail_output = output['stdout'].nil? ? '--no standard output--' : output['stdout'].split("\n").last(tail_count).join("\n")
       EasyIO.logger.info "[#{remote_host}]: #{tail_output}"
-      raise "Failed to run command on #{remote_host}: #{output['stderr']}\n#{output['exception'].cause}\n#{output['exception'].message}" if output['exception']
-      raise "The script exited with exit code #{output['exitcode']}.\n\n#{output['stderr']}" unless output['exitcode'] == 0
+      if output['exception']
+        exceptions.push "Failed to run command on #{remote_host}: #{output['stderr']}\n#{output['exception'].cause}\n#{output['exception'].message}"
+        next
+      end
+      exceptions.push "The script exited with exit code #{output['exitcode']}.\n\n#{output['stderr']}" unless output['exitcode'] == 0
     end
+    raise exceptions.join("\n\n") unless exceptions.empty?
   end
 
   def add_as_winrm_trusted_host(remote_host)

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: easy_io
 version: !ruby/object:Gem::Version
-  version: 0.4.2
+  version: 0.4.3
 platform: ruby
 authors:
 - Alex Munoz
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2020-05-27 00:00:00.000000000 Z
+date: 2021-07-26 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: easy_format
@@ -100,8 +100,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubyforge_project: 
-rubygems_version: 2.5.2.3
+rubygems_version: 3.0.3
 signing_key: 
 specification_version: 4
 summary: Ruby library for ease of running commands with realtime output and return