mybot 0.1.1 → 0.2.0

data/Gemfile

@@ -1,3 +1,3 @@
-source :rubygems
+source 'https://rubygems.org'
 
-gemspec
+gemspec

data/README.md

@@ -1,190 +1,141 @@
 # mybot
 
-**mybot**, personal bot
+My personal bot
 
 ## Installation
 
-```
-gem install mybot
-bot install
-```
-
-**mybot** would be installed to `~/.mybot`
-
-## Tasks
+Add this line to your application's Gemfile:
 
-Define task
-
-
-```ruby
-require "mybot"
+    gem 'mybot'
 
-namespace :foo do
-  task :bar do
-    puts "foo:bar"
-  end
-end
-```
+And then execute:
 
-and run it by typing `bot foo:bar`.
+    $ bundle
 
-**mybot** searches for tasks in following places:
+Or install it yourself as:
 
-  * `./Botfile`
-  * `.mybot/*.rb`
-  * `~/.mybot/tasks`
+    $ gem install mybot
 
-To list all available tasks type `bot tasks:list`.
+## Usage
 
-## Nodes
+### Tasks
 
-**mybot** operates on nodes which are practically computers you can SSH into. For the most part you will be executing commands using `node.run`:
+It's all about executing tasks. **mybot** will search for recipes in `~/.mybot/*.rb` and `Botfile` in current directory. Syntax is similar to **rake** and **capistrano**
 
 ```ruby
 require "mybot"
 
-srv = node "1.2.3.4", "user", :password => "123"
-
 namespace :foo do
-  task :bar do
-    srv.run "uname -a"
+  task :baz do
+    puts "foo:baz"
+  end
+
+  task :bar => :baz do |options|
+    puts options.inspect
   end
 end
 ```
 
-It will execute your command on specified node (mine was Ubuntu Server).
-The output will be more or less:
+To run task, use `bot` command:
 
 ```
-$ bot foo:bar
-TASK foo
-[user@1.2.3.4] RUN sudo pwd
-  EXIT 0
-  TIME 0.353989s
+% bot foo:bar --no-foo -bar -baz=12
+      task foo:bar
+      task foo:baz
+foo:baz
+{:foo=>false, :bar=>true, :baz=>12}
 ```
 
-You can also use SSH keys:
+### Nodes & interactive commands
+
+**mybot** operates on nodes which are in fact computers you can ssh into. You can run commands and interactively handle it's output:
 
 ```ruby
-srv = node "1.2.3.4", "user", :keys => ["/path/to/key"]
-```
-  
-## Interaction
+require "mybot"
 
-Executed commands can ask for your input and you can handle it with `on`:
+server = node "1.2.3.4", "user", :password => "123"
 
-```ruby
 task :foo do
-  node.run "sudo pwd" do |cmd|
-    cmd.on "[sudo] password" do
-      cmd.write "123"
+  wait "Press any key to continue..."
+  options = {
+    :sudo => true,
+    :cwd => "/home",
+    :env => {
+      "PARAM" => "value"
+    }
+  }
+  server.run "uname -a", options do |cmd|
+    cmd.on "Password:" do
+      cmd.write! ask "Type password: "
     end
   end
-end
-```
-  
-Here's the output:
-
-```
-TASK foo
-[user@1.2.3.4] RUN sudo pwd
-  HANDLE [sudo] password
-  WRITE 123<LF>
-  EXIT 0
-  TIME 0.353989s
-```
-
-### Handling sudo
-
-Handling sudo is such repetitive task that you can try to handle it automatically by **mybot**:
-
-```ruby
-task :foo do
-  node.run "pwd", :sudo => true
-end
-```
-
-It would try to use password provided with node declaration and will fail when the password doesn't work asking you to handle sudo manually. Note that you don't have to prepend command with **sudo** when using `:sudo => true`.
-
-## Templates
-
-```ruby
-mytpl = tpl "param: <%= param %>"
 
-task :foo do
-  puts mytpl.render({ param: "value" })
+  if yes? "Is that all (y/n): "
+    puts "we're done!"
+  else
+    puts "wait a minute!"
+  end
 end
 ```
 
-In fact you don't want to clutter your recipes with template strings so better use template files:
+and you should see:
 
-```ruby
-mytpl = tpl :file => "path/to/tpl"
 ```
