pdo 0.0.3 → 0.0.5

data/bin/pdo

@@ -3,17 +3,15 @@
 lib = File.expand_path("#{File.dirname(__FILE__)}/../lib")
 $LOAD_PATH.unshift(lib) unless $LOAD_PATH.include? lib
 
-#require 'pdo/version'
-
 require 'ostruct'
 require 'pdo'
 require 'pdo/logging'
 require 'pdo/host'
-require 'pdo/pdoopts'
+require 'pdo/opts'
 require 'pdo/task'
 require 'pp'
 
-include Logging
+include PDO
 
 opts = OpenStruct.new
 # setting default values
@@ -26,7 +24,7 @@ opts.nohush = false
 
 begin
   # parse ARGV; defaults in opts is overwritten if needed
-  opts = PdoOpts.parse(ARGV, opts)
+  opts = Opts.parse(ARGV, opts)
   logger.debug { opts }
 rescue => err
   logger.error { "#{err.class}: #{err.message}" }
@@ -34,7 +32,6 @@ rescue => err
   exit 1
 end
 
-include Host
 Host.load_file opts.host_definition_file
 
 excludes = []
@@ -82,7 +79,7 @@ if opts.groups then
         end
       end
     end
-    pdo = PDO.new(tasks, opts.thread_num)
+    pdo = Worker.new(tasks, opts.thread_num)
     pdo.run
   else 
     opts.groups.each do |key|

data/lib/pdo.rb

@@ -2,88 +2,90 @@
 
 require 'pdo/logging'
 
-class PDO
-  include Process
-  include Logging
+module PDO
+  class Worker
+    include Process
+    include Logging
 
-  def initialize(tasks, thread_num)
-    @tasks = tasks
-    @thread_num = thread_num
-  end
+    def initialize(tasks, thread_num)
+      @tasks = tasks
+      @thread_num = thread_num
+    end
 
-  def run
-  # run first spawns a set of threads, tells them to execute the task
-  # queue. it then loop through the current Thread list (note
-  # Thread.list returns all running and sleeping threads), and outputs
-  # those new data.
-  # for the spawned threads, they execute one task, then wait for their
-  # data to be picked up by the main thread, then do the next task.
+    def run
+    # run first spawns a set of threads, tells them to execute the task
+    # queue. it then loop through the current Thread list (note
+    # Thread.list returns all running and sleeping threads), and outputs
+    # those new data.
+    # for the spawned threads, they execute one task, then wait for their
+    # data to be picked up by the main thread, then do the next task.
 
-    return 1 if @tasks.size == 0
+      return 1 if @tasks.size == 0
 
-    n = @thread_num < @tasks.size ? @thread_num : @tasks.size
-    1.upto(n) do
-      Thread.new do
-        while true do
-          logger.info "#{Thread.current.object_id} started."
-          begin
-            execute(@tasks.next)
-            # presumably new data is ready, thus i stop. 
-            # main thread will read :output and then wakes me up.
-            Thread.stop
-          rescue
-            logger.info "No more task for #{Thread.current.object_id}."
-            break
+      n = @thread_num < @tasks.size ? @thread_num : @tasks.size
+      1.upto(n) do
+        Thread.new do
+          while true do
+            logger.info "#{Thread.current.object_id} started."
+            begin
+              execute(@tasks.next)
+              # presumably new data is ready, thus i stop. 
+              # main thread will read :output and then wakes me up.
+              Thread.stop
+            rescue
+              logger.info "No more task for #{Thread.current.object_id}."
+              break
+            end
           end
         end
       end
-    end
 
-    loop do
-      # break because the only left thread must be the main thread.
-      break if Thread.list.size == 1
+      loop do
+        # break because the only left thread must be the main thread.
+        break if Thread.list.size == 1
 
-      Thread.list.each do |t|
-        next if t == Thread.main
-        if t.key? :output and t.key? :new_data and t[:new_data] then
-          logger.info "#{t.object_id} finished."
-          puts "=== #{t[:target]} ==="
-          t[:output].each {|x| puts x}
-          # puts t[:output].join('').gsub("\n", ' | ').chomp(' | ')
-          t[:new_data] = false
-          # wakes up the thread
-          t.run
+        Thread.list.each do |t|
+          next if t == Thread.main
+          if t.key? :output and t.key? :new_data and t[:new_data] then
+            logger.info "#{t.object_id} finished."
+            puts "=== #{t[:target]} ==="
+            t[:output].each {|x| puts x}
+            # puts t[:output].join('').gsub("\n", ' | ').chomp(' | ')
+            t[:new_data] = false
+            # wakes up the thread
+            t.run
+          end
         end
       end
     end
