raykit 0.0.302 → 0.0.306

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1e31c9155319544ec3235de4545a56cb22d31fdaa4bd7dd29ce886b5aa9abba4
-  data.tar.gz: 72c06e1332d3b1c261a0668a76b2d6708da83352f77872b69ddb1d4f007c75d3
+  metadata.gz: ee9ddaa4700fb58d7f4819286b17752c1313498a9e3d159c59f75ec424be92fe
+  data.tar.gz: 2ebd78110747cbccdbca74111dc9eb95c6e560ebdb3270ca08775641c3632210
 SHA512:
-  metadata.gz: adb8ce5adeeea98305c56a232983a503a9ba2a1a0e8e473a48b4b2a8598b75cf9989d5a86a33242a2f139ffaa41dcb22f053f7b94b5d40bd1d64a7d0713c1b6c
-  data.tar.gz: abefe06850b65f1968e4f5023747b3cd807c68644f8e21df2aaa4ae1122048352dc348cec6454f71a7d38faba41b5c55257ff31675ebaf38f2b997a74e4746ab
+  metadata.gz: feebb5d35660642dc0523065b96e0763dc77b1c3c43d8a35cdf1883cf5dfb8c691eb547c095d926ebe7c9d0de8bbb4a458e5ddd6becc7ee5e7d5156d3b901e62
+  data.tar.gz: a5c0a6ad0539af06cfd5b224623053804ff7780e60e78ab5256bb554aa3628716dd1050d014acfa3a3a3bc459245c3663fe6ba2507ca4207d1ef4b50bf20b621

data/bin/raykit

@@ -1,4 +1,6 @@
 #!/usr/bin/env ruby
-require_relative '../lib/raykit.rb'
+# frozen_string_literal: true
+
+require_relative '../lib/raykit'
 console = Raykit::Console.new
-console.run
+console.run

data/lib/raykit/command.rb

@@ -1,263 +1,262 @@
-require 'open3'
-require 'timeout'
-require 'json'
-require 'yaml'
-require 'logger'
-require 'securerandom'
+# frozen_string_literal: true
 
-BUFFER_SIZE=1024 if(!defined?(BUFFER_SIZE))
-module Raykit
-    # Functionality to support executing and logging system commands
-    class Command
-        @@commands=Array.new
-        # The timeout in seconds, defaults to 0 if not specified
-        attr_accessor :timeout
-        # The working directory, defaults the current directory if not specified
-        attr_accessor :directory
-        # The start time
-        attr_accessor :start_time
-        # The execution time in seconds
-        attr_accessor :elapsed
-        attr_accessor :command,:output,:error,:exitstatus
-        attr_accessor :user,:machine
-        attr_accessor :logging_enabled
-        attr_accessor :success_log_level
+require "open3"
+require "timeout"
+require "json"
+require "yaml"
+require "logger"
+require "securerandom"
 
-        def init_defaults 
-            @timeout=0
-            @directory = Dir.pwd
-            @output = ''
-            @error = ''
-            @exitstatus = 0
-            @user = Environment.user
-            @machine=Environment.machine
-            @logging_enabled = true
-        end
+BUFFER_SIZE = 1024 unless defined?(BUFFER_SIZE)
 
-        def initialize(command,timeout=0,success_log_level=Logger::DEBUG,logging_enabled=true)
-            @@commands=Array.new
-            init_defaults
-            @success_log_level=success_log_level
-            @logging_enabled=logging_enabled
-            @command=command
-            @timeout=timeout
-            if(@command.length > 0)
-                run
-            end
-            self
-        end
+module Raykit
+  # Functionality to support executing and logging system commands
+  class Command
+    @@commands = []
+    # The timeout in seconds, defaults to 0 if not specified
+    attr_accessor :timeout
+    # The working directory, defaults the current directory if not specified
+    attr_accessor :directory
+    # The start time
+    attr_accessor :start_time
+    # The execution time in seconds
+    attr_accessor :elapsed
+    attr_accessor :command, :output, :error, :exitstatus, :user, :machine, :logging_enabled, :success_log_level
 
