do 0.0.3 → 0.1.0

data/Gemfile

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

data/README.md

@@ -11,14 +11,31 @@ So why another one? Basically I need:
 * see perfectly what's happening on my remote servers
 * highly focus on smart actions, upload, download, sudo, replace.
 * manage easily more than one server at same time
-* use same syntax to manage local tasks
+* a use same syntax to manage local tasks
+
+What really is *DO* ?
+
+* some like brew
+* some like rake
+* some like capistrano
+
+All togheter mixed to make your life easier.
+
+As mentioned before do is a fun mix of capistrano, rake, thor and brew.
+
+With *DO* you are be able to do easily common task on your local or remote machine.
+The aim of *DO* is to become the unique and universal tool language that permit you to make
+your own _brew_, _apt-get_ or _yum_ package, same syntax for all your machine.
 
 ## DO - Installation and Setup
 
 ```sh
 $ sudo gem install do
-$ doit setup # setup DO directory
-$ doit -T    # show DO tasks
+$ doit download # download a new recipe with --url=
+$ doit setup    # setup a working home directory
+$ doit version  # show version number
+$ doit list     # show task list
+$ doit help     # show help message
 ```
 
 Now you can edit your `~/.do/dorc` adding your **servers** or **plugins**.
@@ -135,7 +152,7 @@ plugin :vim, 'https://raw.github.com/DAddYE/.do/master/vim.rake'
 However we have a `doit` command for that:
 
 ```sh
-$ doit download[https://raw.github.com/DAddYE/.do/master/l.rake]
+$ doit download --url https://raw.github.com/DAddYE/.do/master/l.rake
 ```
 
 This command add for you a new line in your `~/.do/dorc` and perform:
@@ -150,11 +167,7 @@ file.
 Once this happen you are be able to see new tasks:
 
 ```sh
-$ doit -T
-
-************************************************************
-*                         DO - IT!                         *
-************************************************************
+$ doit list
 
 doit plugin:vim                  # install vim plugin
 doit setup                       # setup a working home directory
@@ -184,7 +197,7 @@ I've also some recipes in my `~/.do` path:
 # ~/.do/configure.rake
 namespace :configure
   desc "upgrade rubygems and install useful gems"
-  task :gems => :ree do
+  task :gems => :ree, :in => :web do
     run "gem update --system" if yes?("Do you want to update rubygems?")
     run "gem install rake"
     run "gem install highline"
@@ -193,18 +206,18 @@ namespace :configure
   end
 
   desc "create motd for each server"
-  task :motd do
+  task :motd, :in => :remote 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
+  task :root_emails, :in => :remote do
     append "\nroot: servers@lipsiasoft.com", "/etc/aliases"
     run "newaliases"
   end
 
   desc "mysql basic configuration"
-  task :mysql => :yum do
+  task :mysql => :yum, :in => :remote do
     run "yum install mysql-server mysql mysql-devel -y"
     run "chkconfig --level 2345 mysqld on"
     run "service mysqld restart"
@@ -228,14 +241,14 @@ $ doit configure:mysql
 any task, ex:
 
 ```rb
-task :mysql => :yum do; ...; end
+task :mysql => :yum, :in => :remote do; ...; end
 ```
 
 That's are some local tasks:
 
 ```rb
 namespace :l do
-  local :setup do
+  task :setup do
     name = File.basename(File.expand_path('.'))
     exit unless yes?('Do you want to setup "%s"?' % name)
     srv = nil
@@ -246,18 +259,18 @@ namespace :l do
 
     if File.exist?('.git')
       exit unless yes?('Project "%s" has already a working repo, do you want remove it?' % name)
-      sh 'rm -rf .git'
+      run '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?")
+    run 'git init'
+    run 'git remote add origin git@lipsiasoft.biz:/%s.git' % name
+    run_task('l:commit') 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'
+  task :commit do
+    run 'git add .'
+    run 'git commit -a'
+    run 'git push origin master'
   end
 end
 ```
@@ -277,8 +290,8 @@ standard rake tasks. *DO* extend `Rake`.
 Sometimes you want to perform a task only on some servers:
 
 ```sh