-
-**mybot** will look for templates in `~/.mybot/tpl`
-
-## Download and upload files
-
-```ruby
-task :foo do
-  node.upload "/Users/seba/Downloads/test.zip",
-    :to => "/home/user/test.zip"
-
-  node.download "/home/user/test.zip",
-    :to => "/Users/seba/Downloads/t.zip"
-end
+% bot foo:bar
+      task foo
+      wait Press any key to continue...
+       run cd /home && sudo PARAM='value' uname -a
+    handle Password:
+       ask Type password:
+     write ***
+      time 0.151334
+      exit 0
+       ask Is that all (y/n):
+we're done!
 ```
 
-There's always *progress bar* so you know if you have time for coffee :)
+Note that bang version of `write` would replace sent data with asterisks.
 
-## CLI helpers
+### File operations & templates
 
-* `wait` will display *Press any key to continue...* message and will wait for any user interaction
-* `ask` will display question passed as argument and return the answer
-* `yes?` will display question too but it should return true or false based on user's answer. Only `yes | Yes | y` and similar answers are acceptable. When boolean value cannot be guessed the question is asked again.
-
-## Libs
-
-You can group node operations into lib
+Couple of most common file operations are available.
 
 ```ruby
 require "mybot"
 
-library "ubuntu:apt" do
-	library_options({
-		:env => {
-			"DEBIAN_FRONTEND" => "noninteractive"
-		}
-	})
-
-	func :update do |node, options|
-		node.run "apt-get update", options do |cmd|
-			cmd.on "dpkg was interrupted" do
-				error "Cannot update"
-			end
-
-			cmd.on "Could not get lock" do
-				error "Cannot update"
-			end
-		end
-	end
+server = node "1.2.3.4", "user", :password => "123"
+file_tpl = tpl :file => "/path/to/tpl"
+
+namespace :server do
+  task :foo do
+    unless server.exists? "/path/to/file"
+      server.create "/path/to/file", :content => file_tpl.render({
+        :param => "value",
+        :param => "value"
+      })
+    end
+  end
 end
+
 ```
 
-and use them in this way
+### Upload & download
 
 ```ruby
 require "mybot"
 
-apt = lib "ubuntu:apt"
+server = node "1.2.3.4", "user", :password => "123"
 
-apt.update node, {}
+task :foo do
+  server.upload "/Users/user/from.txt", "/home/user/to.txt"
+  server.download "/home/user/to.txt", "/Users/user/file.txt"
+end
 ```
 
-## Uninstallation
+## Contributing
 
-```
-bot uninstall
-gem uninstall -Iax mybot
-```
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/lib/mybot.rb

@@ -1,28 +1,21 @@
-$USE_COLOR = true
-$SHOW_CMD = true
-$LIVE_STDOUT = false
-$LIVE_STDERR = false
-$LIVE_STDIN = false
-
 module Mybot
-  autoload :Base,      "mybot/base"
-  autoload :Cli,       "mybot/cli"
-  autoload :Command,   "mybot/command"
-  autoload :Fmt,       "mybot/fmt"
-  autoload :Helpers,   "mybot/helpers"
-  autoload :Installer, "mybot/installer"
-  autoload :Lib,       "mybot/lib"
-  autoload :Libs,      "mybot/libs"
-  autoload :Loader,    "mybot/loader"
-  autoload :Node,      "mybot/node"
-  autoload :Nodes,     "mybot/nodes"
-  autoload :Tasks,     "mybot/tasks"
-  autoload :Template,  "mybot/template"
-  autoload :Templates, "mybot/templates"
-  autoload :VERSION,   "mybot/version"
-
-  GEM_PATH = File.dirname(File.dirname(__FILE__))
-  VENDOR_PATH = File.join(GEM_PATH, "vendor", ".")
+	GEM_PATH = File.dirname(File.dirname(__FILE__))
   HOME_PATH = File.expand_path "~"
-  MYBOT_PATH = File.join HOME_PATH, ".mybot"
+  
+	autoload :Base, "mybot/base"
+	autoload :Cli, "mybot/cli"
+	autoload :Command, "mybot/command"
+	autoload :Fmt, "mybot/fmt"
+	autoload :Helpers, "mybot/helpers"
+	autoload :Node, "mybot/node"
+	autoload :Nodes, "mybot/nodes"
+	autoload :Recipes, "mybot/recipes"
+	autoload :Tasks, "mybot/tasks"
+	autoload :Template, "mybot/template"
+	autoload :Templates, "mybot/templates"
+  autoload :VERSION, "mybot/version"
 end
+
+$MYBOT_USE_COLORS = true
+$MYBOT_SHOW_CMD = true
+$MYBOT_SHOW_OUTPUT = false

data/lib/mybot/base.rb

@@ -1,12 +1,9 @@
 module Mybot