-        def run() 
-            @start_time = Time.now
-            timer = Timer.new
-            if(@timeout == 0)
-                @output,@error,process_status = Open3.capture3(@command) 
-                @exitstatus=process_status.exitstatus
-            else
-                Open3.popen3(@command, :chdir=>@directory) { |stdin,stdout,stderr,thread|
-                    tick=2
-                    pid = thread.pid
-                    start = Time.now
-                    elapsed = Time.now-start
-                    while ((elapsed) < @timeout) and thread.alive?
-                        Kernel.select([stdout,stderr], nil, nil, tick)
-                        begin
-                            @output << stdout.read_nonblock(BUFFER_SIZE)
-                            @error << stderr.read_nonblock(BUFFER_SIZE)
-                        rescue IO::WaitReadable
-                        rescue EOFError
-                            @exitstatus=thread.value.exitstatus
-                            break
-                        end
-                        elapsed = Time.now-start
-                    end
-                    if thread.alive?
-                        if(Gem.win_platform?)
-                            `taskkill /f /pid #{pid}`
-                        else
-                            Process.kill("TERM", pid)
-                        end
-                        @exitstatus=5
-                        @error="timed out"
-                    else
-                        @exitstatus=thread.value.exitstatus
-                    end
-                  }
-            end
-            @elapsed = timer.elapsed
-            if @logging_enabled
-                log
-                if @exitstatus != 0 
-                    to_log_event.to_seq
-                else
-                    if !@success_log_level.nil?
-                        e = to_log_event
-                        e["Level"] = "Verbose" if @success_log_level == "Verbose"
-                        e["Level"]= "Debug" if @success_log_level == Logger::DEBUG
-                        e["Level"] = "Information" if @success_log_level == Logger::INFO
-                        e["Level"] = "Warning" if @elapsed > 60*2
-                        e.to_seq
-                    end
-                end
-            end
-        end
+    def init_defaults
+      @timeout = 0
+      @directory = Dir.pwd
+      @output = ""
+      @error = ""
+      @exitstatus = 0
+      @user = Environment.user
+      @machine = Environment.machine
+      @logging_enabled = true
+    end
 
-        def to_log_event
-            secrets=Secrets.new()
-            msg =secrets.hide(@command)
-            level="Verbose"
-            level="Warning" if @exitstatus != 0
-            output=@output
-            error=@error
-            output = @output.last(1000) if(@output.length > 1200)
-            error = @error.last(1000) if(@output.length > 1200)
-            Raykit::LogEvent.new(level,msg,{
-                "SourceContext"=>"Raykit::Command",
-                "Category"=>"Command",
-                "Timeout"=>@timeout,
-                "Directory"=>@directory,
-                "Output"=>@output,
-                "Error"=>@error,
-                "ExitStatus"=>@exitstatus,
-                "Elapsed"=>elapsed_str,
-                "ElapsedSeconds"=>@elapsed
-            })
-        end
+    def initialize(command, timeout = 0, success_log_level = Logger::DEBUG, logging_enabled = true)
+      @@commands = []
+      init_defaults
+      @success_log_level = success_log_level
+      @logging_enabled = logging_enabled
+      @command = command
+      @timeout = timeout
+      run if @command.length.positive?
+      self
+    end
 
