hadouken 0.1.4.pre

data/lib/hadouken/ext/net_ssh_multi_session_actions.rb

@@ -0,0 +1,31 @@
+module Net::SSH::Multi::SessionActions
+
+  def hadouken_exec(command)
+    open_channel do |channel|
+
+      channel.exec(command) do |ch, success|
+        raise "could not execute command: #{command.inspect} (#{ch[:host]})" unless success
+        channel.on_data do |ch, data|
+          ch[:stdout] = []
+          data.chomp.each_line do |line|
+            ch[:stdout] << line
+          end 
+        end 
+      end 
+
+      channel.on_extended_data do |ch, type, data|
+        ch[:stderr] = []
+        data.chomp.each_line do |line|
+          ch[:stderr] << line
+        end 
+      end
+
+      channel.on_request("exit-status") do |ch, data|
+        ch[:exit_status] = data.read_long
+      end 
+
+    end #open_channel
+
+  end 
+
+end

data/lib/hadouken/group.rb

@@ -0,0 +1,32 @@
+class Hadouken::Group
+  attr_reader :name
+  attr_reader :range
+  attr_reader :pattern
+
+  def initialize(opts)
+    @name    = opts[:name]
+    @range   = opts[:range]
+    @pattern = opts[:pattern]
+  end
+
+  def count
+    @count ||= hosts.size
+  end
+  alias :size :count
+
+  def hosts
+    @hosts ||= @range.map{|idx| "#{@pattern}" % [ idx ] }.map do |hostname|
+      Hadouken::Hosts.add({:name => hostname})
+    end
+  end
+
+  def has_host?(name)
+    @hosts_by_name ||= hosts.inject({}){|h,host| h[host]=true; h}
+    @hosts_by_name.has_key?(name)
+  end
+
+  def self.create!(name, opts)
+    new(opts.merge(:name => name))
+  end
+
+end

data/lib/hadouken/groups.rb

@@ -0,0 +1,42 @@
+class Hadouken::Groups
+  include Enumerable
+
+  def initialize
+    @groups = {}
+    @order  = []
+  end
+
+  def count
+    @groups.values.size
+  end
+  alias :size :count
+
+  def hosts
+    @groups.values.map{|group| group.hosts}.flatten
+  end
+
+  def each
+    @order.uniq!
+    @order.each do |name|
+      yield @groups[name]
+    end
+  end
+
+  def [](name)
+    fetch name
+  end
+
+  def fetch (name)
+    @groups[ name ]
+  end
+
+  def add (name, opts)
+    store(Hadouken::Group.create!(name, opts))
+  end
+
+  def store (group)
+    raise ArgumentError.new("8==D~") unless group.is_a?(Hadouken::Group)
+    @groups[ group.name ] = group
+    @order << group.name
+  end
+end

data/lib/hadouken/host.rb

