mybot 0.1.1 → 0.2.0

data/lib/mybot/fmt.rb

@@ -2,174 +2,51 @@ require "colored"
 
 module Mybot
   module Fmt
-    def info(msg)
-      info_format = "INFO"
-      info_format = info_format.blue.bold if $USE_COLOR
-      puts "#{info_format} #{msg}"
-    end
+    WIDTH = 10
 
-    def warning(msg)
-      warning_format = "WARNING"
-      warning_format = warning_format.magenta.bold if $USE_COLOR
-      puts "#{warning_format} #{msg}"
+    def print_cmd(type, msg, *colors)
+      if $MYBOT_SHOW_CMD
+        $stdout.print "#{spaces(type)}#{colored(type, *colors)} #{msg.to_s}"
+      end
     end
 
-    def error(msg)
-      error_format = "ERROR"
-      error_format = error_format.red.bold if $USE_COLOR
-      puts "#{error_format} #{msg}"
-      abort
+    def print_cmd!(type, msg, *colors)
+      print_cmd type, "#{msg}\n", *colors
     end
 
-    def task_info(task)
-      task_format = "TASK"
-      task_format = task_format.green.bold if $USE_COLOR
-      puts "#{task_format} #{task}"
+    def print_stdout(data, force = false)
+      $stdout.print colored(data, :green) if $MYBOT_SHOW_OUTPUT || force
     end
 
-    def run_info(cmd, options = {})
-      return unless $SHOW_CMD
-
-      primary_cmd "RUN", cmd, options
-      secondary_cmd "SUDO" if options[:sudo]
-      secondary_cmd "CWD", options[:cwd] if options[:cwd] != ""
-
-      unless options[:env].empty?
-        secondary_cmd "ENV"
-        kv_cmd options[:env]
-      end
+    def print_stderr(data, force = false)
+      $stdout.print colored(data, :red) if $MYBOT_SHOW_OUTPUT || force
     end
 
-    def handle_info(s, options = {})
-      if $USE_COLOR
-        s = s.green if options[:type] == :stdout
-        s = s.red if options[:type] == :stderr
+    def print_progress(n)
+      if $MYBOT_SHOW_CMD
+        cmd = colored "progress", :blue, :bold
+        $stdout.print "\r#{spaces('progress')}#{cmd} #{n}%"
+        puts if n == 100
       end
-
-      secondary_cmd "HANDLE", s
     end
-
-    def write_info(data, options = {})
-      return unless $SHOW_CMD
-
-      lf_format = "<LF>"
-      lf_format = lf_format.bold if $USE_COLOR
-
-      if options[:shadow]
-        data = "*" * data.size
-      end
-
-      secondary_cmd "WRITE", "#{data}#{lf_format}"
-    end
-
-    def status_info(result)
-      return unless $SHOW_CMD
-
-      value_format = "#{result[:exit_status]}"
-
-      if $USE_COLOR
-        if result[:exit_status] == 0
-          value_format = value_format.green.bold
-        else
-          value_format = value_format.red.bold
+    
+    def colored(str, *colors)
+      if $MYBOT_USE_COLORS
+        colors.each do |c|
+          str = str.send(c)
         end
-      end
-
-      secondary_cmd "EXIT", value_format
-      time_info result[:time]
-
-      if result[:exit_status] != 0
-        stdout(result[:stdout])
-        stderr(result[:stderr])
+        str
+      else
+        str
       end
     end
 
-    def stdout(data)
-      return if $LIVE_STDOUT || data.empty?
-
-      stdout_data_format = data.split("\r\n").join("\n")
-      stdout_data_format = stdout_data_format.green if $USE_COLOR
-
-      secondary_cmd "STDOUT"
-      puts stdout_data_format
+    def spaces(str)
+      " " * (WIDTH - str.size)
     end
 