-        def log
-            # --- Rolling File JSON -----
-            log = Logger.new("#{Raykit::Environment::log_dir}/Raykit.Commands.txt",'daily')
-            log.formatter = proc do |severity,datetime,progname,msg|
-                "#{msg}\n"
-            end
-            secrets=Secrets.new()
-            msg =secrets.hide(@command)#"?"# self.summary(false)
-            level="Verbose"
-            level="Warning" if @exitstatus != 0
-            event = Raykit::LogEvent.new(level,msg,{ 
-                "Timeout"=>@timeout,
-                "Directory"=>@directory,
-                "Output"=>@output,
-                "Error"=>@error,
-                "ExitStatus"=>@exitstatus,
-                "Elapsed"=>elapsed_str})
-            log.info event.to_json
-            # ---------------------------
+    def run
+      # puts '---running---'
+      @start_time = Time.now
+      timer = Timer.new
+      if @timeout.zero?
+        @output, @error, process_status = Open3.capture3(@command)
+        @exitstatus = process_status.exitstatus
+      else
+        Open3.popen3(@command, chdir: @directory) do |_stdin, stdout, stderr, thread|
+          tick = 2
+          pid = thread.pid
+          start = Time.now
+          elapsed = Time.now - start
+          while ((elapsed) < @timeout) && thread.alive?
+            Kernel.select([stdout, stderr], nil, nil, tick)
             begin
-                json=JSON.generate(to_hash)
-                log_filename = Environment.get_dev_dir('log') + '/Raykit.Command/' + SecureRandom.uuid + '.json'
-                log_dir = File.dirname(log_filename)
-                FileUtils.mkdir_p(log_dir) if(!Dir.exist?(log_dir))
-                File.open(log_filename, 'w') {|f| f.write(json) }
-                if(@exitstatus == 0)
-                    LOG.log('Raykit.Command',Logger::Severity::INFO,json)
-                else
-                    LOG.log('Raykit.Command',Logger::Severity::ERROR,json)
-                end
-            rescue JSON::GeneratorError => ge
-                puts to_hash.to_s
-                puts ge.to_s
-                json=JSON.generate(to_hash)
+              @output << stdout.read_nonblock(BUFFER_SIZE)
+              @error << stderr.read_nonblock(BUFFER_SIZE)
+            rescue IO::WaitReadable
+            rescue EOFError
+              @exitstatus = thread.value.exitstatus
+              break
             end
-        end
-
-        def elapsed_str()
-            if(elapsed < 1.0)
-                "%.0f" % (elapsed) + "s"
+            elapsed = Time.now - start
+          end
+          if thread.alive?
+            if Gem.win_platform?
+              `taskkill /f /pid #{pid}`
             else
-                "%.0f" % (elapsed) + "s"
+              Process.kill("TERM", pid)
             end
+            @exitstatus = 5
+            @error = "timed out"
+          else
+            @exitstatus = thread.value.exitstatus
+          end
         end
-
-        def summary(show_directory=false)
-            checkmark="\u2713"
-            #warning="\u26A0"
-            error="\u0058"
-            symbol=Rainbow(checkmark.encode('utf-8')).green
-            symbol=Rainbow(error.encode('utf-8')).red if(@exitstatus!=0)
-            if(show_directory)
-                puts symbol + "  " + elapsed_str.rjust(4) + " " + Rainbow(SECRETS.hide(@command)).yellow + " (#{@directory})"
-            else
-                puts symbol + "  " + elapsed_str.rjust(4) + " " + Rainbow(SECRETS.hide(@command)).yellow# + " (#{@directory})"
-            end
-            #puts symbol + "  " + elapsed_str.rjust(4) + " " + Rainbow(SECRETS.hide(@command)).yellow# + " (#{@directory})"
+      end
+      @elapsed = timer.elapsed
+      if @logging_enabled
+        log
+        if @exitstatus != 0
+          to_log_event.to_seq
+        else
+          # puts '---logging---'
+          unless @success_log_level.nil?
+            e = to_log_event
+            e["Level"] = "Verbose" if @success_log_level == "Verbose"
+            e["Level"] = "Debug" if @success_log_level == Logger::DEBUG
+            e["Level"] = "Information" if @success_log_level == Logger::INFO
+            e["Level"] = "Warning" if @elapsed > 60 * 2
+            e.to_seq
+          end
         end