-  module Base
-  	include Fmt
-    include Helpers
-    include Libs
-    include Loader
-    include Nodes
-    include Tasks
-    include Templates
-    extend self
-  end
+	module Base
+		include Helpers
+		include Nodes
+		include Recipes
+		include Tasks
+		extend self
+	end
 end

data/lib/mybot/cli.rb

@@ -1,26 +1,22 @@
 module Mybot
-  module Cli
-    include Fmt
-    include Helpers
-    include Installer
-    extend self
+	module Cli
+		include Fmt
+		extend self
 
-    def start(args)
-      cmd = args.shift
-      options = parse(args)
+		def start(args)
+			cmd = args.shift
+      options = parse_args(args)
 
-      error "usage: bot [install|uninstall|<task>] <options>" unless cmd
-
-      case cmd
-      when /(install|uninstall)/
-        self.send($1, options)
-      else
-        Base.load_files
-        Base.run_task cmd, options
+      unless cmd
+      	print_cmd! "error", "usage: bot <task> [<options>]", :red, :bold
+      	abort
       end
-    end
 
-    def parse(args)
+      Base.load_recipes
+      Base.run_task cmd, options
+		end
+
+		def parse_args(args)
       options = {}
 
       args.each_with_index do |arg, i|
@@ -52,5 +48,5 @@ module Mybot
         end
       end
     end
-  end
+	end
 end

data/lib/mybot/command.rb

@@ -1,67 +1,80 @@
 module Mybot
-  class Command
-    include Fmt
+	class Command
+		include Fmt
 
-    attr_accessor :channel, :exit_status, :time
+		attr_accessor :channel, :exit
 
-    def initialize
-      @out = @stdout = @stderr = ""
-      @handlers = {}
-      @exit_status = -1
-      @time = 0
-    end
+		def initialize
+			@out = @stdout = @stderr = ""
+			@handlers = {}
+			@time = Time.now
+			@exit = -1
+		end
 
-    def on(s, &block)
-      @handlers[s] = block
-    end
+		def on(s, &block)
+			@handlers[s] = block
+		end
 
-    def handle_stdout(data)
-      @out = data
-      @stdout += data
-      stdout_live(data)
-      @handlers.each do |s, proc|
-        if @out.include? s
-          handle_info s, :type => :stdout
-          proc.call
-        end
-      end
-    end
+		def handle_stdout(data)
+			@out = data
+			@stdout += data
+			print_stdout data
+			run_handlers
+		end
 
-    def handle_stderr(data)
-      @out = data
-      @stderr += data
-      stderr_live(data)
-      @handlers.each do |s, proc|
-        if @out.include? s
-          handle_info s, :type => :stderr
-          proc.call
-        end
-      end
-    end
+		def handle_stderr(data)
+			@out = data
+			@stderr += data
+			print_stderr data
+			run_handlers
+		end
 
-    def handle_close
-      status_info result
-      error "command exited with error" unless result[:exit_status] == 0
-    end
+		def handle_close
+			@time = Time.now - @time
+			print_cmd! "time", @time, :blue, :bold
+			print_cmd! "exit", @exit, :blue, :bold
 
-    def write(data, options = {})
-      write_info data, options
-      @channel.send_data "#{data}\n"
-    end
+			unless @exit == 0
+				print_cmd! "error", "invalid exit status", :red, :bold
+				print_stdout @stdout, true
+				print_stderr @stderr, true
+				abort
+			end
+		end
 
-    def result
-      {
-        :stdout => filter(@stdout),
-        :stderr => filter(@stderr),
-        :exit_status => @exit_status,
-        :time => @time
-      }
-    end
+		def write(data)
+			print_cmd! "write", data, :blue, :bold
+			@channel.send_data "#{data}\n"
+		end
+
+		def write!(data)
+			print_cmd! "write", asterisks(data), :blue, :bold
+			@channel.send_data "#{data}\n"
+		end
+
+		def result
+			{ 
+				:stdout => filter(@stdout),
+				:stderr => filter(@stderr),
+				:exit => @exit,
+				:time => @time
+			}
+		end
+
+	private
 
-  private
+		def run_handlers
+			@handlers.each do |s, block|
+				if @out.include? s
+					puts if @out[-3..-1] == "\r\n" && $MYBOT_SHOW_OUTPUT
+					print_cmd! "handle", s, :blue, :bold
+					block.call
+				end
+			end
+		end
 
-    def filter(data)
+		def filter(data)
       data.gsub(/\[sudo\]\ password\ for\ [a-zA-Z0-9_].+\:/, "")
     end
-  end
+	end
 end