-    def stderr(data)
-      return if $LIVE_STDERR || data.empty?
-
-      stderr_data_format = data
-      stderr_data_format = stderr_data_format.red if $USE_COLOR
-
-      secondary_cmd "STDERR"
-      puts stderr_data_format
-    end
-
-    def stdout_live(data)
-      return unless $LIVE_STDOUT
-
-      stdout_data_format = data
-      stdout_data_format = stdout_data_format.green if $USE_COLOR
-
-      $stdout.print stdout_data_format
-    end
-
-    def stderr_live(data)
-      return unless $LIVE_STDERR
-
-      stderr_data_format = data
-      stderr_data_format = stderr_data_format.red if $USE_COLOR
-
-      $stdout.print stderr_data_format
-    end
-
-    def upload_info(options)
-      return unless $SHOW_CMD
-
-      primary_cmd "UPLOAD", options[:file], options
-      secondary_cmd "TO", options[:to]
-    end
-
-    def download_info(options)
-      return unless $SHOW_CMD
-
-      primary_cmd "DOWNLOAD", options[:file], options
-      secondary_cmd "TO", options[:to]
-    end
-
-    def prompt(user, host)
-      prompt_format = "[#{user}@#{host}]"
-      prompt_format = prompt_format.white if $USE_COLOR
-    end
-
-    def progress(n)
-      return unless $SHOW_CMD
-
-      progress_format = "PROGRESS"
-      progress_format = progress_format.blue.bold if $USE_COLOR
-
-      $stdout.print "\r  #{progress_format} #{n}%"
-      puts if n == 100
-    end
-
-    def time_info(time)
-      secondary_cmd "TIME", "#{time}s"
-    end
-
-    def primary_cmd(name, value, options = {})
-      name = name.bold if $USE_COLOR
-      prompt_format = prompt(options[:user], options[:host])
-      puts "#{prompt_format} #{name} #{value}"
-    end
-
-    def secondary_cmd(name, value = "")
-      name = name.blue.bold if $USE_COLOR
-      puts "  #{name} #{value}"
-    end
-
-    def kv_cmd(options)
-      options.each do |k, v|
-        puts "    #{k}: #{v}"
-      end
+    def asterisks(str)
+      "*" * str.size
     end
   end
 end

data/lib/mybot/helpers.rb

@@ -1,24 +1,26 @@
 module Mybot
-	module Helpers
-		def wait
-      $stdout.print "Press any key to continue..."
+  module Helpers
+    include Fmt
+
+    def wait(msg = "Press any key to continue...")
+      print_cmd "wait", msg, :blue, :bold
       $stdin.gets
     end
 
     def ask(q = "")
-      $stdout.print "#{q}"
+      print_cmd "ask", q, :blue, :bold
       $stdin.gets.chomp
     end
 
     def yes?(q = "")
       result = ""
       loop do
-        $stdout.print "#{q}"
+        print_cmd "ask", q, :blue, :bold
         result = $stdin.gets.chomp
         break if result =~ /y|yes|Y|YES|Yes|n|no|N|NO|No/
       end
 
       result =~ /y|yes|Y|YES|Yes/
     end
-	end
+  end
 end

data/lib/mybot/node.rb

@@ -5,158 +5,113 @@ module Mybot
   class Node
     include Fmt
 
-    attr_accessor :host, :user, :options
-
     def initialize(host, user, options = {})
       @host, @user, @options = host, user, options
     end
 
-    def ssh
-      @ssh ||= Net::SSH.start @host, @user, @options
-    end
-
-    def sftp
-      @sftp ||= Net::SFTP.start @host, @user, @options
-    end
-
-    def run(cmd, options = {}, &block)
-      error "cmd cannot be empty" if cmd == ""
-
-      start_time = Time.now
-      options[:sudo] ||= false
-      options[:cwd] ||= ""
-      options[:env] ||= {}
-
+    def run(cmd, options = {})
       command = Command.new
       yield command if block_given?
 
-      ssh.open_channel do |ch, ok|
+      ssh.open_channel do |ch|
         ch.request_pty do |ch, ok|
-          error "cannot request pty" unless ok
+          abort "cannot request pty" unless ok
         end
 
         command.channel = ch
 
-        run_info cmd, {
-          :host => @host,
-          :user => @user,
-          :sudo => options[:sudo],
-          :cwd => options[:cwd],
-          :env => options[:env]
-        }
-
-        if options[:sudo]
-          cmd = "sudo #{cmd}"
-          handle_sudo(command)
-        end
+        options[:env] ||= {}
+        options[:sudo] ||= false
+        options[:cwd] ||= ""
 
         unless options[:env].empty?