+      end
+    end
 
-        def details
-            #summary
-            puts @output
-            puts @error
-            puts 
+    def to_log_event
+      secrets = Secrets.new
+      msg = secrets.hide(@command)
+      level = "Verbose"
+      level = "Warning" if @exitstatus != 0
+      output = @output
+      error = @error
+      output = @output[-1000..-1] if @output.length > 1200
+      error = @error[-1000..-1] if @error.length > 1200
+      Raykit::LogEvent.new(level, msg, {
+        "SourceContext" => "Raykit::Command",
+        "Category" => "Command",
+        "Timeout" => @timeout,
+        "Directory" => @directory,
+        "Output" => output,
+        "Error" => error,
+        "ExitStatus" => @exitstatus,
+        "Elapsed" => elapsed_str,
+        "ElapsedSeconds" => @elapsed,
+      })
+    end
+
+    def log
+      # --- Rolling File JSON -----
+      log = Logger.new("#{Raykit::Environment.log_dir}/Raykit.Commands.txt", "daily")
+      log.formatter = proc do |_severity, _datetime, _progname, msg|
+        "#{msg}\n"
+      end
+      secrets = Secrets.new
+      msg = secrets.hide(@command) # "?"# self.summary(false)
+      level = "Verbose"
+      level = "Warning" if @exitstatus != 0
+      event = Raykit::LogEvent.new(level, msg, {
+        "Timeout" => @timeout,
+        "Directory" => @directory,
+        "Output" => @output,
+        "Error" => @error,
+        "ExitStatus" => @exitstatus,
+        "Elapsed" => elapsed_str,
+      })
+      log.info event.to_json
+      # ---------------------------
+      begin
+        json = JSON.generate(to_hash)
+        log_filename = "#{Environment.get_dev_dir("log")}/Raykit.Command/#{SecureRandom.uuid}.json"
+        log_dir = File.dirname(log_filename)
+        FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
+        File.open(log_filename, "w") { |f| f.write(json) }
+        if @exitstatus.zero?
+          LOG.log("Raykit.Command", Logger::Severity::INFO, json)
+        else
+          LOG.log("Raykit.Command", Logger::Severity::ERROR, json)
         end
+      rescue JSON::GeneratorError => e
+        puts to_hash.to_s
+        puts e.to_s
+        json = JSON.generate(to_hash)
+      end
+    end
 
-        def save()
-            filename = Environment.get_dev_dir('log') + '/Commands/' + SecureRandom.uuid
-            log_dir=File.dirname(filename)
-            FileUtils.mkdir_p(log_dir) if(!Dir.exist?(log_dir))
+    def elapsed_str
+      if elapsed < 1.0
+      end
+      "#{format("%.0f", elapsed)}s"
+    end
 
-            File.open(filename,'w'){|f|
-                f.write(JSON.pretty_generate(self.to_hash))
-            }
-            self
-        end
+    def summary(show_directory = false)
+      checkmark = "\u2713"
+      # warning="\u26A0"
+      error = "\u0058"
+      symbol = Rainbow(checkmark.encode("utf-8")).green
+      symbol = Rainbow(error.encode("utf-8")).red if @exitstatus != 0
+      if show_directory
+        puts "#{symbol}  #{elapsed_str.rjust(4)} #{Rainbow(SECRETS.hide(@command)).yellow} (#{@directory})"
+      else
+        puts "#{symbol}  #{elapsed_str.rjust(4)} #{Rainbow(SECRETS.hide(@command)).yellow}" # + " (#{@directory})"
+      end
+      # puts symbol + "  " + elapsed_str.rjust(4) + " " + Rainbow(SECRETS.hide(@command)).yellow# + " (#{@directory})"
+    end
 