-$ doit configure:new --only-srv1 --only-srv2
-$ doit configure:new --except-srv1
+$ doit configure:new --srv1 # apply recipes only on srv1
+$ doit configure:new --no-srv1 # apply recipes to all except srv1
 ```
 
 ## DO - Output (Awesome...)

data/Rakefile

@@ -1,8 +1,14 @@
 #!/usr/bin/env rake
-require 'bundler/setup'
+require 'rubygems' unless defined?(Gem)
 require 'bundler/gem_tasks'
 require 'rspec/core/rake_task'
 
+RSpec::Core::RakeTask.new(:spec) do |t|
+  t.rspec_opts = %w(-fs --color --fail-fast)
+end
+
+task :default => :spec
+
 %w(install release).each do |task|
   Rake::Task[task].enhance do
     sh "rm -rf pkg"
@@ -20,12 +26,3 @@ task :bump do
 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

@@ -1,30 +1,6 @@
 #!/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 - IT!".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
+DO::CLI.start(*ARGV)

data/do.gemspec

@@ -14,10 +14,8 @@ Gem::Specification.new do |gem|
   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"
 
   gem.post_install_message  = "\e[32m" + ("*" * 60) + "\n"
   gem.post_install_message += "*" + "DO - IT! $ doit setup".center(58) + "*" + "\n"

data/lib/do/cli.rb

@@ -0,0 +1,14 @@
+module DO
+  module CLI
+    extend self
+
+    def start(*args)
+      DO::Commands.load_recipes
+      args.empty? ? DO::Commands.run_task(:help) : DO::Commands.task_run(*args)
+    rescue DO::Tasks::NotFound
+      puts "\e[31mSorry, \e[1m'%s'\e[0m\e[31m was not found, see available tasks:\e[0m" % args.join(' ')
+      puts
+      DO::Commands.run_task(:list)
+    end
+  end # CLI
+end # DO

data/lib/do/commands.rb

@@ -1,11 +1,10 @@
-require 'rake/dsl_definition'
-require 'rake'
-
 module DO
   module Commands
-    include Rake::DSL
+    include DO::Tasks
     include DO::Utils
 
+    extend self
+
     ##
     # Array of DO::Server defined in our tasks
     #
@@ -13,11 +12,8 @@ module DO
       @_servers ||= []
     end
 
-    ##
-    # An array of DO::Server selected by our remote task
-    #
-    def servers_selected
-      @_servers_selected ||=[]
+    def remote
+      servers.map(&:name)
     end
 
     ##
@@ -27,6 +23,40 @@ module DO
       @_current_server
     end
 
+    ##
+    # Set an option to the given value
+    #
+    def set(option, value)
+      define_method(option) { value }
+    end
+
+    ##
+    # 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) } <<
+        File.expand_path('../common.rb', __FILE__)
+      ).reject { |f| !File.exist?(f) }
+    end
+
+    def load_recipes
+      recipes.each { |f| load_recipe(f) }
+    end
+
+    def load_recipe(path)
+      instance_eval(File.read(path), __FILE__, __LINE__)
+    end
+    alias :load :load_recipe
+
     ##
     # This method define our servers
     #
@@ -39,7 +69,20 @@ module DO
     #
     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 }) }
+      task name do |opts, b|
+        allowed  = opts.map { |k,v| k if remote.include?(k) && v }.compact
+        denied   = opts.map { |k,v| k if remote.include?(k) && v == false }.compact
+        if (allowed.empty? && denied.empty?) ||
+           (!allowed.empty? && allowed.include?(name)) ||
+           (!denied.empty? && !denied.include?(name))
+          @_current_server = servers.find { |s| s.name == name }
+          begin
+            b.arity == 1 ? b.call(opts) : b.call
+          ensure
+            @_current_server = nil
+          end
+        end
+      end
     end
 
     ##
@@ -52,95 +95,33 @@ module DO
     #
     def plugin(name, repo)
       desc "install #{name} plugin"
-      local("plugin:#{name}" => :setup) do
-        log "\e[36m## Installing plugin %s\e[0m" % name
-        Dir.mkdir(DO_PATH) unless File.exist?(DO_PATH)
-        sh "curl --location --progress-bar #{repo} > #{File.join(DO_PATH, '%s.rake' % name)}"
+      namespace :plugin do
+        task(name => :setup) do
+          log "\e[36m## Installing plugin %s\e[0m" % name
+          Dir.mkdir(DO_PATH) unless File.exist?(DO_PATH)
+          path = File.join(DO_PATH, '%s.rake' % name)
+          sh :curl, '--location', '--progress-bar', repo, '>', path
+          load_recipe(path)
+        end
       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
+    # Log text under current_server if available
     #
-    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
+    def log(text="", new_line=true)
+      current_server ? current_server.log(text, new_line) : super(text, new_line)
     end
 
-    alias_method :local, :task
-    alias_method :task, :remote
-
     ##
-    # Log text under current_server if available
+    # Run commands on 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
+    def run(*args)
+      current_server ? current_server.run(*args) : super(*args)
+    end
+
+    def method_missing(method, *args,  &block)
+      current_server && current_server.respond_to?(method) ? current_server.send(method, *args) : super(method, *args,  &block)
     end
   end # Commands
 end # DO
-
-self.extend DO::Commands
-
-load(File.expand_path('../common.rb', __FILE__))

data/lib/do/common.rb

@@ -1,41 +1,40 @@
 ##
 # Common tasks performed by doit
 #
-
-local :servers do
-  servers_selected.replace(servers)
-end
-
-local :download, [:recipe] => :setup  do |t, options|
-  if options[:recipe]
-    name = File.basename(options[:recipe], '.rake')
+desc "download a new recipe with --url="
+task :download => :setup  do |options|
+  if options[:url]
+    name = File.basename(options[:url], '.rake')
     rc   = File.join(DO_PATH, 'dorc')
     buf  = File.read(rc)
 
-    if buf.include?(options[:recipe])
-      log "\e[31mYour '\e[1m%s\e[31m' already has the plugin '\e[1m%s\e[0m'" % [rc, options[:recipe]]
+    if buf.include?(options[:url])
+      log "'\e[1m%s\e[0m' already has plugin '\e[1m%s\e[0m'" % [rc, options[:url]]
+      log
       log "Please run: $ doit plugin:%s" % name
       exit
     else
-      plugin = "plugin :%s, '%s'\n" % [name, options[:recipe]]
+      plugin = "plugin :%s, '%s'\n" % [name, options[:url]]
       File.open(rc, 'a') { |f| f.write plugin }
-      load(rc)
-      Rake::Task['plugin:%s' % name].invoke
+      load_recipe(rc)
+      task_run('plugin:%s' % name)
     end
   else
     log "\e[31mYou must provide a recipe path ex:\e[0m"
     log
-    log "  $ doit download[https://raw.github.com/DAddYE/.do/master/l.rake]"
+    log "  $ doit download --url=https://raw.github.com/DAddYE/.do/master/l.rake"
     log
   end
 end
 
 desc "setup a working home directory"
-local :setup do
+task :setup do |options|
   Dir.mkdir(DO_PATH) unless File.exist?(DO_PATH)
   hrc = File.expand_path("~/.dorc")
   orc = File.join(DO_PATH, 'dorc')
-  unless File.exist?(orc)
+  if File.exist?(orc)
+    log "Config already exist in your %s path" % DO_PATH unless options[:dependency]
+  else
     template = <<-RUBY.gsub(/^ {6}/, '')
       ##
       # Server definitions
@@ -54,3 +53,35 @@ local :setup do
   end
   sh 'ln -s %s %s' % [orc, hrc] unless File.exist?(hrc)
 end
+
+desc "show version number"
+task :version do
+  log "\e[1mDO\e[0m version %s" % DO::VERSION
+end
+
+desc "show task list"
+task :list do
+  formatted = tasks.map { |t| ["\e[1mdoit\e[0m\e[34m %s:%s\e[0m" % [t[:namespace], t[:name]], t[:desc]] }
+  formatted.each { |f| f[0].gsub!(/\s:/, ' ') }
+  formatted.reject! { |t, desc| desc == '' }
+  max = formatted.max { |a,b| a[0].size <=> b[0].size }[0].size
+  log formatted.map { |t, desc| "%s \e[0m# %s" % [t.ljust(max+2), desc] }.join("\n")
+end
+
+desc "show help message"
+task :help do
+  log <<-TEXT.gsub(/^ {4}/, '')
+    Usage \e[1mdoit\e[0m task [options]
+
+    Available Tasks:
+
+  TEXT
+
+  run_task(:list)
+
+  log <<-TEXT.gsub(/^ {4}/, '')
+
+    Options:
+      Each task can accept multiple options
+  TEXT
+end

data/lib/do/parser.rb

@@ -0,0 +1,38 @@
+module DO
+  class Parser < Hash
+
+    def initialize(*args)
+      options = {}
+      args.each_with_index do |arg, i|
+        case arg
+          # --foo=bar
+          when /=/
+            key, value = *arg.split("=")
+            options[key.sub(/^-{1,2}/,'').to_sym] = value
+          # --no-foo
+          when /^-{1,2}no-(.+)/
+            options[$1.to_sym] = false
+          # --foo bar
+          # --foo
+          # -foo
+          when /^-{1,2}(.+)/
+            value = args[i+1] && args[i+1] != /^--/ ? args.delete_at(i+1) : true
+            options[$1.to_sym] = value
+        end
+      end
+
+      # Automatically map values
+      options.each do |k, v|
+        case v
+          when /^true$/i   then options[k] = true
+          when /^false$/i  then options[k] = false
+          when /^\d+$/     then options[k] = v.to_i
+          when /^[\d\.]+$/ then options[k] = v.to_f
+          when /,/         then options[k] = v.split(",")
+        end
+      end
+
+      self.replace(options)
+    end
+  end # Parser
+end # DO

data/lib/do/server.rb

@@ -5,10 +5,7 @@ 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
@@ -20,16 +17,14 @@ module DO
     #
     # ==== 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
+    # using DO::Server::DO_LOGGER_FORMAT, by default we have a nice
     # colored version like:
     #
     #   srv1@root ~ # ls -al
@@ -37,11 +32,10 @@ module DO
     # If you don't like colors or our format feel free to edit:
     #
     # ==== Examples:
-    #   DO::Server::LOG_FORMAT = "%s@%s$ %s"
+    #   DO::Server::DO_LOGGER_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]
+      super(DO_LOGGER_FORMAT % [user, name, text], new_line)
     end
 
     ##
@@ -76,21 +70,34 @@ module DO
     def run(*args)
       options = args.last.is_a?(Hash) ? args.pop : {}
       cmd = args.join(" ")
-      cmd = "su #{options[:as]} -c '#{cmd.gsub(/'/, "\'")}'" if options[:as]
+      if options[:as]
+        if options[:as] == 'root'
+          cmd = "sudo #{cmd.gsub(/'/, "\'")}"
+        else
+          cmd = "su #{options[:as]} -c '#{cmd.gsub(/'/, "\'")}'"
+        end
+      end
       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]
+      ssh.open_channel do |channel|
+        channel.request_pty do |c, success|
+          raise "could not request pty" unless success
+          channel.exec cmd
+          channel.on_data do |c_, data|
+            result << data
+            DO_LOGGER.print(data) unless options[:silent]
+            if options[:input]
+              match = options[:match] || /password:/i
+              if data =~ match
+                options[:input] += "\n" if options[:input][-1] != ?\n
+                channel.send_data(options[:input])
+                DO_LOGGER.puts(options[:input]) unless options[:silent] || data =~ /password:/i
+              end
+            end
           end
         end
       end
+      ssh.loop
       result.chomp
     end