mybot 0.0.1 → 0.0.2

data/Botfile

@@ -6,7 +6,7 @@ include Messages
 namespace :mybot do
   task :install do
     if File.exists? Mybot::MYBOT_PATH
-      fatal "mybot is already installed"
+      error "mybot is already installed"
     end
 
     info "installing mybot to #{Mybot::MYBOT_PATH}"
@@ -16,7 +16,7 @@ namespace :mybot do
 
   task :uninstall do
     unless File.exists? Mybot::MYBOT_PATH
-      fatal "mybot is not installed"
+      error "mybot is not installed"
     end
 
     info "uninstalling mybot"
@@ -29,18 +29,18 @@ namespace :mybot do
 
   task :update do
     unless File.exists? Mybot::MYBOT_PATH
-      fatal "mybot is not installed"
+      error "mybot is not installed"
     end
 
     info "updating mybot"
-    FileUtils.rm_rf File.join(LIB_PATH, "mybot")
-    FileUtils.mkdir File.join(LIB_PATH, "mybot")
-    FileUtils.cp_r File.join(VENDOR_PATH, "lib", "mybot"),
+    FileUtils.rm_rf File.join(LIB_PATH, "core")
+    FileUtils.mkdir File.join(LIB_PATH, "core")
+    FileUtils.cp_r File.join(VENDOR_PATH, "lib", "core"),
       File.join(MYBOT_PATH, "lib")
 
-    FileUtils.rm_rf File.join(TPL_PATH, "mybot")
-    FileUtils.mkdir File.join(TPL_PATH, "mybot")
-    FileUtils.cp_r File.join(VENDOR_PATH, "tpl", "mybot"),
+    FileUtils.rm_rf File.join(TPL_PATH, "core")
+    FileUtils.mkdir File.join(TPL_PATH, "core")
+    FileUtils.cp_r File.join(VENDOR_PATH, "tpl", "core"),
       File.join(MYBOT_PATH, "tpl")
   end
 

data/CHANGELOG.md

@@ -0,0 +1,7 @@
+### 0.0.2
+* started CHANGELOG
+* updated README to cover all available techniques
+* added handling sudo via `options[:sudo]`
+* renamed `~/.mybot/tasks` to `~/.mybot/recipes`
+* lib support
+* added Kernel.qualified_const_get in core-ext

data/README.md

@@ -1,31 +1,307 @@
-# Mybot
+# mybot
+
+**mybot**, my personal bot
 
 ## Installation
 
-	gem install mybot
-	bot install
+```
+gem install mybot
+bot mybot:install
+```
+
+This will install **myboot** to `$HOME/.mybot`.
+
+* `.mybot`
+  * `lib` - libraries
+  * `recipes` - your recipes
+  * `tpl` - templates
+
+## Updating
+
+```
+gem update mybot
+bot mybot:update
+```
+
+This will replace `.mybot/lib/mybot/core` and `.mybot/tpl/mybot/core` directories with new, updated ones.
 
 ## Usage
-**Mybot** searches for tasks in following directories:
 
-  * `~/.mybot/tasks/`
-  * `.mybot/`
+### Recipes and tasks
+
+**mybot** searches for recipes in following directories:
+
+  * `~/.mybot/recipes/*.rb`
+  * `.mybot/*.rb`
   * and in `./Botfile`
 