-        def to_hash()
-            hash = Hash.new
-            hash[:command] = @command
-            hash[:directory] = @directory
-            hash[:timeout] = @timeout
-            hash[:start_time] = @start_time
-            hash[:elapsed] = @elapsed
-            hash[:output] = @output.force_encoding("ISO-8859-1").encode("UTF-8")
-            hash[:error] = @error.force_encoding("ISO-8859-1").encode("UTF-8")
-            hash[:exitstatus] = @exitstatus
-            hash[:user] = @user
-            hash[:machine] = @machine
-            hash[:context] = "Raykit.Command"
-            hash
-        end
+    def details
+      # summary
+      puts @output
+      puts @error
+      puts
+    end
 
-        def from_hash(hash)
-            @command = hash["command"]
-            @directory=hash["directory"]
-            @timeout=hash["timeout"]
-            @start_time=hash["start_time"]
-            @elapsed=hash["elapsed"]
-            @output=hash["output"]
-            @error=hash["error"]
-            @exitstatus=hash["exitstatus"]
-            @user=hash["user"] if(hash.include?("user"))
-            @machine=hash["machine"] if(hash.include?("machine"))
-        end
+    def save
+      filename = "#{Environment.get_dev_dir("log")}/Commands/#{SecureRandom.uuid}"
+      log_dir = File.dirname(filename)
+      FileUtils.mkdir_p(log_dir) unless Dir.exist?(log_dir)
 
-        def self.parse(json)
-            cmd=Command.new('')
-            cmd.from_hash(JSON.parse(json))
-            cmd
-        end
+      File.open(filename, "w") do |f|
+        f.write(JSON.pretty_generate(to_hash))
+      end
+      self
+    end
 
-        def self.parse_yaml_commands(yaml)
-            #commands=Array.new()
-            data = YAML.load(yaml)
-            commands = get_script_commands(data)
+    def to_hash
+      hash = {}
+      hash[:command] = @command
+      hash[:directory] = @directory
+      hash[:timeout] = @timeout
+      hash[:start_time] = @start_time
+      hash[:elapsed] = @elapsed
+      hash[:output] = @output.force_encoding("ISO-8859-1").encode("UTF-8")
+      hash[:error] = @error.force_encoding("ISO-8859-1").encode("UTF-8")
+      hash[:exitstatus] = @exitstatus
+      hash[:user] = @user
+      hash[:machine] = @machine
+      hash[:context] = "Raykit.Command"
+      hash
+    end
+
+    def from_hash(hash)
+      @command = hash["command"]
+      @directory = hash["directory"]
+      @timeout = hash["timeout"]
+      @start_time = hash["start_time"]
+      @elapsed = hash["elapsed"]
+      @output = hash["output"]
+      @error = hash["error"]
+      @exitstatus = hash["exitstatus"]
+      @user = hash["user"] if hash.include?("user")
+      @machine = hash["machine"] if hash.include?("machine")
+    end
+
+    def self.parse(json)
+      cmd = Command.new("")
+      cmd.from_hash(JSON.parse(json))
+      cmd
+    end
+
+    def self.parse_yaml_commands(yaml)
+      # commands=Array.new()
+      data = YAML.safe_load(yaml)
+      commands = get_script_commands(data)
+    end
+
+    def self.get_script_commands(hash)
+      commands = []
+      if hash.key?("script")
+        hash["script"].each do |cmd|
+          commands << cmd
         end
+      end
+      hash.each do |_k, v|
+        next unless v.is_a?(Hash)
 
-        def self.get_script_commands(hash)
-            commands=Array.new
-            if(hash.key?('script'))
-                hash['script'].each{|cmd|
-                    commands << cmd
-                }
-            end
-            hash.each{|k,v|
-                if(v.is_a?(Hash))
-                    subcommands=get_script_commands(v)
-                    subcommands.each{|c|
-                        commands << c
-                    }
-                end
-            }
-            commands
+        subcommands = get_script_commands(v)
+        subcommands.each do |c|
+          commands << c
         end
+      end
+      commands
     end
-end
+  end
+end