-  end
 
-  def execute(task)
-  # execute forks a child process to run the task, then saves the
-  # output from the child process into a thread local variable, marks
-  # the :new_data tag.
+    def execute(task)
+    # execute forks a child process to run the task, then saves the
+    # output from the child process into a thread local variable, marks
+    # the :new_data tag.
 
-    raise "no task" if task.nil?
+      raise "no task" if task.nil?
 
-    target, cmd = task
+      target, cmd = task
 
-    open("|-") do |child_io|
-      if child_io
-        # The waitpid statement below causes the program to hang when
-        # running some commands, such as wget.
-        # waitpid child_io.pid
-        Thread.current[:output] = child_io.readlines
-        Thread.current[:new_data] = true
-        Thread.current[:target] = target
-      else
-        STDIN.close
-        STDERR.reopen(STDOUT)
-        exec(*cmd)
+      open("|-") do |child_io|
+        if child_io
+          # The waitpid statement below causes the program to hang when
+          # running some commands, such as wget.
+          # waitpid child_io.pid
+          Thread.current[:output] = child_io.readlines
+          Thread.current[:new_data] = true
+          Thread.current[:target] = target
+        else
+          STDIN.close
+          STDERR.reopen(STDOUT)
+          exec(*cmd)
+        end
       end
-    end
 
-  end
+    end
 
-end
+  end # class Worker
+end # module PDO
 
 # vim: set et ts=2 sts=2 sw=2 si sta :

data/lib/pdo/host.rb

@@ -4,186 +4,188 @@ require 'pp'
 require 'yaml'
 require_relative 'logging'
 
-module Host
-
-  include Logging
-
-  @@recursive_level = 9
-  def self.recursive_level=(level)
-    @@recursive_level = level
-  end
-  def self.recursive_level
-    @@recursive_level
-  end
-
-  def self.load_file(def_file=nil)
-    if def_file then
-      files = [ def_file ]
-    else
-      files = [ "/etc/pdo/pdo.yaml", "#{ENV['HOME']}/.pdo/pdo.yaml", ]
-    end
-
-    hosts = {}
-    files.each do |f|
-      begin
-        hosts.update(YAML::load_file(f))
-      rescue => ex
-        logger.warn { "#{ex.class}: #{ex.message}" }
-        logger.debug { ex.backtrace.join "\n" }
-      end
-    end
-    return @@host_hash = hosts
+module PDO
+  module Host
 
-  end
+    include Logging
 
-  def expand_group(group, level)
-  # given a group, recursively expand it into a list of hosts.
-  # if the group can't expand to a list of hosts, return that group.
-  # if there are exception expanding the group, return an empty list.
-  
-    hosts = []
-
-    level += 1
-    if level > @@recursive_level then
-      logger.warn "circle detected in the host definition file."
-      return []
+    @@recursive_level = 9
+    def self.recursive_level=(level)
+      @@recursive_level = level
+    end
+    def self.recursive_level
+      @@recursive_level
     end
 
