pdo 0.0.1

checksums.yaml

@@ -0,0 +1,15 @@
+---
+!binary "U0hBMQ==":
+  metadata.gz: !binary |-
+    ZjJkNzY1MWMyNjZiODFiMjY2ZDliZDIyZGMyNTkxNjM1MmJjNTQwYg==
+  data.tar.gz: !binary |-
+    NzVmYWRhOTQwMzdmNGYwOGY5YWVlN2ZjMzIzM2Y3ZWQ5MThjMjRmMQ==
+!binary "U0hBNTEy":
+  metadata.gz: !binary |-
+    YjNlM2QyMGEyY2M0Nzg3YzFlODhlNWQzMGNlYWE4NGRhZmI0NWQ1NmYyYWZi
+    NTk3MDRiNWZjOWY2ZDFkYjQ5ZGI5ZDExZDU2ZGQwNmUwYWM0NjU1NzBjMWJi
+    OWQzMzZjYmRjZTI2YzE3MDNkMGFmMjdkMjc0MDU5Mzk4YzYyMmM=
+  data.tar.gz: !binary |-
+    OGJjMmU2MTk1YTJjMzAzNzIwY2E3NDBjNjc0MjAxYWMwZDVlMTExYWNjZTA3
+    NTFkMjk4Zjc2ZTg3YWUzMTVkMDE5ODQ3ZDY3YzQ3ZjcyNzY4MWNkMDFiYmE2
+    ZDk0ZWM3YzMyOTJkYWIzYTViZjVmNWI5MzJkYzE4ZWExMGY0YzE=

data/.gitignore

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

data/Gemfile

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

data/LICENSE.txt

@@ -0,0 +1,22 @@
+Copyright (c) 2013 bqbn
+
+MIT License
+
+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 OR COPYRIGHT HOLDERS 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/README.md

@@ -0,0 +1,50 @@
+# Pdo
+
+pdo is a wrapper for running commands on or against multiple hosts at
+the same time.
+
+## Installation
+
+Add this line to your application's Gemfile:
+
+    gem 'pdo'
+
+And then execute:
+
+    $ bundle
+
+Or install it yourself as:
+
+    $ gem install pdo
+
+## Usage
+
+The following usage examples assume the host definition file in the
+example/ directory is used.
+
+* to list the hosts or groups
+$ pdo -g /
+$ pdo -g dc0/perf
+
+* to enumerate hosts in groups
+$ pdo -g lab0 --enum
+$ pdo -g dc0/perf --enum
+
+* to count # of hosts in groups
+$ pdo -g dc0/func,dc0/perf --count
+$ pdo -g lab0/empty --count
+
+* to run 'ls -l' on some hosts
+$ pdo -g env0 -c 'ls -l' -t 3 -y
+
+* to rsync some file to some hosts
+$ pdo -g lab0/dc1/util -c "rsync -avc example.txt _HOST_:/var/tmp/" -l -t 5
+
+
+## Contributing
+
+1. Fork it
+2. Create your feature branch (`git checkout -b my-new-feature`)
+3. Commit your changes (`git commit -am 'Add some feature'`)
+4. Push to the branch (`git push origin my-new-feature`)
+5. Create new Pull Request

data/Rakefile

@@ -0,0 +1 @@
+require "bundler/gem_tasks"

data/bin/pdo

@@ -0,0 +1,98 @@
+#!/usr/bin/env ruby
+
+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/task'
+require 'pp'
+
+logger = Logger['main'] || Logger['pdo']
+
+opts = OpenStruct.new
+# setting default values
+opts.confirm_before_execute = true
+opts.hosts = []
+opts.local = false
+opts.step = [0, 0]
+opts.thread_num = 1
+opts.nohush = false
+
+begin
+  # parse ARGV; defaults in opts is overwritten if needed
+  opts = PdoOpts.parse(ARGV, opts)
+  logger.debug { opts }
+rescue => err
+  logger.error { "#{err.class}: #{err.message}" }
+  logger.debug { err.backtrace.join "\n" }
+  exit 1
+end
+
+include Host
+Host.load_file opts.host_definition_file
+
+excludes = []
+opts.e_groups and opts.e_groups.each do |group|
+  excludes += get_hosts(group, opts.step)
+end
+
+if opts.groups then 
+  # the following all depend on existing of opts.groups option
+  if opts.count then
+    opts.groups.each do |group|
+      hosts = get_hosts(group, opts.step) - excludes
+      printf "%s: %d\n", group, hosts.size
+    end
+    exit 0
+  elsif opts.enum then
+    hosts = []
+    opts.groups.each do |group|
+      hosts += get_hosts(group, opts.step)
+    end
+    puts (hosts - excludes).join(' ')
+    exit 0
+  elsif opts.cmd then
+    hosts = []
+    opts.groups.each do |group|
+      hosts += get_hosts(group, opts.step)
+    end
+    hosts -= excludes
+
+    tasks = Task.new
+    hosts.each do |host|
+      ssh = SSHCmd.new(opts.local, opts.sshopts)
+      tasks.add [host, ssh.form(host, opts.cmd)]
+    end
+
+    if opts.confirm_before_execute 
+      tasks.print_all
+      loop do
+        printf "proceed? (y/N) : "
+        response = gets.rstrip
+        if response == 'y'
+          break
+        elsif response == 'N' or response == ''
+          exit 2 # user given up
+        end
+      end
+    end
+    pdo = PDO.new(tasks, opts.thread_num)
+    pdo.run
+  else 
+    opts.groups.each do |key|
+      printf "%s:\n", key
+      get_sub_groups(key).each do |sub_group|
+        printf "#{' ' * key.length}%s\n", sub_group
+      end
+    end
+    exit
+  end
+end # end of "if opts.groups then"
+
+# vim: set et ts=2 sts=2 sw=2 si sta :