-          values = options[:env].map { |k, v| "#{k}=#{v}" }.join " "
+          values = options[:env].map { |k, v| "#{k}='#{v}'" }.join " "
           cmd = "#{values} #{cmd}"
         end
 
+        if options[:sudo]
+          cmd = "sudo #{cmd}"
+        end
+
         if options[:cwd] != ""
           cmd = "cd #{options[:cwd]} && #{cmd}"
         end
 
+        print_cmd! "run", cmd, :green, :bold
+
         ch.exec cmd do |ch, ok|
-          error "cannot exec '#{cmd}'" unless ok
+          abort "cannot exec command" unless ok
 
           ch.on_data do |ch, data|
             command.handle_stdout data
           end
 
-          ch.on_extended_data do |ch, data|
-            command.handle_stderr data
+          ch.on_extended_data do |ch, type, data|
+            command.handle_stderr data if type == 1
           end
 
           ch.on_request("exit-status") do |ch, data|
-            command.exit_status = data.read_long
+            command.exit = data.read_long
           end
 
           ch.on_close do |ch|
-            command.time = Time.now - start_time
             command.handle_close
           end
         end
       end
 
       ssh.loop
-
       return command.result
     end
 
-    def upload(file, options = {})
-      error "file '#{file}' does not exists" unless File.exists?(file)
-      error "to is required" unless options[:to]
-
-      start_time = Time.now
-      upload_info({
-        :host => @host,
-        :user => @user,
-        :file => file,
-        :to => options[:to]
-      })
+    def exists?(file)
+      sftp.stat!(file) do |resp|
+        return resp.ok?
+      end
+    rescue Net::SFTP::StatusException
+      false
+    end
 
-      sftp.upload!(file, options[:to]) do |event, uploader, *args|
+    def upload(from, to, options = {})
+      print_cmd! "upload", "#{from} -> #{to}", :green, :bold
+      sftp.upload!(from, to) do |event, uploader, *args|
         case event
         when :put
           n = (args[1].to_f * 100 / args[0].size.to_f).to_i
-          progress(n)
+          print_progress(n)
         when :finish
-          progress(100)
+          print_progress(100)
         end
       end
-
-      time_info Time.now - start_time
     end
 
-    def download(file, options = {})
-      error "to is required" unless options[:to]
-
-      start_time = Time.now
-      download_info({
-        :host => @host,
-        :user => @user,
-        :file => file,
-        :to => options[:to]
-      })
-
-      sftp.download!(file, options[:to]) do |event, uploader, *args|
+    def download(from, to, options = {})
+      print_cmd! "download", "#{from} -> #{to}", :green, :bold
+      sftp.download!(from, to) do |event, uploader, *args|
         case event
         when :get
           size = 0
           if args[0].size
             size = args[0].size
           else
-            size = sftp.stat!(file).size
+            size = sftp.stat!(from).size
           end
           n = (args[1].to_f * 100 / size.to_f).to_i
-          progress(n)
+          print_progress(n)
         when :finish
-          progress(100)
+          print_progress(100)
         end
       end
-
-      time_info Time.now - start_time
     end
 
   private
 
-    def handle_sudo(command)
-      @options[:password] ||= ""
-      
-      command.on "[sudo] password" do
-        command.write @options[:password], :shadow => true
-      end
-
-      command.on "Password:" do
-        command.write @options[:password], :shadow => true
-      end
+    def ssh
+      @ssh ||= Net::SSH.start @host, @user, @options
+    end
 
-      command.on "Sorry, try again." do
-        error "cannot handle sudo automatically, try manually"
-      end
+    def sftp
+      @sftp ||= Net::SFTP.start @host, @user, @options
     end
   end
 end

data/lib/mybot/nodes.rb

@@ -3,14 +3,5 @@ module Mybot
 		def node(host, user, options = {})
       Node.new host, user, options
     end
-
-    def run(*args, &block)
-      @nodes ||= []
-      error "no node specified" if @nodes.empty?
-
-      @nodes.each do |node|
-        node.run(*args, &block)
-      end
-    end
-	end
+  end
 end