-    # get the hash value
-    keys = group.gsub(/^\//,'').split('/')
-    list_of_hosts = @@host_hash
-    keys.each do |k|
-      begin
-        if list_of_hosts.key? k then
-          list_of_hosts = list_of_hosts[k]
-        else
-          # if any part of the group name is not a key in the
-          # host hash, then return the group.
-          return [ group ]
+    def self.load_file(def_file=nil)
+      if def_file then
+        files = [ def_file ]
+      else
+        files = [ "/etc/pdo/pdo.yaml", "#{ENV['HOME']}/.pdo/pdo.yaml", ]
+      end
+
+      hosts = {}
+      files.each do |f|
+        begin
+          hosts.update(YAML::load_file(f))
+        rescue => ex
+          logger.warn { "#{ex.class}: #{ex.message}" }
+          logger.debug { ex.backtrace.join "\n" }
         end
-      rescue => ex
-        logger.warn {
-          "failed to get hash value for #{group.inspect}. "\
-          'possibly an error in the yaml file.'
-        }
-        logger.debug { ex.backtrace.join "\n" }
-        return []
       end
+      return @@host_hash = hosts
+
     end
+
+    def expand_group(group, level)
+    # given a group, recursively expand it into a list of hosts.
+    # if the group can't expand to a list of hosts, return that group.
+    # if there are exception expanding the group, return an empty list.
     
-    # return empty array if the group is empty.
-    return [] if list_of_hosts.nil? 
+      hosts = []
 
-    if list_of_hosts.is_a? Hash then
-      list_of_hosts.keys.each do |key|
-        hosts += expand_group("#{group}/#{key}".squeeze('/'), level)
+      level += 1
+      if level > @@recursive_level then
+        logger.warn "circle detected in the host definition file."
+        return []
       end
-    elsif list_of_hosts.is_a? Array then
-      list_of_hosts.each do |h|
-        if not h.is_a? String then
+
+      # get the hash value
+      keys = group.gsub(/^\//,'').split('/')
+      list_of_hosts = @@host_hash
+      keys.each do |k|
+        begin
+          if list_of_hosts.key? k then
+            list_of_hosts = list_of_hosts[k]
+          else
+            # if any part of the group name is not a key in the
+            # host hash, then return the group.
+            return [ group ]
+          end
+        rescue => ex
           logger.warn {
-            "invalid host or group format: #{h.inspect}\n"\
+            "failed to get hash value for #{group.inspect}. "\
             'possibly an error in the yaml file.'
           }
-          next
+          logger.debug { ex.backtrace.join "\n" }
+          return []
+        end
+      end
+      
+      # return empty array if the group is empty.
+      return [] if list_of_hosts.nil? 
+
+      if list_of_hosts.is_a? Hash then
+        list_of_hosts.keys.each do |key|
+          hosts += expand_group("#{group}/#{key}".squeeze('/'), level)
         end
-        if h.include? "/" then
-          hosts += expand_group(h, level)
-        else
-          hosts << h
+      elsif list_of_hosts.is_a? Array then
+        list_of_hosts.each do |h|
+          if not h.is_a? String then
+            logger.warn {
+              "invalid host or group format: #{h.inspect}\n"\
+              'possibly an error in the yaml file.'
+            }
+            next
+          end
+          if h.include? "/" then
+            hosts += expand_group(h, level)
+          else
+            hosts << h
+          end
         end
+      else
+        logger.fatal "I don't know how to handle this. "\
+                       'possibly an error in the yaml file.'
+        exit 1
       end
-    else
-      logger.fatal "I don't know how to handle this. "\
-                     'possibly an error in the yaml file.'
-      exit 1
+      return hosts
+
+    end # expand_group
+    private :expand_group
+
+    def get_hosts(group, step)
+      hosts = []
+      hosts += expand_group(group, 0)
+      hosts.uniq!
+      hosts = stepping hosts, step
+      return hosts
+      
     end
-    return hosts
-
-  end # expand_group
-  private :expand_group
 
-  def get_hosts(group, step)
-    hosts = []
-    hosts += expand_group(group, 0)
-    hosts.uniq!
-    hosts = stepping hosts, step
-    return hosts
-    
-  end
+    def stepping(hosts, step)
+      unless hosts.is_a? Array or step.is_a? Array then
+        logger.warn "both hosts or step should be array."
+        return nil
+      end
+      
+      start, stride = step[0].to_i, step[1].to_i
+      # if stride > 0, stepping forward
+      # if stride < 0, stepping backward
+      # if stride == 0, no stepping
+      # if start or stride makes no sense, no stepping either
+      index = case
+              when stride > 0 then
+                (start-1...hosts.size).step(stride).to_a
+              when stride < 0 then
+                (-start+1..0).step(-stride).to_a.map {|x| -x}
+              else []
+              end
+
+      unless index.empty? then
+        alist = []
+        index.each do |i|
+          alist << hosts[i]
+        end
+        hosts = alist
+      end
 
-  def stepping(hosts, step)
-    unless hosts.is_a? Array or step.is_a? Array then
-      logger.warn "both hosts or step should be array."
-      return nil
+      return hosts
     end
-    
-    start, stride = step[0].to_i, step[1].to_i
-    # if stride > 0, stepping forward
-    # if stride < 0, stepping backward
-    # if stride == 0, no stepping
-    # if start or stride makes no sense, no stepping either
-    index = case
-            when stride > 0 then
-              (start-1...hosts.size).step(stride).to_a
-            when stride < 0 then
-              (-start+1..0).step(-stride).to_a.map {|x| -x}
-            else []
-            end
-
-    unless index.empty? then
-      alist = []
-      index.each do |i|
-        alist << hosts[i]
-      end
-      hosts = alist
+
+    def show_hosts
+      pp @@host_hash
     end
 
-    return hosts
-  end
-
-  def show_hosts
-    pp @@host_hash
-  end
-
-  def get_sub_groups(group)
-
-    keys = group.gsub(/^\//, '').split('/')
-    pointer = @@host_hash
-    keys.each do |k|
-      begin
-        if pointer.key? k then
-          pointer = pointer[k]
-        else
-          # if any part of the given group name is not a key in the
-          # host hash, then return an empty array.
-          return [ ]
+    def get_sub_groups(group)
+
+      keys = group.gsub(/^\//, '').split('/')
+      pointer = @@host_hash
+      keys.each do |k|
+        begin
+          if pointer.key? k then
+            pointer = pointer[k]
+          else
+            # if any part of the given group name is not a key in the
+            # host hash, then return an empty array.
+            return [ ]
+          end
+        rescue => ex
+          logger.warn {
+            "failed to get hash value for #{group.inspect}. "\
+            'maybe a wrong key is specifid?'
+          }
+          logger.debug { ex.backtrace.join "\n" }
+          return []
         end
-      rescue => ex
-        logger.warn {
-          "failed to get hash value for #{group.inspect}. "\
-          'maybe a wrong key is specifid?'
-        }
-        logger.debug { ex.backtrace.join "\n" }
-        return []
       end
-    end
 
-    # return empty array if the group is empty.
-    return [] if pointer.nil? 
-
-    if pointer.is_a? Hash then
-      return pointer.keys
-    elsif pointer.is_a? Array then
-      return pointer
-    else
-      logger.fatal "I don't know how to handle this. "\
-                    'possibly an error in the yaml file.'
-      exit 1
+      # return empty array if the group is empty.
+      return [] if pointer.nil? 
+
+      if pointer.is_a? Hash then
+        return pointer.keys
+      elsif pointer.is_a? Array then
+        return pointer
+      else
+        logger.fatal "I don't know how to handle this. "\
+                      'possibly an error in the yaml file.'
+        exit 1
+      end
+      
     end
-    
-  end
 
-end # module Host
+  end # module Host
+end # module PDO
 
 # vim: set et ts=2 sts=2 sw=2 si sta :

data/lib/pdo/logging.rb

@@ -4,28 +4,30 @@ require 'log4r'
 require 'log4r/yamlconfigurator'
 require 'log4r/outputter/datefileoutputter'
 
-module Logging
+module PDO
+  module Logging
 
-  include Log4r
-  # set the default log directory
-  Log4r::YamlConfigurator['LOGDIR'] =
-    File.expand_path("#{File.dirname(__FILE__)}/../../log")
+    include Log4r
+    # set the default log directory
+    Log4r::YamlConfigurator['LOGDIR'] =
+      File.expand_path("#{File.dirname(__FILE__)}/../../log")
 
-  def logger
+    def logger
 
-    return @logger if @logger
+      return @logger if @logger
 
-    conf_dir = File.expand_path("#{File.dirname(__FILE__)}/../../conf")
+      conf_dir = File.expand_path("#{File.dirname(__FILE__)}/../../conf")
 
-    [conf_dir, '/etc/pdo', "#{ENV['HOME']}/.pdo"].each { |dir|
-      conf = "#{dir}/log4r.yaml"
-      Log4r::YamlConfigurator.load_yaml_file conf if File.exists? conf
-    }
+      [conf_dir, '/etc/pdo', "#{ENV['HOME']}/.pdo"].each { |dir|
+        conf = "#{dir}/log4r.yaml"
+        Log4r::YamlConfigurator.load_yaml_file conf if File.exists? conf
+      }
 
-    @logger = Logger[self.class.to_s] || Logger['pdo']
+      @logger = Logger[self.class.to_s] || Logger['pdo']
 
-  end
+    end
 
-end # module Logging
+  end # module Logging
+end # module PDO
 
 # vim: set et ts=2 sts=2 sw=2 si sta :

data/lib/pdo/opts.rb

@@ -0,0 +1,95 @@
+#!/usr/bin/env ruby
+
+require 'optparse'
+
+module PDO
+  class Opts
+    def self.parse(args, opts)
+      op = OptionParser.new
+      op.set_summary_width 15
+
+      op.banner = "pdo [opts]"
+      op.separator ""
+      op.separator "Specific options:"
+
+      op.on('-c CMD', 'the command to be executed',
+            "if CMD equals to '-', then read command from stdin") do |cmd|
+        if cmd == '-' then
+          opts.cmd = $stdin.read
+        else
+          opts.cmd = cmd
+        end
+      end
+
+      op.on('--count', 'count the number of hosts') do |count|
+        opts.count = true
+      end
+
+      op.on('--enum', 'enumerate the hosts') do |enum|
+        opts.enum = true
+      end
+
+      op.on('-f <name>', 
+            'name of the alternative host definition file') do |fn|
+        opts.host_definition_file = fn
+      end
+
+      op.on('-g <name1,name2,...>', Array,
+            'comma separated group or host names') do |groups|
+        opts.groups = groups
+      end
+
+      op.on('-l', 'run the command CMD locally') do 
+        opts.local = true
+      end
+
+      op.on('--step <m,n>', Array,
+            'stepping the hosts, m and n must be integers;',
+            'if n > 0, stepping forward; if n < 0 stepping',
+            'backward') do |step|
+        opts.step = [step[0].to_i, step[1].to_i]
+      end
+
+      op.on('--sshopts <key1=val1,key2=val2,...>', Array, 
+            'ssh options as described in "man ssh_config"') do |sshopts|
+        opts.sshopts = {} unless opts.sshopts
+        sshopts.each do |opt|
+          key, val = opt.split '='
+          opts.sshopts[:"#{key}"] = val if key and val
+        end
+      end
+
+      op.on('-t INTEGER', Integer, 'number of threads') do |thread_num|
+        if thread_num < 0 then
+          raise ArgumentError,
+                "thread number must be greater or equal to zero"
+        end
+        opts.thread_num = thread_num
+      end
+
+      op.on('-x <name1,name2,...>', Array,
+            'comma separated group or host names, which should be',
+            'excluded from the final list') do |e_groups|
+        opts.e_groups = e_groups
+      end
+
+      op.on('-y', 'do not confirm, execute immediately') do 
+        opts.confirm_before_execute = false
+      end
+
+      op.separator ""
+      op.separator "Common options:"
+
+      op.on_tail('-h', '--help', 'this help') do
+        puts op.help
+        exit 0
+      end
+
+      op.parse!(args)
+      return opts
+
+    end # self.parse()
+  end # class Opts
+end # module PDO
+
+# vim: set et ts=2 sts=2 sw=2 si sta :

data/lib/pdo/task.rb

@@ -2,102 +2,104 @@
 
 require_relative 'logging'
 
-class SSHCmd
-  include Logging
+module PDO
+  class SSHCmd
+    include Logging
 
-  def initialize(local, sshopts)
+    def initialize(local, sshopts)
 
-    @defaults = {
-      :user => 'root',
-      :port => '22',
-      :ssh  => '/usr/bin/ssh',
-      :sshopts  => {
-        :ConnectTimeout         => '60',
-        :StrictHostKeyChecking  => 'no',
-      },
-    }
-    @local = local
-    @sshopts = @defaults[:sshopts]
-    @sshopts = @defaults[:sshopts].update sshopts if sshopts
-    logger.debug { @sshopts.inspect }
-  end
-  
-  def form(host, cmd)
-    if host.match(/^(?:(\w+)@)?(\w+(?:\.\w+)*)(?::(\d+))?$/) then
-      user, host, port = $1, $2, $3
+      @defaults = {
+        :user => 'root',
+        :port => '22',
+        :ssh  => '/usr/bin/ssh',
+        :sshopts  => {
+          :ConnectTimeout         => '60',
+          :StrictHostKeyChecking  => 'no',
+        },
+      }
+      @local = local
+      @sshopts = @defaults[:sshopts]
+      @sshopts = @defaults[:sshopts].update sshopts if sshopts
+      logger.debug { @sshopts.inspect }
     end
+    
+    def form(host, cmd)
+      if host.match(/^(?:(\w+)@)?(\w+(?:\.\w+)*)(?::(\d+))?$/) then
+        user, host, port = $1, $2, $3
+      end
 
-    cmd = cmd.dup # without dup, all tasks refer to the same
-    cmd.strip!
-    cmd.gsub! '_USER_', user ? user : @defaults[:user] 
-    cmd.gsub! '_HOST_', host 
-    cmd.gsub! '_PORT_', port ? port : @defaults[:port] 
-    # when opts.cmd == '-', the command is read from stdin.
-    # in this case multiple lines can be entered. here I'm doing some
-    # simple substitution for "\n".
-    cmd.gsub! "\n", '; '
+      cmd = cmd.dup # without dup, all tasks refer to the same
+      cmd.strip!
+      cmd.gsub! '_USER_', user ? user : @defaults[:user] 
+      cmd.gsub! '_HOST_', host 
+      cmd.gsub! '_PORT_', port ? port : @defaults[:port] 
+      # when opts.cmd == '-', the command is read from stdin.
+      # in this case multiple lines can be entered. here I'm doing some
+      # simple substitution for "\n".
+      cmd.gsub! "\n", '; '
 
-    # escape "`$ characters in cmd, unless they're already escaped.
-    if RUBY_VERSION.to_f < 1.9 then
-      # v1.8 dose not support negative look-behind assertion, thus
-      # doing it in 2 steps.
-      if cmd.match /["`$]/ then
-        if not cmd.match /['\\]["`$]/ then
-          cmd.gsub! /(["`$])/, '\\\\\1'
+      # escape "`$ characters in cmd, unless they're already escaped.
+      if RUBY_VERSION.to_f < 1.9 then
+        # v1.8 dose not support negative look-behind assertion, thus
+        # doing it in 2 steps.
+        if cmd.match /["`$]/ then
+          if not cmd.match /['\\]["`$]/ then
+            cmd.gsub! /(["`$])/, '\\\\\1'
+          end
         end
+      else
+        cmd.gsub! /(?<!['\\])(["`$])/, '\\\\\1'
       end
-    else
-      cmd.gsub! /(?<!['\\])(["`$])/, '\\\\\1'
-    end
 
-    if @local then
-      return cmd
-    else
-      ssh = @defaults[:ssh]
-      ssh = [ ssh, '-l', "#{user}"].join ' ' if user
-      ssh = [ ssh, '-p', "#{port}"].join ' ' if port
-      @sshopts.each do |k, v| 
-        ssh = [ssh, '-o', "#{k}=#{v}"].join ' '
+      if @local then
+        return cmd
+      else
+        ssh = @defaults[:ssh]
+        ssh = [ ssh, '-l', "#{user}"].join ' ' if user
+        ssh = [ ssh, '-p', "#{port}"].join ' ' if port
+        @sshopts.each do |k, v| 
+          ssh = [ssh, '-o', "#{k}=#{v}"].join ' '
+        end
+        ssh = [ ssh, "#{host}", "\"#{cmd}\""].join ' '
+        return ssh
       end
-      ssh = [ ssh, "#{host}", "\"#{cmd}\""].join ' '
-      return ssh
     end
   end
-end
 
-class Task
-  include Logging
+  class Task
+    include Logging
 
-  def initialize
-    @task_q = Queue.new
-  end
+    def initialize
+      @task_q = Queue.new
+    end
 
-  def add(task)
-    @task_q << task
-  end
+    def add(task)
+      @task_q << task
+    end
 
-  def next
-    begin
-      @task_q.deq(non_block=true)
-    rescue ThreadError
-      nil
+    def next
+      begin
+        @task_q.deq(non_block=true)
+      rescue ThreadError
+        nil
+      end
     end
-  end
 
-  def size
-    @task_q.length
-  end
+    def size
+      @task_q.length
+    end
 
-  def print_all
-    tmp_q = Queue.new
-    while not @task_q.empty? do
-      task = @task_q.deq
-      printf "%s\n", task
-      tmp_q << task
+    def print_all
+      tmp_q = Queue.new
+      while not @task_q.empty? do
+        task = @task_q.deq
+        printf "%s\n", task
+        tmp_q << task
+      end
+      @task_q = tmp_q
     end
-    @task_q = tmp_q
-  end
 
-end
+  end # class SSHCmd
+end # module PDO
 
 # vim: set et ts=2 sts=2 sw=2 si sta :

data/lib/pdo/version.rb

@@ -1,3 +1,3 @@
-module Pdo
-  VERSION = "0.0.3"
+module PDO
+  VERSION = "0.0.5"
 end

data/pdo.gemspec

@@ -6,7 +6,7 @@ require 'pdo/version'
 Gem::Specification.new do |gem|
   gem.name          = 'pdo'
   gem.license       = 'MIT'
-  gem.version       = Pdo::VERSION
+  gem.version       = PDO::VERSION
   gem.authors       = ['bqbn']
   gem.email         = ['bqbn@openken.com']
   gem.description   = 'pdo is a wrapper for running commands on or '\

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: pdo
 version: !ruby/object:Gem::Version
-  version: 0.0.3
+  version: 0.0.5
   prerelease: 
 platform: ruby
 authors:
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: bin
 cert_chain: []
-date: 2013-05-20 00:00:00.000000000 Z
+date: 2013-10-15 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: log4r
@@ -47,7 +47,7 @@ files:
 - lib/pdo.rb
 - lib/pdo/host.rb
 - lib/pdo/logging.rb
-- lib/pdo/pdoopts.rb
+- lib/pdo/opts.rb
 - lib/pdo/task.rb
 - lib/pdo/version.rb
 - log/.gitignore

data/lib/pdo/pdoopts.rb

@@ -1,94 +0,0 @@
-#!/usr/bin/env ruby
-
-require 'optparse'
-
-class PdoOpts
-  def self.parse(args, opts)
-    op = OptionParser.new
-    op.set_summary_width 15
-
-    op.banner = "pdo [opts]"
-    op.separator ""
-    op.separator "Specific options:"
-
-    op.on('-c CMD', 'the command to be executed',
-          "if CMD equals to '-', then read command from stdin") do |cmd|
-      if cmd == '-' then
-        opts.cmd = $stdin.read
-      else
-        opts.cmd = cmd
-      end
-    end
-
-    op.on('--count', 'count the number of hosts') do |count|
-      opts.count = true
-    end
-
-    op.on('--enum', 'enumerate the hosts') do |enum|
-      opts.enum = true
-    end
-
-    op.on('-f <name>', 
-          'name of the alternative host definition file') do |fn|
-      opts.host_definition_file = fn
-    end
-
-    op.on('-g <name1,name2,...>', Array,
-          'comma separated group or host names') do |groups|
-      opts.groups = groups
-    end
-
-    op.on('-l', 'run the command CMD locally') do 
-      opts.local = true
-    end
-
-    op.on('--step <m,n>', Array,
-          'stepping the hosts, m and n must be integers;',
-          'if n > 0, stepping forward; if n < 0 stepping',
-          'backward') do |step|
-      opts.step = [step[0].to_i, step[1].to_i]
-    end
-
-    op.on('--sshopts <key1=val1,key2=val2,...>', Array, 
-          'ssh options as described in "man ssh_config"') do |sshopts|
-      opts.sshopts = {} unless opts.sshopts
-      sshopts.each do |opt|
-        key, val = opt.split '='
-        opts.sshopts[:"#{key}"] = val if key and val
-      end
-    end
-
-    op.on('-t INTEGER', Integer, 'number of threads') do |thread_num|
-      if thread_num < 0 then
-        raise ArgumentError,
-              "thread number must be greater or equal to zero"
-      end
-      opts.thread_num = thread_num
-    end
-
-    op.on('-x <name1,name2,...>', Array,
-          'comma separated group or host names, which should be',
-          'excluded from the final list') do |e_groups|
-      opts.e_groups = e_groups
-    end
-
-    op.on('-y', 'do not confirm, execute immediately') do 
-      opts.confirm_before_execute = false
-    end
-
-    op.separator ""
-    op.separator "Common options:"
-
-    op.on_tail('-h', '--help', 'this help') do
-      puts op.help
-      exit 0
-    end
-
-    op.parse!(args)
-    return opts
-
-  end # self.parse()
-
-end
-
-# vim: set et ts=2 sts=2 sw=2 si sta :