do 0.0.1

data/.gitignore

@@ -0,0 +1,17 @@
+*.gem
+*.rbc
+.bundle
+.config
+.yardoc
+Gemfile.lock
+InstalledFiles
+_yardoc
+coverage
+doc/
+lib/bundler/man
+pkg
+rdoc
+spec/reports
+test/tmp
+test/version_tmp
+tmp

data/Gemfile

@@ -0,0 +1,4 @@
+source 'http://rubygems.org'
+
+# Specify your gem's dependencies in do.gemspec
+gemspec

data/README.md

@@ -0,0 +1,298 @@
+# DO .. it! - Framework Toolkit for Sysadmin
+
+DO is a thin framework useful to manage remote servers through ssh.
+
+There are many other alternative, once of them is [capistrano](https://github.com/capistrano/capistrano)
+
+So why another one? Basically I need:
+
+* easy creation of my recipes
+* see perfectly what's happening on my remote servers
+* highly focus on smart actions, upload, download, sudo, replace.
+* manage more than one server each
+* use same behaviour for manage local tasks
+
+## Installation
+
+```sh
+$ sudo gem install do
+$ doit do:setup
+```
+
+Now start to edit your `~/do/dorc` file and have fun!
+
+## Files
+
+There are some way to generate **DO** tasks, you can:
+
+* Create a file called `Do` in your project directory
+* Create a file called `Dofile` in your project directory
+* Create `*.rake` files in `~/.do` directory, aka **home dir**
+* Create a file called `dorc` in `~/.do` directory
+
+You can change your **do home directory** with:
+
+```
+DO_PATH='/my/new/.do/path'
+ENV['DO_PATH']='/my/new/.do/path'
+export DO_PATH='/my/new/.do/path'
+```
+
+## Features
+
+* Easily server logging
+* SSH connections
+* SFTP connections (upload and download)
+* run cmd (we handle also with input)
+* shortcuts (exist?, read, replace, append etc...)
+
+Code is much better:
+
+```rb
+server = DO::Server.new('srv1', 'srv1.domain.local', 'root', :key => %w[srv1.pem]
+
+server.run 'uname'
+# root@srv1 ~ # uname
+# Linux
+
+server.run 'uname', '-a'
+# root@srv1 ~ # uname -a
+# Linux srv1.lipsiasoft.net 2.6.18-194.32.1.el5  x86_64 x86_64 x86_64 GNU/Linux
+
+server.run 'mysqladmin -u root -p password 'oldone', 'newpassword'
+# root@srv1 ~ # mysqladmin -u root -p password 'oldone'
+# Enter password: oldone
+# mysqladmin: connect to server at 'localhost' failed
+# error: 'Access denied for user 'root'@'localhost' (using password: YES)'
+
+server.exist?('~/.ssh')
+# root@srv1 ~ # test -e ~/.ssh && echo True
+# => true
+
+server.read('/etc/redhat-release')
+# root@srv1 ~ # cat /etc/redhat-release
+# => "CentOS release 5.5 (Final)"
+
+server.upload '/tmp/file', '/tmp/foo'
+# root@srv1 ~ # upload from '/tmp/file' to '/tmp/foo'
+
+server.download '/tmp/foo', '/tmp/file2'
+# root@srv1 ~ # download from '/tmp/foo' to '/tmp/file2'
+
+server.replace :all, 'new content', '/tmp/file'
+# root@srv1 ~ # replace all in '/tmp/foo'
+
+server.read('/tmp/foo')
+# root@srv1 ~ # cat /tmp/foo
+# => "new content"
+
+server.replace /content$/, 'changed content', '/tmp/foo'
+# root@srv1 ~ # replace /content$/ in '/tmp/foo'
+
+server.read('/tmp/foo')
+# root@srv1 ~ # cat /tmp/foo
+# => "new changed content"
+
+server.append('appended', '/tmp/foo')
+# root@srv1 ~ # append to 'bottom' in '/tmp/foo'
+
+server.read('/tmp/foo')
+# root@srv1 ~ # cat /tmp/foo
+# => "new changed contentappended"
+
+server.append('---', '/tmp/foo', :top)
+# root@srv1 ~ # append to 'top' in '/tmp/foo'
+
+server.read('/tmp/foo')
+# root@srv1 ~ # cat /tmp/foo
+# => "---new changed contentappended"
+
+server.ask "Please choose"
+# root@srv1 ~ # Please choose: foo
+# => "foo"
+
+server.yes? "Do you want to proceed"
+# root@srv1 ~ # Do you want to proceed? (y/n): y
+# => 0
+
+server.wait
+# Press ENTER to continue...
+```
+
+## Scenario and examples
+
+I'm porting my custom recipes to do, you can found my dot files
+[here](https://github.com/daddye/.do)
+
+I've server config in `~/.do/dorc`:
+
+```rb
+keys = %w(/keys/master.pem /keys/instances.pem /keys/stage.pem)
+server :sho0, 'sho0.lipsiasoft.biz', 'root', :keys => keys
+server :srv0, 'srv0.lipsiasoft.biz', 'root', :keys => keys
+server :srv1, 'srv1.lipsiasoft.biz', 'root', :keys => keys
+server :srv2, 'srv2.lipsiasoft.biz', 'root', :keys => keys
+
+plugin "configure-server", "https://raw.github.com/gist/112..."
+```
+
+Then I've some recipes in my `~/.do` path where I do common tasks.
+
+```rb
+# ~/.do/configure.
+namespace :configure
+  desc "upgrade rubygems and install usefull gems"
+  task :gems => :ree do
+    run "gem update --system" if yes?("Do you want to update rubygems?")
+    run "gem install rake"
+    run "gem install highline"
+    run "gem install bundler"
+    run "ln -s /opt/ruby-enterprise/bin/bundle /usr/bin/bundle" unless exist?("/usr/bin/bundle")
+  end
+
+  desc "create motd for each server"
+  task :motd do
+    replace :all, "Hey boss! Welcome to the \e[1m#{name}\e[0m of LipsiaSOFT s.r.l.\n", "/etc/motd"
+  end
+
+  desc "redirect emails to a real account"
+  task :root_emails do
+    append "\nroot: servers@lipsiasoft.com", "/etc/aliases"
+    run "newaliases"
+  end
+
+  desc "mysql basic configuration"
+  task :mysql => :yum do
+    run "yum install mysql-server mysql mysql-devel -y"
+    run "chkconfig --level 2345 mysqld on"
+    run "service mysqld restart"
+    pwd = ask "Tell me the password for mysql"
+    run "mysqladmin -u root -p password '#{pwd}'", :input => "\n"
+    run "service mysqld restart"
+    run "ln -fs /var/lib/mysql/mysql.sock /tmp/mysql.sock"
+  end
+...
+```
+
+I call those with:
+
+```sh
+$ doit configure:gems
+$ doit configure:motd
+$ doit configure:mysql
+```
+
+**NOTE** that like rake tasks you are be able to add prerequisites to
+any task, in this case:
+
+```rb
+task :mysql => :yum do; ...; end
+```
+
+That's are some local tasks:
+
+```rb
+namespace :l do
+  local :setup do
+    name = File.basename(File.expand_path('.'))
+    exit unless yes?('Do you want to setup "%s"?' % name)
+    srv = nil
+
+    until servers.map(&:name).include?(srv)
+      srv = ask("Which server do you want to use (%s)" % servers.map(&:name).join(", ")).to_sym
+    end
+
+    if File.exist?('.git')
+      exit unless yes?('Project "%s" has already a working repo, do you want remove it?' % name)
+      sh 'rm -rf .git'
+    end
+
+    sh 'git init'
+    sh 'git remote add origin git@lipsiasoft.biz:/%s.git' % name
+    Rake::Task['l:commit'].invoke if yes?("Are you ready to commit it, database, config etc is correct?")
+  end
+
+  local :commit do
+    sh 'git add .'
+    sh 'git commit -a'
+    sh 'git push origin master'
+  end
+end
+```
+
+When I need to setup a new project I do:
+
+``` sh
+$ doit l:setup
+$ doit l:commit # to make a fast commit and push
+```
+
+As you can see define remote and local task is simple like making common
+rake tasks, infact this gem handle rake.
+
+## Filtering
+
+Sometimes you want to perform a task only on one or some servers:
+
+```sh
+$ doit configure:new --only-srv1 --only-srv2
+$ doit configure:new --except-srv1
+```
+
+## Awesome output
+
+What I really need is a great understandable, colored output that clarify
+me what's happen on my remote servers.
+
+```
+root@sho0 ~ # touch /root/.bashrc
+root@sho0 ~ # replace all in '/root/.bashrc'
+root@sho0 ~ # replace all in '/etc/motd'
+root@sho0 ~ # replace /HOSTNAME=.*/ in '/etc/sysconfig/network'
+root@sho0 ~ # chmod +w /etc/sudoers
+root@sho0 ~ # replace /^Defaults    requiretty/ in '/etc/sudoers'
+root@sho0 ~ # chkconfig --level 2345 sendmail on
+root@sho0 ~ # chkconfig --level 2345 mysqld on
+root@sho0 ~ # service sendmail restart
+Shutting down sm-client: [  OK  ]
+Shutting down sendmail: [  OK  ]
+Starting sendmail: [  OK  ]
+Starting sm-client: [  OK  ]
+root@sho0 ~ # service mysqld restart
+Stopping mysqld:  [  OK  ]
+Starting mysqld:  [  OK  ]
+root@sho0 ~ # Tell me the password for mysql: xx
+root@sho0 ~ # mysqladmin -u root -p password xx'
+Enter password: xx
+mysqladmin: connect to server at 'localhost' failed
+error: 'Access denied for user 'root'@'localhost' (using password: NO)'
+root@sho0 ~ # service mysqld restart
+Stopping mysqld:  [  OK  ]
+Starting mysqld:  [  OK  ]
+root@sho0 ~ # ln -fs /var/lib/mysql/mysql.sock /tmp/mysql.sock
+```
+
+## Copyright
+
+Copyright (C) 2011 Davide D'Agostino -
+[@daddye](http://twitter.com/daddye)
+
+Permission is hereby granted, free of charge, to any person obtaining a
+copy of this software and
+associated documentation files (the “Software”), to deal in the Software
+without restriction, including without
+limitation the rights to use, copy, modify, merge, publish, distribute,
+sublicense, and/or sell copies of the Software,
+and to permit persons to whom the Software is furnished to do so,
+subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included
+in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS
+OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES
+OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS BE LIABLE FOR ANY CLAIM,
+DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
+OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE
+SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

data/Rakefile

@@ -0,0 +1,28 @@
+#!/usr/bin/env rake
+require 'bundler/setup'
+require 'bundler/gem_tasks'
+require 'rspec/core/rake_task'
+
+%w(install release).each do |task|
+  Rake::Task[task].enhance do
+    sh "rm -rf pkg"
+  end
+end
+
+desc "Bump version on github"
+task :bump do
+  puts "\e[31mNothing to commit (working directory clean)\e[0m" and return unless `git status -s`.chomp == ""
+  version  = Bundler.load_gemspec(Dir[File.expand_path('../*.gemspec', __FILE__)].first).version
+  sh "git add .; git commit -a -m \"Bump to version #{version}\""
+end
+
+task :release => :bump
+
+desc "Run complete application spec suite"
+RSpec::Core::RakeTask.new("spec") do |t|
+  t.skip_bundler = true
+  t.pattern = './spec/**/*_spec.rb'
+  t.rspec_opts = %w(-fs --color --fail-fast)
+end
+
+task :default => :spec

data/bin/doit

@@ -0,0 +1,30 @@
+#!/usr/bin/env ruby
+$:.push File.expand_path("../../lib", __FILE__)
+require 'rubygems' unless defined?(Gem)
+require 'rake/dsl_definition'
+require 'rake'
+require 'do'
+
+ARGV << "-T" if ARGV.empty?
+
+only   = ARGV.map { |a| a =~ /--only-(.*)/ && $1.to_sym }.compact
+except = ARGV.map { |a| a =~ /--except-(.*)/ && $1.to_sym }.compact
+
+ARGV.delete_if { |a| a =~ /--(only|except)/ }
+
+puts "\e[32m"
+puts "*" * 60
+puts "*" + "DO".center(58) + "*"
+puts "*" * 60
+puts "\e[0m"
+
+Rake.application.init
+Rake.application.instance_variable_set(:@name, 'doit')
+load(File.expand_path('../../lib/do/commands.rb', __FILE__))
+DO.recipes.each { |recipe| Rake.application.add_import(recipe) }
+Rake.application.load_imports
+
+servers.delete_if { |server| !only.include?(server.name)  } unless only.empty?
+servers.delete_if { |server| except.include?(server.name) }
+
+Rake.application.top_level

data/do.gemspec

@@ -0,0 +1,21 @@
+# -*- encoding: utf-8 -*-
+require File.expand_path('../lib/do/version', __FILE__)
+
+Gem::Specification.new do |gem|
+  gem.authors       = ["Davide D'Agostino"]
+  gem.email         = ["d.dagostino@lipsiasoft.com"]
+  gem.description   = %q[DO is a thin framework useful to manage remote servers through ssh.]
+  gem.summary       = %q[DO is a thin framework useful to manage remote servers through ssh.]
+  gem.homepage      = 'https://github.com/daddye/do'
+
+  gem.executables   = `git ls-files -- bin/*`.split("\n").map{ |f| File.basename(f) }
+  gem.files         = `git ls-files`.split("\n")
+  gem.test_files    = `git ls-files -- {test,spec,features}/*`.split("\n")
+  gem.name          = "do"
+  gem.require_paths = ['lib']
+  gem.version       = DO::VERSION
+  gem.add_dependency "rake",     "~>0.9.2"
+  gem.add_dependency "net-ssh",  "~>2.1.4"
+  gem.add_dependency "net-sftp", "~>2.0.5"
+  gem.add_development_dependency "rspec"
+end

data/lib/do/commands.rb

@@ -0,0 +1,156 @@
+require 'rake/dsl_definition'
+require 'rake'
+
+module DO
+  module Commands
+    include Rake::DSL
+    include DO::Utils
+
+    ##
+    # Array of DO::Server defined in our tasks
+    #
+    def servers
+      @_servers ||= []
+    end
+
+    ##
+    # An array of DO::Server selected by our remote task
+    #
+    def servers_selected
+      @_servers_selected ||=[]
+    end
+
+    ##
+    # Returns the current server
+    #
+    def current_server
+      @_current_server
+    end
+
+    ##
+    # This method define our servers
+    #
+    # ==== Examples:
+    #   keys = %w[key1.pem key2.pem key3.pem key4.pem]
+    #   server :srv1, 's1.domain.local', 'user', :keys => keys
+    #   server :srv2, 's2.domain.local', 'user', :keys => keys
+    #   server :srv3, 's3.domain.local', 'user', :keys => keys
+    #   server :srv4, 's4.domain.local', 'user', :keys => keys
+    #
+    def server(name, host, user, options={})
+      servers.push(DO::Server.new(name, host, user, options))
+      local(name) { servers_selected.replace(servers.select { |s| s.name == name }) }
+    end
+
+    ##
+    # Install in your DO_PATH a remote task
+    #
+    # === Examples
+    #   # You can install/update task with
+    #   # rake plugin:configuration
+    #   plugin "configuration", "https://gist.github.com/raw/xys.rake"
+    #
+    def plugin(name, repo)
+      desc "Install #{name} plugin"
+      local("plugin:#{name}" => "do:setup") do
+        Dir.mkdir(DO_PATH) unless File.exist?(DO_PATH)
+        sh "curl --location --progress-bar #{repo} > #{File.join(DO_PATH, name + '.rake')}"
+      end
+    end
+
+    ##
+    # Execute DO::Server operations on remote defined servers.
+    #
+    # ==== Examples:
+    #   # Define our ssh connections
+    #   keys = %w[key1.pem key2.pem key3.pem key4.pem]
+    #   server :srv1, 's1.domain.local', 'user', :keys => keys
+    #   server :srv2, 's2.domain.local', 'user', :keys => keys
+    #   server :srv3, 's3.domain.local', 'user', :keys => keys
+    #   server :srv4, 's4.domain.local', 'user', :keys => keys
+    #
+    #   # => Executes commands only to :srv1, :srv2, :srv3
+    #   remote :name => [:srv1, :srv2, :srv3] do; ...; end
+    #
+    #   # => Same as above
+    #   task :name => [:srv1, :srv2, :srv3] do; ...; end
+    #
+    #   # => Executes commands on all defined servers
+    #   remote :name  => :servers do; ...; end
+    #   # => Same as above
+    #   remote :name => do; ...; end
+    #   # => Same as above
+    #   task :name do; ...; end
+    #   # => Same as above
+    #   local :name => :servers do; ...; end
+    #
+    #   # => Execute the task on your machine
+    #   local :name do; sh 'uname'; end
+    #
+    #   # => Execute commands both on servers side and local side
+    #   remote :name do |t|
+    #     t.run 'run this command on remote servers'
+    #     sh 'run this command on my local machine'
+    #   end
+    #
+    #   # same of:
+    #
+    #   task :name do |t|
+    #     t.run 'command on remote servers'
+    #     sh 'command on my local machine'
+    #   end
+    #
+    #   # => Execute command only on remote server srv1
+    #   task :name => :srv1 do
+    #     run 'command only on remote server srv1'
+    #   end
+    #
+    def remote(args, &block)
+      args = { args => :servers } unless args.is_a?(Hash)
+      local(args) do
+        name = args.is_a?(Hash) ? args.keys[0] : args
+        servers_selected.each do |current|
+          begin
+            server_was, @_current_server = @_current_server, current
+            self.class.send(:define_method, name, &block)
+            method = self.class.instance_method(name)
+            self.class.send(:remove_method, name)
+            block.arity == 1 ? method.bind(self).call(current) : method.bind(current).call
+          ensure
+            @_current_server = server_was
+          end # begin
+        end # servers
+      end # local
+    end
+
+    alias_method :local, :task
+    alias_method :task, :remote
+
+    ##
+    # Log text under current_server if available
+    #
+    def log(text, new_line=true)
+      if current_server
+        current_server.log(text, new_line)
+      else
+        text += "\n" if new_line && text[-1] != ?\n
+        print(text)
+      end
+    end
+  end # Commands
+end # DO
+
+self.extend DO::Commands
+
+local :servers do
+  servers_selected.replace(servers)
+end
+
+namespace :do do
+  desc "setup a working home directory"
+  local :setup do
+    File.mkdir(DO_PATH) unless File.exist?(DO_PATH)
+    sh 'touch %s' % File.join(DO_PATH, 'dorc')
+    sh 'ln -s %s %s' % [File.join(DO_PATH, 'dorc'), File.expand_path("~/.dorc")]
+  end
+end

data/lib/do/server.rb

@@ -0,0 +1,212 @@
+require 'net/ssh'
+require 'net/sftp'
+
+module DO
+  class Server
+    include DO::Utils
+
+    LOG_FORMAT = "\e[36m%s\e[33m@\e[31m%s \e[33m~ \e[35m#\e[0m %s" unless defined?(LOG_FORMAT)
+
+    attr_reader :name, :host, :user, :options
+    attr_accessor :logger
+
+    ##
+    # Initialize a new DO Server
+    #
+    # name:: is a shortcut useful in rake tasks
+    # host:: is the host where we connect
+    # user:: the user of our server
+    # options:: an hash of options used by ssh/sftpd, where normally we provide :keys => ['path/to/key.pem']
+    #
+    # ==== Examples:
+    #   srv1 = DO::Server.new(:srv1, 'srv1.lipsiasoft.biz', 'root', :keys => %w[/path/to/key.pem]
+    #   srv1.logger = StringIO.new # default is STDOUT
+    #
+    def initialize(name, host, user, options={})
+     @name, @host, @user, @options = name, host, user, options
+     @logger = STDOUT
+    end
+
+    ##
+    # Method used to print a formatted version of our commands
+    # using DO::Server::LOG_FORMAT, by default we have a nice
+    # colored version like:
+    #
+    #   srv1@root ~ # ls -al
+    #
+    # If you don't like colors or our format feel free to edit:
+    #
+    # ==== Examples:
+    #   DO::Server::LOG_FORMAT = "%s@%s$ %s"
+    #
+    def log(text, new_line=true)
+      text += "\n" if new_line && text[-1] != ?\n
+      logger.print LOG_FORMAT % [user, name, text]
+    end
+
+    ##
+    # This is the ssh connection
+    #
+    def ssh
+      @_ssh ||= Net::SSH.start(host, user, options)
+    end
+
+    ##
+    # The sftp connection used to perform uploads, downloads
+    #
+    def sftp
+      @_sftp ||= Net::SFTP.start(host, user, options)
+    end
+
+    ##
+    # Method used to close the ssh connection
+    #
+    def close
+      ssh.close if @_ssh
+    end
+
+    ##
+    # Run commands on remote server
+    #
+    # ==== Examples:
+    #   run 'ls -al'
+    #   run 'ls', '-al'
+    #   run 'mysqladmin -u root -p password 'new', :input => 'oldpassword'
+    #
+    def run(*args)
+      options = args.last.is_a?(Hash) ? args.pop : {}
+      cmd = args.join(" ")
+      cmd = "su #{options[:as]} -c '#{cmd.gsub(/'/, "\'")}'" if options[:as]
+      log cmd
+      result = ""
+      ssh.exec!(cmd) do |channel, stream, data|
+        result << data
+        logger.print(data) unless options[:silent]
+        if options[:input]
+          match = options[:match] || /^Enter password:/
+          if data =~ match
+            options[:input] += "\n" if options[:input][-1] != ?\n
+            channel.send_data(options[:input])
+            logger.puts(options[:input]) unless options[:silent]
+          end
+        end
+      end
+      result.chomp
+    end
+
+    ##
+    # Returns true if a given file exist on the remote server
+    #
+    def exist?(file)
+      run("test -e #{file} && echo True", :silent => true) == "True"
+    end
+
+    ##
+    # Return the content of a given file
+    #
+    def read(file)
+      run("cat #{file}", :silent => true)
+    end
+
+    ##
+    # Upload a file or directory from a local location to the remote location
+    # When you need to upload a directory you need to provide:
+    #
+    #   :recursive => true
+    #
+    # === Examples
+    #   upload(/my/file, /tmp/file)
+    #   up(/my/dir, /tmp, :recursive => true)
+    #
+    def upload(from, to, options={})
+      log "upload from '%s' to '%s'" % [from, to]
+      sftp.upload!(from, to)
+    end
+    alias :up :upload
+
+    ##
+    # Download a file o a directory from a remote location to a local location
+    # As for +upload+ we can download an entire directory providing
+    #
+    #   :recursive => true
+    #
+    # ==== Examples
+    #   download(/tmp/file, /my/file)
+    #   get(/tmp/dir, /my, :recursive => true)
+    #
+    def download(from, to, options={})
+      log "download from '%s' to '%s'" % [from, to]
+      sftp.download!(from, to)
+    end
+    alias :get :download
+
+    ##
+    # Replace a pattern with text in a given file.
+    #
+    # Pattern can be:
+    #
+    # * string
+    # * regexp
+    # * symbol (:all, :any, :everything) => replace all content
+    #
+    # ==== Examples
+    #   replace :all, my_template, "/root/.gemrc"
+    #   replace /^motd/, "New motd", "/etc/motd"
+    #   replace "Old motd, "New motd", "/etc/motd"
+    #
+    def replace(pattern, replacement, file)
+      was = sftp.file.open(file, "r") { |f| f.read }
+      found = case pattern
+        when :all, :any, :everything
+          log "replace \e[1m%s\e[0m in '%s'" % [pattern, file]
+          true
+        when Regexp
+          log "replace \e[1m%s\e[0m in '%s'" % [pattern.inspect, file]
+          replacement = was.gsub(pattern, replacement)
+          was =~ pattern
+        when String
+          log "replace \e[1m%s\e[0m in '%s'" % ["String", file]
+          replacement = was.gsub(pattern, replacement)
+          was.include?(pattern)
+        else raise "%s is not a valid. You can use a String, Regexp or :all, :any and :everything" % pattern.inspect
+      end
+
+      if found
+        sftp.file.open(file, "w") { |f| f.write replacement }
+      else
+        log "\e[31m '%s' does not include your \e[1mpattern\e[0m" % file unless was =~ pattern
+      end
+    end
+    alias :gsub :replace
+
+    ##
+    # Append text into a given file in a specified location
+    #
+    # Locations can be:
+    #
+    # :top, :start:: Add your text before the old content
+    # :bottom, :end:: Append your text at bottom of your file
+    #
+    # ==== Examples:
+    #   append "By default Im at bottom", "/tmp/file"
+    #   append "Im on top", "/tmp/file", :top
+    #
+    def append(pattern, file, where=:bottom)
+      was = sftp.file.open(file, "r") { |f| f.read }
+
+      if was.include?(pattern)
+        log "'%s' already match your pattern" % file
+        return false
+      else
+        replacement = case where
+          when :top, :start  then pattern+was
+          when :bottom, :end then was+pattern
+          else raise "%s is not a valid, available values are (:top, :start, :bottom, :end)" % where.inspect
+        end
+      end
+
+      log "append to '%s' in '%s'" % [where, file]
+      sftp.file.open(file, "w") { |f| f.write(replacement) }
+    end
+  end # Server
+end # DO

data/lib/do/utils.rb

@@ -0,0 +1,55 @@
+module DO
+  module Utils
+    ##
+    # This is generally used when calling DO::Server from a CLI
+    #
+    # ==== Examples:
+    #   [srv1, srv2, srv3].each do |server|
+    #     server.run "long task"
+    #     server.wait # because we want to see all outputs before start with new one
+    #   end
+    #
+    def wait
+      puts "\e[36mPress ENTER to continue...\e[0m"
+      STDIN.gets
+    end
+
+    ##
+    # Ask question to your STDIN.
+    # This command is useful in conjunction with a CLI
+    #
+    # ==== Example
+    #   old_pwd = ask "Tell me the old password of mysql"
+    #   new_pwd = ask "Tell me the new password of mysql"
+    #   run "mysqladmin -u root -p password '#{new_pwd}', :input => old_pwd
+    #
+    def ask(question, allow_blank=false)
+      result = ""
+      loop do
+        log("\e[36m%s: \e[0m" % question, false)
+        result = STDIN.gets.chomp
+        break if allow_blank || result != ""
+      end
+      result
+    end
+
+    ##
+    # Ask a yes/no question and return true if it is equal to y or yes
+    #
+    # ==== Examples:
+    #   if yes?("Do you want to proceed?")
+    #     do_some
+    #   end
+    #
+    def yes?(question)
+      result = ""
+      question += "?" if question[-1] != ??
+      loop do
+        log("\e[36m%s (y/n): \e[0m" % question, false)
+        result = STDIN.gets.chomp
+        break if result =~ /y|yes|n|no/i
+      end
+      return result =~ /y|yes/i
+    end
+  end # Utils
+end # DO

data/lib/do/version.rb

@@ -0,0 +1,3 @@
+module DO
+  VERSION = "0.0.1" unless defined?(DO::VERSION)
+end

data/lib/do.rb

@@ -0,0 +1,27 @@
+DO_PATH = ENV['DO_PATH'] ||= File.expand_path("~/.do") unless defined?(DO_PATH)
+
+module DO
+
+  autoload :Server,   'do/server.rb'
+  autoload :Utils,    'do/utils.rb'
+  autoload :VERSION,  'do/version.rb'
+
+  extend self
+
+  ##
+  # DO loads rakefiles in these locations:
+  #
+  #   ~/do/dorc
+  #   ~/do/*.rake
+  #   ./Do
+  #   ./Dofile
+  #
+  # DO_PATH, default is ~/do.
+  #
+  def recipes
+    @_recipes ||= (
+      %w[dorc *.rake].map { |f| Dir[File.join(DO_PATH, f)] }.flatten +
+      %w[./Do ./Dofile].map { |f| File.expand_path(f) }
+    ).reject { |f| !File.exist?(f) }
+  end
+end # DO

data/recipes/.servorc

@@ -0,0 +1,14 @@
+keys = %w(/Developer/src/LipsiaSoft/lipsiahosting/lib/lipsiarec/recipes/servers/resources/keys/Lipsiasoft.pem)
+server :srv1, 'srv1.lipsiasoft.biz', 'root', :keys => keys
+server :srv2, 'srv2.lipsiasoft.biz', 'root', :keys => keys
+
+plugin "configure-server", "https://raw.github.com/gist/112..."
+
+namespace :status do
+
+  desc "Show processes"
+  task :ps do
+    run "ps aux --sort -rss"
+    wait
+  end
+end

data/spec/fixtures/sample

@@ -0,0 +1,9 @@
+Their sighs, lamentations and loud wailings
+resounded through the starless air,
+so that at first it made me weep;
+Strange utterances, horrible pronouncements,
+words of pain, tones of anger,
+voices shrill and faint, and beating hands,
+all went to make a tumult that will whirl
+forever through that turbid, timeless air,
+like sand that eddies when a whirlwind swirls.

data/spec/server_spec.rb

@@ -0,0 +1,76 @@
+require 'spec_helper'
+
+describe DO::Server do
+  before do
+    keys = %w(/Developer/src/LipsiaSoft/lipsiahosting/lib/lipsiarec/recipes/servers/resources/keys/Lipsiasoft.pem)
+    @server = DO::Server.new(:sho0, 'sho0.lipsiasoft.biz', 'ec2-user', :keys => keys)
+    @server.logger = StringIO.new
+    @fixture = File.expand_path('../fixtures/sample', __FILE__)
+    @fixture_was = File.read(@fixture)
+  end
+
+  it 'should read my uname' do
+    release = @server.run 'uname'
+    release.should match(/Linux/)
+  end
+
+  it 'should upload a something' do
+    @server.upload @fixture, '/tmp/sample'
+    @server.exist?('/tmp/sample').should be_true
+  end
+
+  it 'should download something' do
+    tmp = File.expand_path('./sample')
+    @server.download '/tmp/sample', tmp
+    File.read(tmp).should == @fixture_was
+    FileUtils.rm_rf(tmp)
+  end
+
+  it 'should replace in file' do
+    @server.replace 'eddies', 'dummies', '/tmp/sample'
+    result = @server.read '/tmp/sample'
+    result.should match(/dummies/)
+  end
+
+  it 'should replace everything' do
+    @server.replace :all, 'foo', '/tmp/sample'
+    result = @server.read '/tmp/sample'
+    result.should == 'foo'
+  end
+
+  it 'should not replace if pattern is not valid' do
+    proc {
+      @server.replace :xyz, 'foo', '/tmp/sample'
+    }.should raise_exception
+  end
+
+  it 'should replace with a regex' do
+    @server.upload @fixture, '/tmp/sample'
+    @server.replace /and/, 'AND', '/tmp/sample'
+    result  = @server.read '/tmp/sample'
+    matches = result.scan(/and/i)
+    matches.size.should == 5
+    matches.all? { |m| m == 'AND' }.should be_true
+  end
+
+  it 'should append on bottom' do
+    @server.append '---', '/tmp/sample'
+    result = @server.read '/tmp/sample'
+    result.should match(/---$/)
+    @server.append '~~~', '/tmp/sample', :bottom
+    result = @server.read '/tmp/sample'
+    result.should match(/~~~$/)
+  end
+
+  it 'should append on top' do
+    @server.append '---', '/tmp/sample', :top
+    result = @server.read '/tmp/sample'
+    result.should match(/^---/)
+  end
+
+  it 'should not append if the where condition is not valid' do
+    proc {
+      @server.append 'xyz', '/tmp/sample', :xyz
+    }.should raise_exception
+  end
+end

data/spec/spec_helper.rb

@@ -0,0 +1,19 @@
+require 'rubygems' unless defined?(Gem)
+require 'bundler/setup'
+require 'rspec'
+require 'fileutils'
+require 'do'
+
+module Helper
+  def capture_stdout(&block)
+    stdout_was, $stdout = $stdout, StringIO.new
+    block.call
+    return $stdout
+  ensure
+    $stdout = stdout_was
+  end
+end
+
+RSpec.configure do |config|
+  config.include(Helper)
+end

metadata

@@ -0,0 +1,145 @@
+--- !ruby/object:Gem::Specification 
+name: do
+version: !ruby/object:Gem::Version 
+  hash: 29
+  prerelease: 
+  segments: 
+  - 0
+  - 0
+  - 1
+  version: 0.0.1
+platform: ruby
+authors: 
+- Davide D'Agostino
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2011-08-09 00:00:00 +02:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 63
+        segments: 
+        - 0
+        - 9
+        - 2
+        version: 0.9.2
+  name: rake
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 2
+        - 1
+        - 4
+        version: 2.1.4
+  name: net-ssh
+  version_requirements: *id002
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :runtime
+  requirement: &id003 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ~>
+      - !ruby/object:Gem::Version 
+        hash: 5
+        segments: 
+        - 2
+        - 0
+        - 5
+        version: 2.0.5
+  name: net-sftp
+  version_requirements: *id003
+- !ruby/object:Gem::Dependency 
+  prerelease: false
+  type: :development
+  requirement: &id004 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - ">="
+      - !ruby/object:Gem::Version 
+        hash: 3
+        segments: 
+        - 0
+        version: "0"
+  name: rspec
+  version_requirements: *id004
+description: DO is a thin framework useful to manage remote servers through ssh.
+email: 
+- d.dagostino@lipsiasoft.com
+executables: 
+- doit
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- .gitignore
+- Gemfile
+- README.md
+- Rakefile
+- bin/doit
+- do.gemspec
+- lib/do.rb
+- lib/do/commands.rb
+- lib/do/server.rb
+- lib/do/utils.rb
+- lib/do/version.rb
+- recipes/.servorc
+- spec/fixtures/sample
+- spec/server_spec.rb
+- spec/spec_helper.rb
+has_rdoc: true
+homepage: https://github.com/daddye/do
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.6.2
+signing_key: 
+specification_version: 3
+summary: DO is a thin framework useful to manage remote servers through ssh.
+test_files: 
+- spec/fixtures/sample
+- spec/server_spec.rb
+- spec/spec_helper.rb