data/conf/log4r.yaml

@@ -0,0 +1,18 @@
+---
+log4r_config:
+  loggers:
+    - name      : pdo
+      level     : INFO
+      outputters:
+        - stderr
+
+  # define all outputters (incl. formatters)      
+  outputters:
+    - type     : StderrOutputter
+      name     : stderr 
+      level    : INFO
+      formatter:
+        type   : PatternFormatter
+        pattern: "%d, %C: %l, %m"
+
+# vim: set et ts=2 sts=2 sw=2 si sta:

data/examples/pdo.yaml.example

@@ -0,0 +1,83 @@
+#
+# This is an example host definition file.
+#
+# The host definition file must be a YAML (http://www.yaml.org/) file.
+#
+# The below rules should be followed when defining your environments
+# and hosts.
+#
+# * A host name should be in the format of [user@]<host>[:port].
+# * A group name should be in the format of
+#     <group1/>[group2[/group3[...]]]
+#   Note the trailing slash ("/") for "group1". Without it, "group1"
+#   will be deemed as a host name.
+# * A group names must be an absolute path. The leading slash ("/")
+#   can be omitted.
+# * The leaf node must be either a group or host name.
+
+
+# A simple environment with 3 hosts.
+env0:
+  - h1
+  - h2
+  - h3
+
+# A data center that contains 2 environments
+dc0:
+  func: # functional test environment
+    - h1.func.dc0
+    - h2.func.dc0
+
+  perf: # performance test environment
+    - dc0/env2/type1
+    - dc0/env2/type2
+    - h3.perf.dc0
+    - h4.perf.dc0
+
+  env2: # dc0/env2
+    type1:
+      - h1.type1.env2.dc0
+      - h2.type2.env2.dc0
+    type2:
+      - h1.type2.dc0
+      - h2.type2.dc0
+
+# A lab that contains 2 data centers and more
+lab0:
+  empty: # empty group is OK.
+
+  # a functional grouping containing two data centers and an 
+  # extra host
+  func:
+    - lab0/dc1
+    - lab0/dc2
+    - funchost1
+
+  # lab0/dc1
+  dc1:
+    env1:
+      - lab0/dc1/util/admin
+      - host1.dc1
+      - host2.dc1
+    env2:
+      - lab0/dc1/util/tool
+      - host3.dc1
+      - host4.dc1
+    util:
+      admin:
+        - root@admin.example.com
+      tool:
+        - tools@tool.example.com:443
+
+  # lab0/dc2
+  dc2:
+    - host1.dc2
+    - host2.dc2
+
+# ALL of it
+all:
+  - env0/ # trailing slash is needed to indicate group names.
+  - lab0/
+  - dc0/
+
+# vim: set et ts=2 sts=2 sw=2 si sta :

data/lib/pdo/host.rb

@@ -0,0 +1,191 @@
+#!/usr/bin/env ruby
+
+require 'log4r'
+include Log4r
+
+require 'pp'
+require 'yaml'
+
+module Host
+
+  @@logger = Logger[self.class.to_s] || Logger['pdo']
+
+  @@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
+
+  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.
+  
+    hosts = []
+
+    level += 1
+    if level > @@recursive_level then
+      @@logger.warn "circle detected in the host definition file."
+      return []
+    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 ]
+        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
+    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
+    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
+    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
+
+    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 [ ]
+        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
+    end
+    
+  end
+
+end
+
+# vim: set et ts=2 sts=2 sw=2 si sta :

data/lib/pdo/logging.rb

@@ -0,0 +1,14 @@
+#!/usr/bin/env ruby
+
+require 'log4r'
+require 'log4r/yamlconfigurator'
+require 'log4r/outputter/datefileoutputter'
+
+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
+}
+
+# vim: set et ts=2 sts=2 sw=2 si sta :