-## Tasks
-This is example task
+To list all available tasks type `bot mybot:tasks:list`. Here's example recipe with task `foo:bar`:
+
+```ruby
+require "mybot"
+
+namespace :foo do
+  task :bar do
+    puts "foo:bar"
+  end
+end
+```
+
+You can run it by typing `bot foo:bar`.
+
+### Setting nodes and running commands
+
+**mybot** operates on nodes which are practically computers you can SSH into. For the most part you will be executing commands using `node.run`:
+
+```ruby
+require "mybot"
+
+@node = node "1.2.3.4", "user", :password => "123"
+
+namespace :foo do
+  task :bar do
+    @node.run({ :cmd => "uname -a" })
+  end
+end
+```
+
+It will execute your command on specified node (mine was Ubuntu Server). The output will be more or less:
+
+```
+$ bot foo:bar
+[ubuntu@1.2.3.4] RUN uname -a
+Linux ubuntu 3.5.0-17-generic #28-Ubuntu SMP Tue Oct 9 19:31:23 UTC 2012 x86_64 x86_64 x86_64 GNU/Linux
+```
+
+When setting node you can also use SSH keys:
+
+```ruby
+@node = node "1.2.3.4", "user", :keys => ["/path/to/key"]
+```
+  
+### Interaction
+
+Executed commands can ask for your input and you can handle it with `on`:
+
+```ruby
+task :foo do
+  @node.run({ :cmd => "sudo pwd" }) do |cmd|
+    cmd.on "[sudo] password" do
+      cmd.write "123"
+    end
+  end
+end
+```
+  
+Here's the output:
+
+```
+[ubuntu@192.168.1.7] RUN sudo pwd
+[sudo] password for ubuntu: 
+[ubuntu@192.168.1.7] WRITE 123<LF>
+/home/ubuntu
+```
+
+### Handling sudo
+
+Handling sudo is such repetitive task that you can try to handle it automatically by **mybot**:
+
+```ruby
+task :foo do
+  puts "=> running uname -a"
+  @node.run({ :cmd => "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`.
+
+### Customizing output
+
+As you saw in previous sections, **mybot** produces fair amount of output when talking with nodes. Everything is controlled by options in `node.fmt`:
+
+* `use_color` - turn of when your terminal don't support colors
+* `show_cmd` - show messages like `[user@host] RUN cmd`
+* `show_stdout` and `show_stdout` - show **STDOUT** and **STDERR** produced by executed commands
+* `show_stdin` - show input being passed to nodes (messages like `[user@host] WRITE sth<LF>`)
+
+Each option is set to `true` by default. For example you can customize **mybot** to show only commands without output:
+
+```ruby
+@node.fmt.show_stdout = false
+@node.fmt.show_stderr = false
+@node.fmt.show_stdin = false
+
+task :foo do
+  @node.run({ :cmd => "uname -a" })
+end
+```
+
+or even completely disable it and only display own informations, so adding `@node.fmt.show_cmd = false` to previous example will produce only:
+
+```
+=> running uname -a
+```
+
+You can use helpers build-in: `info`, `warning` and `error` which aborts execution of the script.
+
+### Libraries
+
+You can `use` many provided libraries to extend nodes functionality. The most common is Filesystem library:
+
+```ruby
+task :foo do
+  if @node.fs.exists?({ :file => "/path/to/file" })
+    content = @node.fs.read({ :file => "/path/to/file" })
+  else
+    @node.fs.create({ :file => "/path/to/file", :content => "abc\n" })
+  end
+end
+```
+
+### Templates
+
+There is build-in templating system based on **ERB**.
+
+```ruby
+@tpl = tpl <<<-TPL
+This is template
+param1: <%= param1 %>
+param2: <%= param2 %>
+TPL
+
+task :foo do
+  @node.fs.create({
+    :file => "/path/to/file",
+    :content => @tpl.render({
+      :param1 => "value1",
+      :param2 => "value2"
+    })
+  })
+end
+```
+
+In fact you don't want to clutter your recipes with template strings so better use template files:
+
+```ruby
+@tpl = tpl_file "path/to/tpl"
+```
+
+**mybot** will look for templates in `~/.mybot/tpl`
+
+Downloading and uploading files is simple as:
+
+```ruby
+task :foo do
+  @node.fs.upload({
+    :from => "/file/to/upload",
+    :to => "/home/ubuntu/file"
+  })
+
+  @node.fs.download({
+    :from => "/home/ubuntu/file,
+    :to => "/tmp/downloaded_file"
+  })
+end
+```
+
+There's always *progress bar* so you know if you have time for coffee :)
+
+There's nice **Ubuntu** library already:
+
+```ruby
+@node = node "1.2.3.4", "user", :password => "123"
+@node.use "core/ubuntu/apt"
+
+task :setup do
+  unless @node.apt.installed?({ :pkg => "name" })
+    @node.apt.install({ :pkg => "name" })
+  else
+    @node.apt.update
+  end
+end
+```
+
+Of course you can roll own libraries. Save them to `~/.mybot/lib` folder. Do not touch `~/.mybot/lib/core` because it will be replaced by updates. Your custom lib should look like this:
+
+```ruby
+class Foo < Mybot::Lib
+  def initialize(node)
+    @node = node
+  end
+
+  def bar
+    puts "foo:bar"
+  end
+
+  def baz?
+    true
+  end
+end
+```
+
+and should be used like this:
+
+```ruby
+@node.use "foo"
+
+task :foo
+  if @node.foo.baz?
+    @node.foo.bar
+  end
+end
+```
+
+### Usefull CLI helpers
+
+* `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.
+
+Here's example showing helpers in action:
+
+```ruby
+task :foo do
+  wait
+
+  @node.run({ :cmd => "sudo pwd" }) do |cmd|
+    cmd.on "[sudo] password" do
+      # ask's 1st argument is the question and it defaults to empty string
+      # we're displaying STDOUT so question is already asked :)
+      cmd.write ask
+    end
+  end
+
+  if yes?("type sth (yes/no): ")
+    puts "you said yes"
+  else
+    puts "you said no"
+  end
+end
+```
+
+Running `foo` task will produce:
+
+```
+Press any key to continue...
+[user@1.2.3.4] RUN sudo pwd
+[sudo] password for ubuntu: 34
+
+[user@1.2.3.4] WRITE 34<LF>
+
+Sorry, try again.
+[sudo] password for ubuntu: 123
 
