mybot 0.0.4 → 0.1.0

data/Botfile

@@ -1,66 +1,12 @@
 require "mybot"
-require "fileutils"
 
-include Messages
-
-local = node "localhost", "seba",
-  :keys => ["/Users/seba/.ssh/id_rsa"]
-
-namespace :mybot do
-  task :version do
-    puts Mybot::VERSION
-  end
-
-  task :install do
-    if File.exists? Mybot::MYBOT_PATH
-      error "mybot is already installed"
-    end
-
-    info "installing mybot to #{Mybot::MYBOT_PATH}"
-    FileUtils.mkdir Mybot::MYBOT_PATH
-    FileUtils.cp_r Mybot::VENDOR_PATH, Mybot::MYBOT_PATH
-  end
-
-  task :uninstall do
-    unless File.exists? Mybot::MYBOT_PATH
-      error "mybot is not installed"
-    end
-
-    info "uninstalling mybot"
-    if yes?("Do you really want to delete ~/.mybot")
-      FileUtils.rm_rf Mybot::MYBOT_PATH
-    else
-      info "uninstallation aborted"
-    end
-  end
-
-  task :update do
-    unless File.exists? Mybot::MYBOT_PATH
-      error "mybot is not installed"
-    end
-
-    info "updating 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, "core")
-    FileUtils.mkdir File.join(TPL_PATH, "core")
-    FileUtils.cp_r File.join(VENDOR_PATH, "tpl", "core"),
-      File.join(MYBOT_PATH, "tpl")
-  end
-
-  namespace :tasks do
-    task :list do
-      puts "available tasks:"
-      tasks.each do |t|
-        if t[:namespace]
-          puts "  #{t[:namespace]}:#{t[:name]}"
-        else
-          puts "  #{t[:name]}"
-        end
-      end
+namespace :tasks do
+  task :list do
+    puts "available tasks:"
+    tasks.each do |t|
+      task = t[:name]
+      task = "#{t[:namespace]}:#{t[:name]}" if t[:namespace]
+      puts "  #{task}"
     end
   end
 end

data/CHANGELOG.md

@@ -1,25 +1,2 @@
-### 0.0.3
-* added Utils with lib_to_path
-* added require_*_installed helper
-* added AWS instances support
-* added nginx support with static apps
-* added rails and static apps deployment
-* added git.init
-* added PHP support with nginx and FPM
-* fixed bug when running cmd in other cmd
-* refactored output formatting
-* added apt.dpkg_reconfigure
-* Node#run now returns Result object with STDOUT, STDERR and exit status
-* added fs.mktemp
-* added mysql user and dbs management routines
-* added ~/.bash_profile, ~/.bashrc and ~/.profile loading
-* added listeners
-* added write shadows
-
-### 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
+### 0.1.0
+* gem rewritten

data/README.md

@@ -1,41 +1,20 @@
 # mybot
 
-**mybot**, my personal bot
+**mybot**, personal bot
 
 ## Installation
 
 ```
 gem install mybot
-bot mybot:install
+bot install
 ```
 
-This will install **myboot** to `$HOME/.mybot`.
+**mybot** would be installed to `~/.mybot`
 
-* `.mybot`
-  * `lib` - libraries
-  * `recipes` - your recipes
-  * `tpl` - templates
+## Tasks
 
-## Updating
+Define task
 
-```
-gem update mybot
-bot mybot:update
-```
-
-This will replace `.mybot/lib/mybot/core` and `.mybot/tpl/mybot/core` directories with new, updated ones.
-
-## Usage
-
-### Recipes and tasks
-
-**mybot** searches for recipes in following directories:
-
-  * `~/.mybot/recipes/*.rb`
-  * `.mybot/*.rb`
-  * and in `./Botfile`
-
-To list all available tasks type `bot mybot:tasks:list`. Here's example recipe with task `foo:bar`:
 
 ```ruby
 require "mybot"
@@ -47,45 +26,56 @@ namespace :foo do
 end
 ```
 
-You can run it by typing `bot foo:bar`.
+and run it by typing `bot foo:bar`.
+
+**mybot** searches for tasks in following places:
 
-### Setting nodes and running commands
+  * `./Botfile`
+  * `.mybot/*.rb`
+  * `~/.mybot/tasks`
+
+To list all available tasks type `bot tasks:list`.
+
+## Nodes
 
 **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"
+srv = node "1.2.3.4", "user", :password => "123"
 
 namespace :foo do
   task :bar do
-    @node.run({ :cmd => "uname -a" })
+    srv.run "uname -a"
   end
 end
 ```
 
-It will execute your command on specified node (mine was Ubuntu Server). The output will be more or less:
+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
+TASK foo
+[user@1.2.3.4] RUN sudo pwd
+  EXIT 0
+  TIME 0.353989s
 ```
 
-When setting node you can also use SSH keys:
+You can also use SSH keys:
 
 ```ruby
-@node = node "1.2.3.4", "user", :keys => ["/path/to/key"]
+srv = node "1.2.3.4", "user", :keys => ["/path/to/key"]
 ```
   
-### Interaction
+## 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|
+  node.run "sudo pwd" do |cmd|
     cmd.on "[sudo] password" do
       cmd.write "123"
     end
@@ -96,10 +86,12 @@ 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
+TASK foo
+[user@1.2.3.4] RUN sudo pwd
+  HANDLE [sudo] password
+  WRITE 123<LF>
+  EXIT 0
+  TIME 0.353989s
 ```
 
 ### Handling sudo
@@ -108,195 +100,86 @@ Handling sudo is such repetitive task that you can try to handle it automaticall
 
 ```ruby
 task :foo do
-  puts "=> running uname -a"
-  @node.run({ :cmd => "pwd", :sudo => true })
+  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`.
 
-### 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**.
+## Templates
 
 ```ruby
-@tpl = tpl <<<-TPL
-This is template
-param1: <%= param1 %>
-param2: <%= param2 %>
-TPL
+mytpl = tpl "param: <%= param %>"
 
 task :foo do
-  @node.fs.create({
-    :file => "/path/to/file",
-    :content => @tpl.render({
-      :param1 => "value1",
-      :param2 => "value2"
-    })
-  })
+  puts mytpl.render({ param: "value" })
 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"
+mytpl = tpl :file => "path/to/tpl"
 ```
 
 **mybot** will look for templates in `~/.mybot/tpl`
 
-Downloading and uploading files is simple as:
+## Download and upload files
 
 ```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
-```
+  node.upload "/Users/seba/Downloads/test.zip",
+    :to => "/home/user/test.zip"
 
-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
+  node.download "/home/user/test.zip",
+    :to => "/Users/seba/Downloads/t.zip"
 end
 ```
 
-and should be used like this:
-
-```ruby
-@node.use "foo"
-
-task :foo
-  if @node.foo.baz?
-    @node.foo.bar
-  end
-end
-```
+There's always *progress bar* so you know if you have time for coffee :)
 
-### Usefull CLI helpers
+## 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:
+## Libs
 
-```ruby
-task :foo do
-  wait
+You can group node operations into lib
 
-  @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
+```ruby
+require "mybot"
 
-  if yes?("type sth (yes/no): ")
-    puts "you said yes"
-  else
-    puts "you said no"
-  end
+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
 end
 ```
 
-Running `foo` task will produce:
+and use them in this way
 
-```
-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
+```ruby
+require "mybot"
 
-[user@1.2.3.4] WRITE 123<LF>
+apt = lib "ubuntu:apt"
 
-/home/ubuntu
-type sth (yes/no): x
-type sth (yes/no): y
-you said yes
+apt.update node, {}
 ```
 
 ## Uninstallation