data/lib/pdo/pdoopts.rb

@@ -0,0 +1,94 @@
+#!/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 :

data/lib/pdo/task.rb

@@ -0,0 +1,103 @@
+#!/usr/bin/env ruby
+
+require 'log4r'
+include Log4r
+
+class SSHCmd
+  def initialize(local, sshopts)
+    @logger = Logger[self.class.to_s] || Logger['pdo']
+
+    @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", '; '
+
+    # 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
+
+    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
+  end
+end
+
+class Task
+
+  def initialize
+    @logger = Logger[self.class.to_s] || Logger['pdo']
+    @task_q = Queue.new
+  end
+
+  def add(task)
+    @task_q << task
+  end
+
+  def next
+    begin
+      @task_q.deq(non_block=true)
+    rescue ThreadError
+      nil
+    end
+  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
+    end
+    @task_q = tmp_q
+  end
+
+end
+
+# vim: set et ts=2 sts=2 sw=2 si sta :

data/lib/pdo/version.rb

@@ -0,0 +1,3 @@
+module Pdo
+  VERSION = "0.0.1"
+end

data/lib/pdo.rb

@@ -0,0 +1,87 @@
+#!/usr/bin/env ruby
+
+include Process
+
+class PDO
+  def initialize(tasks, thread_num)
+    @logger = Logger[self.class.to_s] || Logger['pdo']
+    @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.
+
+    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
+          end
+        end
+      end
+    end
+
+    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
+        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.
+
+    raise "no task" if task.nil?
+
+    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)
+      end
+    end
+
+  end
+
+end
+
+# vim: set et ts=2 sts=2 sw=2 si sta :

data/pdo.gemspec

@@ -0,0 +1,25 @@
+# -*- encoding: utf-8 -*-
+lib = File.expand_path('../lib', __FILE__)
+$LOAD_PATH.unshift(lib) unless $LOAD_PATH.include?(lib)
+require 'pdo/version'
+
+Gem::Specification.new do |gem|
+  gem.name          = "pdo"
+  gem.licenses      = "MIT"
+  gem.version       = Pdo::VERSION
+  gem.authors       = ["bqbn"]
+  gem.email         = ["bqbn@openken.com"]
+  gem.description   = 'pdo is a wrapper for running commands on or '\
+                      'against multiple hosts at the same time.'
+  gem.summary       = 'pdo is a wrapper for running commands on or '\
+                      'against multiple hosts at the same time.'
+  gem.homepage      = "https://github.com/bqbn/pdo"
+
+  gem.files         = `git ls-files`.split($/)
+  gem.executables   = gem.files.grep(%r{^bin/}).map{ |f| File.basename(f) }
+  gem.test_files    = gem.files.grep(%r{^(test|spec|features)/})
+  gem.require_paths = ["lib"]
+
+  gem.add_dependency('log4r', '> 1.1.9')
+end
+# vim: set et ts=2 sts=2 sw=2 si sta :

metadata

@@ -0,0 +1,76 @@
+--- !ruby/object:Gem::Specification
+name: pdo
+version: !ruby/object:Gem::Version
+  version: 0.0.1
+platform: ruby
+authors:
+- bqbn
+autorequire: 
+bindir: bin
+cert_chain: []
+date: 2013-03-10 00:00:00.000000000 Z
+dependencies:
+- !ruby/object:Gem::Dependency
+  name: log4r
+  requirement: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+  type: :runtime
+  prerelease: false
+  version_requirements: !ruby/object:Gem::Requirement
+    requirements:
+    - - ! '>'
+      - !ruby/object:Gem::Version
+        version: 1.1.9
+description: pdo is a wrapper for running commands on or against multiple hosts at
+  the same time.
+email:
+- bqbn@openken.com
+executables:
+- pdo
+extensions: []
+extra_rdoc_files: []
+files:
+- .gitignore
+- Gemfile
+- LICENSE.txt
+- README.md
+- Rakefile
+- bin/pdo
+- conf/log4r.yaml
+- examples/pdo.yaml.example
+- lib/pdo.rb
+- lib/pdo/host.rb
+- lib/pdo/logging.rb
+- lib/pdo/pdoopts.rb
+- lib/pdo/task.rb
+- lib/pdo/version.rb
+- pdo.gemspec
+homepage: https://github.com/bqbn/pdo
+licenses:
+- MIT
+metadata: {}
+post_install_message: 
+rdoc_options: []
+require_paths:
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+required_rubygems_version: !ruby/object:Gem::Requirement
+  requirements:
+  - - ! '>='
+    - !ruby/object:Gem::Version
+      version: '0'
+requirements: []
+rubyforge_project: 
+rubygems_version: 2.0.2
+signing_key: 
+specification_version: 4
+summary: pdo is a wrapper for running commands on or against multiple hosts at the
+  same time.
+test_files: []