@@ -0,0 +1,120 @@
+module Hadouken::Hosts
+
+  class << self
+    attr_accessor :history_filepath
+  end
+
+  @@hosts = {}
+
+  def self.add(opts={})
+    @@hosts[opts[:name]] ||= Hadouken::Host.new(opts)
+  end
+  
+  def self.get(hostname)
+    @@hosts[hostname]
+  end
+
+  def self.exists?(hostname)
+    @@hosts.exists?(hostname)
+  end
+
+  def self.count
+    @@hosts.keys.count
+  end
+
+  def self.any?
+    @@hosts.keys.any?
+  end
+
+  def self.each
+    @@hosts.each do |hostname, host|
+      yield host
+    end
+  end
+
+  def self.disable_all!
+    each do |host|
+      host.disable! if host.enabled?
+    end
+  end
+end
+
+class Hadouken::Host
+  attr_reader   :name
+  attr_reader   :history
+
+  # used to store the net-ssh server object
+  attr_accessor :server
+
+  def initialize(opts={})
+    @name    = opts[:name]
+    @enabled = true
+    @history = History.new(self)
+  end
+
+  def disable!
+    history.add :disabled, :noop
+    @enabled = false
+  end
+
+  def enable!
+    history.add :enabled,  :noop
+    @enabled = true
+  end
+
+  def enabled?
+    @enabled
+  end
+
+  def to_s
+    name
+  end
+ 
+  def history_filepath
+    File.join(Hadouken::Hosts.history_filepath, "#{name}.log")
+  end
+ 
+
+  class History
+    include Enumerable
+
+    def initialize(host)
+      @host     = host
+      @history  = []
+    end
+
+    def add(command, status, stdout=nil, stderr=nil, epoch=Time.now.to_f)
+      stdoutJoined = stdout ? stdout.join("\n") : nil
+      stderrJoined = stderr ? stderr.join("\n") : nil
+      @history << [command, status, epoch, stdoutJoined, stderrJoined]
+      File.open(@host.history_filepath, 'a') do |history_file|
+        history_file.write(Yajl::Encoder.encode(command_to_hash(command, status, epoch, stdoutJoined, stderrJoined)))
+        history_file.write("\n")
+      end
+    end
+
+    def each
+      @history.each do |command, status, epoch, stdout, stderr|
+        yield command, status, epoch, stdout, stderr
+      end
+    end
+
+    def to_json
+      Yajl::Encoder.encode self.map do |command, status, epoch, stdout, stderr|
+        command_to_hash(command, status, epoch, stdout, stderr)
+      end
+    end
+
+    private
+
+    def command_to_hash(command, status, epoch, stdout, stderr)
+      return {
+        :command => command,
+        :status  => status,
+        :time    => (epoch * 1000).round,
+        :stdout  => stdout,
+        :stderr  => stderr
+      }
+    end
+  end
+end

data/lib/hadouken/plan.rb

@@ -0,0 +1,48 @@
+class Hadouken::Plan
+  attr_accessor :name
+  attr_accessor :root
+  attr_accessor :user
+
+  attr_accessor :environment
+  attr_accessor :dry_run
+  attr_accessor :interactive
+
+  attr_accessor :history_path
+  attr_accessor :planfile
+  attr_accessor :artifact
+
+  attr_reader   :timestamp
+  
+  def initialize
+    @tasks     = Hadouken::Tasks.new
+    @groups    = Hadouken::Groups.new
+    @timestamp = Time.now.utc.strftime("%Y%m%d%H%M%S")
+  end
+
+  def groups
+    @groups
+  end
+
+  def tasks
+    @tasks
+  end
+
+  def dry_run?
+    !!@dry_run
+  end
+
+  def interactive?
+    !!@interactive
+  end
+
+  def env
+    environment
+  end
+
+
+  def logger
+    Hadouken.logger
+  end
+
+end
+

data/lib/hadouken/runner.rb