-	require "mybot"
-	
-	namespace :foo do
-  	  task :bar do
-	    puts "foo:bar"
-	  end
-	end
+[user@1.2.3.4] WRITE 123<LF>
 
-and you can run it by typing `bot foo:bar`
+/home/ubuntu
+type sth (yes/no): x
+type sth (yes/no): y
+you said yes
+```
 
 ## Uninstallation
 
-	bot uninstall
-	gem uninstall -Iax mybot
+```
+bot uninstall
+gem uninstall -Iax mybot
+```

data/lib/mybot.rb

@@ -1,9 +1,12 @@
+require "mybot/core-ext/kernel"
+
 module Mybot
   autoload :Base,     "mybot/base"
   autoload :Cli,      "mybot/cli"
   autoload :Command,  "mybot/command"
   autoload :Commands, "mybot/commands"
   autoload :Fmt,      "mybot/fmt"
+  autoload :Lib,      "mybot/lib"
   autoload :Messages, "mybot/messages"
   autoload :Node,     "mybot/node"
   autoload :Recipes,  "mybot/recipes"

data/lib/mybot/cli.rb

@@ -1,10 +1,11 @@
 module Mybot
   module Cli
+    include Messages
     extend self
 
     def start(args)
       unless args[0]
-        abort "usage: bot <task>"
+        error "usage: bot <task>"
       end
 
       Base.load_recipes

data/lib/mybot/command.rb

@@ -1,6 +1,6 @@
 module Mybot
   class Command
-    attr_accessor :out, :stdout, :stderr, :channel, :exit_status
+    attr_accessor :channel, :out, :stdout, :stderr, :exit_status
 
     def initialize(node)
       @node = node
@@ -15,7 +15,7 @@ module Mybot
 
     def handle_stdout(data)
       @out = data
-      @stdout += data.strip
+      @stdout += data
       @node.fmt.stdout data
       @handlers.each do |s, proc|
         proc.call if @out.include? s
@@ -24,7 +24,7 @@ module Mybot
 
     def handle_stderr(data)
       @out = data
-      @stderr += data.strip
+      @stderr += data
       @node.fmt.stderr data
       @handlers.each do |s, proc|
         proc.call if @out.include? s
@@ -32,12 +32,31 @@ module Mybot
     end
 
     def handle_exit
-      @stdout
+      filter(@stdout)
+    end
+
+    def handle_sudo
+      on "[sudo] password" do
+        write @node.options[:password]
+      end
+
+      on "Password:" do
+        write @node.options[:password]
+      end
+
+      on "Sorry, try again." do
+        @node.fmt.error "cannot handle sudo automatically, try to it manually"
+      end
     end
 
     def write(data)
       @node.fmt.write data
       @channel.send_data "#{data}\n"
     end
+
+    def filter(data)
+      data.gsub!("[sudo] password for #{@node.options[:user]}:", "")
+      data.strip
+    end
   end
 end