@@ -0,0 +1,84 @@
+class Hadouken::Runner
+
+  attr_accessor :args
+  attr_accessor :plan
+
+  def initialize
+    @args = self.class.optparse
+    @plan = Hadouken::Plan.new
+    @plan.environment = @args[:environment]
+    @plan.dry_run     = @args[:dry_run]
+    @plan.interactive = @args[:interactive]
+    @plan.planfile    = @args[:planfile]
+    @plan.artifact    = @args[:artifact]
+  end
+
+  def self.run!
+    runner = Hadouken::Runner.new
+    plan   = runner.plan
+
+    yield(plan)
+
+    ts0  = Time.now
+    Hadouken::Executor.run!(plan)
+    te0  = Time.now
+
+    Hadouken.logger.info "plan executed in %0.2f" % (te0 - ts0)
+  end
+
+  def self.optparse
+    args   = {}
+    parser = OptionParser.new do |opts|
+      opts.banner  = "Usage: #{$0} [options]"
+      opts.separator ""
+      opts.separator "options:"
+      
+      opts.on("--interactive",   "output stdout/stderr to console") {|o| args[:interactive] = o}
+      opts.on("--dry-run",       "take no action"                 ) {|o| args[:dry_run]     = o}
+      opts.on("--env ENV",       "stage|production|ding-dong|..." ) {|o| args[:environment] = o}
+
+      opts.on("--history PATH",  "where to store history files") do |o| 
+        args[:history] = o || 'history'
+        FileUtils.mkdir_p args[:history]
+        Hadouken::Hosts.history_filepath = args[:history]
+      end
+
+      opts.on("--artifact URL", "URL to the service artifact" ) do |o|
+        begin
+          args[:artifact] = URI.parse(o)
+          raise URI::InvalidURIError unless args[:artifact].is_a?(URI::HTTP)
+        rescue URI::InvalidURIError
+          puts "Sorry, invalid artifact url: #{o}"
+          exit 1
+        end
+      end
+
+      opts.on("--level LEVEL",  "debug|info|warn|error|fatal" ) do |o|
+        if o !~ /^(debug|info|warn|error|fatal)$/i
+          puts "Sorry, I don't know what that log level is ..."
+          exit -1
+        else
+          args[:level] = case o.downcase
+            when /debug/ then Logger::DEBUG
+            when /info/  then Logger::INFO
+            when /warn/  then Logger::WARN
+            when /error/ then Logger::ERROR
+            when /fatal/ then Logger::FATAL
+          end 
+        end
+
+        Hadouken.logger.level = args[:level] || Logger::INFO
+      end
+    end
+    parser.parse!
+
+    unless args.has_key?(:artifact) &&
+           args.has_key?(:environment)
+      puts parser
+      exit 1
+    end
+
+    return args    
+  end
+
+end

data/lib/hadouken/strategy/base.rb

@@ -0,0 +1,15 @@
+class Hadouken::Strategy::Base
+  attr_reader :plan
+  attr_reader :max_hosts
+  attr_reader :traversal
+
+  def initialize(plan, opts={})
+    @plan      = plan
+    @max_hosts = opts[:max_hosts]
+    @traversal = opts[:traversal] || :breadth
+  end
+
+  def host_strategy
+    raise ArgumentError, "not implemneted here"
+  end
+end

data/lib/hadouken/strategy/by_group.rb

@@ -0,0 +1,15 @@
+class Hadouken::Strategy::ByGroup < Hadouken::Strategy::Base
+  def host_strategy
+    host_sets = []
+    plan.groups.each do |group|
+      hosts = group.hosts
+      slice = max_hosts || hosts.size
+
+      hosts.each_slice(slice) do |host_slice|
+        host_sets << host_slice
+      end
+    end 
+
+    balanced
+  end
+end

data/lib/hadouken/strategy/by_group_parallel.rb

@@ -0,0 +1,34 @@
+class Hadouken::Strategy::ByGroupParallel < Hadouken::Strategy::Base
+  def host_strategy
+    return @host_sets if @host_sets
+
+    # transform a array of groups, hosts into a new array that balances
+    # hosts from each group into a single array.
+    @host_sets = []
+    regroup    = []
+    groups     = []
+    max_size   =  0
+
+    plan.groups.each do |group|
+      hosts     = group.hosts
+      max_size  = [max_size, hosts.size].max
+      groups   << hosts
+    end
+
+    [max_size, groups.size].max.times do  
+      groups.each do |hosts|
+        if hosts.size == 0
+          #TODO groups.delete(name)
+        else
+          regroup << hosts.shift
+        end
+      end
+    end
+
+    regroup.each_slice(max_size) do |host_slice|
+      @host_sets << host_slice
+    end
+
+    @balanced
+  end
+end

data/lib/hadouken/strategy/by_host.rb

@@ -0,0 +1,14 @@
+class Hadouken::Strategy::ByHost < Hadouken::Strategy::Base
+  def host_strategy
+    hosts     = plan.groups.map{|g| g.hosts}.flatten.uniq
+    slice     = max_hosts || hosts.size
+    host_sets = [] 
+    
+    slice = max_hosts || hosts.size
+    hosts.each_slice(slice) do |host_slice|
+      host_sets << host_slice
+    end
+
+    host_sets
+  end
+end