zzdeploy 0.0.5

data/lib/commands/ssh_instance.rb

@@ -0,0 +1,98 @@
+require "set"
+require 'readline'
+
+module Commands
+  class SSHInstance
+
+    # holds the options that were passed
+    # you can set any initial defaults here
+    def options
+      @options ||= {
+      }
+    end
+
+    # required options
+    def required_options
+      @required_options ||= Set.new [
+        :group
+      ]
+    end
+
+    def register(opts, global_options)
+      opts.banner = "Usage: ssh [options]"
+      opts.description = "SSH into a server"
+
+      opts.on('-i', "--instance instance", "The instance to connect to..") do |v|
+        options[:instance] = v
+      end
+
+      opts.on('-r', "--role role", MetaOptions.roles, "Role to look for.") do |v|
+        options[:role] = v
+      end
+
+      opts.on('-g', "--group deploy_group", "Required: Group to look for.") do |v|
+        options[:group] = v
+      end
+    end
+
+
+    def run(global_options, amazon)
+      ec2 = amazon.ec2
+
+      group_name = options[:group]
+      deploy_group = amazon.find_deploy_group(group_name)
+      group_config = deploy_group.config
+
+      pick = nil
+      instance_id = options[:instance]
+      if instance_id.nil?
+        instances = amazon.find_and_sort_named_instances(options[:group], options[:role])
+      else
+        instances = amazon.find_and_sort_named_instances()
+        instances.each do |instance|
+          resource_id = instance[:resource_id]
+          if resource_id == instance_id
+            pick = instance
+            break
+          end
+        end
+        if pick.nil?
+          raise "The instance you specified was not a valid ZangZing deployed instance."
+        end
+      end
+
+      if pick.nil?
+        if instances.length == 0
+          raise "No instance matched your search criteria."
+        end
+
+        pick = instances[0]
+        if instances.length > 1
+          # more than one
+          puts "More than one instance matched, pick from list below the instance you want."
+          i = 1
+          instances.each do |instance|
+            name = instance[:Name]
+            resource_id = instance[:resource_id]
+            puts "#{i}) #{name} => #{resource_id}"
+            i += 1
+          end
+          print "Type the one you want to use: "
+          r = Readline.readline()
+          pick_num = r.to_i
+          if pick_num < 1 || pick_num > instances.length
+            raise "Your pick was not in range."
+          end
+          pick = instances[pick_num - 1]
+        end
+      end
+
+      # ok, we have a pick lets ssh to it
+      ec2_instance = ec2.describe_instances(pick[:resource_id])[0]
+      dns_name = ec2_instance[:dns_name]
+      puts "Running SSH for #{pick[:Name]}"
+      ssh_cmd = "ssh -i ~/.ssh/#{group_config[:amazon_security_key]}.pem ec2-user@#{dns_name}"
+      ZZSharedLib::CL.do_cmd ssh_cmd
+    end
+  end
+end

data/lib/commands.rb

@@ -0,0 +1,23 @@
+require "set"
+
+require "multi_ssh"
+require "printer"
+
+require 'commands/build_deploy_config'
+
+require 'commands/deploy_group_create'
+require 'commands/deploy_group_delete'
+require 'commands/deploy_group_list'
+require 'commands/deploy_group_modify'
+
+require 'commands/add_instance'
+require 'commands/delete_instances'
+require 'commands/list_instances'
+require 'commands/deploy_instances'
+require 'commands/maint_instances'
+require 'commands/ssh_instance'
+require 'commands/multi_ssh_instance'
+require 'commands/meta_options'
+require 'commands/chef_upload'
+require 'commands/chef_bake'
+require 'commands/config_amazon'

data/lib/info.rb

@@ -0,0 +1,5 @@
+class Info
+  def self.version
+    "0.0.5"
+  end
+end

data/lib/multi_ssh.rb

@@ -0,0 +1,155 @@
+require 'net/ssh'
+require 'net/ssh/multi'
+
+class MultiSSH
+  attr_reader :amazon, :group_name, :deploy_group, :group_config
+  attr_accessor :instances, :longest, :ui, :concurrent_max
+
+  def initialize(amazon, group_name, deploy_group, concurrent_max = 1000)
+    @amazon = amazon
+    @group_name = group_name
+    @deploy_group = deploy_group
+    @group_config = deploy_group.config
+    @concurrent_max = concurrent_max
+    @session = nil
+    @ui = Printer.new(STDOUT, STDERR, STDIN)
+  end
+
+  def run(remote_cmd)
+    @instances ||= amazon.find_and_sort_named_instances(group_name)
+    run_instances(@instances, remote_cmd)
+  end
+
+  def run_instances(instances, remote_cmd)
+    clear_session
+    @longest = 0
+    @instances = instances
+    @instances.each do |instance|
+      session_opts = {}
+      host = instance[:public_hostname]
+      session_opts[:keys] = File.expand_path("~/.ssh/#{group_config[:amazon_security_key]}.pem")
+      session_opts[:paranoid] = false
+      session_opts[:user_known_hosts_file] = "/dev/null"
+      session_opts[:timeout] = 30
+      hostspec = "ec2-user@#{host}"
+      session.use(hostspec, session_opts)
+
+      @longest = host.length if host.length > @longest
+    end
+
+    ssh_command(remote_cmd, session)
+
+    result = 0
+    failed_count = 0
+    @instances.each do |instance|
+      ssh_result = instance[:ssh_exit_status]
+      if ssh_result != 0
+        failed_count += 1
+        result = ssh_result if result == 0
+      end
+    end
+
+    if failed_count > 0
+      raise "Failed SSH command.  Out of #{@instances.count} servers, #{failed_count} failed.  First error was: #{result}"
+    else
+      ui.msg(ui.color("All #{@instances.count} ssh requests completed without error.", :green, :bold))
+    end
+  end
+
+
+  # find a matching instance for the specified host
+  def find_instance_by_host(host)
+    self.instances.each do |instance|
+      if instance[:public_hostname] == host
+        return instance
+      end
+    end
+    return nil
+  end
+
+  def clear_session
+    @session = nil
+    # a map that tracks all output data in an array
+    # keyed by the host name
+    @output_tracker = {}
+  end
+
+  def output_tracker
+    @output_tracker
+  end
+
+  # dump the result data into a file for each host
+  def output_tracked_data_to_files(prefix, result_path)
+    return if result_path.nil?
+    output_tracker.each do |key, data|
+      file_path = File.expand_path('.', "#{result_path}/results_#{prefix}_#{key}.txt")
+      File.open(file_path, 'w') do |f|
+        data.each do |line|
+          f.puts(line)
+        end
+      end
+    end
+  end
+
+  def add_output(host, msg)
+    # see if we already have an entry for this host
+    data_array = output_tracker[host]
+    if data_array.nil?
+      data_array = []
+      output_tracker[host] = data_array
+    end
+    # now add the msg to the array
+    data_array << msg
+  end
+
+  def session
+    return @session unless @session.nil?
+
+    ssh_error_handler = Proc.new do |server|
+      host = server.host
+      msg = "Failed to connect to #{host} -- #{$!.class.name}: #{$!.message}"
+      print_data(host, msg, :red)
+      instance = find_instance_by_host(host)
+      instance[:ssh_exit_status] = 99
+    end
+
+    @session ||= Net::SSH::Multi.start(:concurrent_connections => concurrent_max, :on_error => ssh_error_handler)
+  end
+
+  # print and group data by host
+  def print_data(host, data, color = :cyan)
+    if data =~ /\n/
+      data.split(/\n/).each { |d| print_data(host, d) }
+    else
+      add_output(host, data)
+      padding = self.longest - host.length
+      str = ui.color(host, color) + (" " * (padding + 1)) + data
+      ui.msg(str)
+    end
+  end
+
+  def ssh_command(command, subsession)
+    subsession.open_channel do |ch|
+      ch.request_pty
+      ch.exec command do |ch, success|
+        raise ArgumentError, "Cannot execute #{command}" unless success
+        ch.on_data do |ichannel, data|
+          print_data(ichannel[:host], data)
+        end
+        ch.on_extended_data do |ichannel, type, data|
+          print_data(ichannel[:host], data, :red)
+        end
+        ch.on_request("exit-status") do |ichannel, data|
+          status = data.read_long
+          ichannel[:exit_status] = status
+          host = ichannel[:host]
+          instance = find_instance_by_host(host)
+          instance[:ssh_exit_status] = status
+          print_data(host, "Exit status is: #{status}", status == 0 ? :blue : :red)
+        end
+      end
+    end
+    session.loop
+  end
+
+end

data/lib/printer.rb

@@ -0,0 +1,54 @@
+class Printer
+  attr_reader :stdout
+  attr_reader :stderr
+  attr_reader :stdin
+
+  def initialize(stdout=STDOUT, stderr=STDERR, stdin=STDIN)
+    @stdout, @stderr, @stdin = stdout, stderr, stdin
+  end
+
+  def highline
+    @highline ||= begin
+      require 'highline'
+      HighLine.new
+    end
+  end
+
+  # Prints a message to stdout. Aliased as +info+ for compatibility with
+  # the logger API.
+  def msg(message)
+    stdout.puts message
+    stdout.flush
+  end
+
+  alias :info :msg
+
+  # Print a warning message
+  def warn(message)
+    msg("#{color('WARNING:', :yellow, :bold)} #{message}")
+  end
+
+  # Print an error message
+  def error(message)
+    msg("#{color('ERROR:', :red, :bold)} #{message}")
+  end
+
+  # Print a message describing a fatal error.
+  def fatal(message)
+    msg("#{color('FATAL:', :red, :bold)} #{message}")
+  end
+
+  def color(string, *colors)
+    if color?
+      highline.color(string, *colors)
+    else
+      string
+    end
+  end
+
+  # Should colored output be used? Only on TTY
+  def color?
+    true
+  end
+
+end

data/lib/zz_deploy.rb

@@ -0,0 +1,177 @@
+$:.unshift(File.dirname(__FILE__))
+models = File.expand_path('../../models', __FILE__)
+$:.unshift(models)
+require 'subcommand'
+require 'commands'
+require 'right_aws'
+require 'sdb/active_sdb'
+require 'json'
+require 'zzsharedlib'
+
+class ZZDeploy
+  include Subcommands
+
+  VERSION = "0.0.4"
+  CMD = "zzdeploy"
+
+  RECIPES_DIR = "/var/chef/cookbooks/zz-chef-repo"
+  RECIPES_BUNDLE_DIR = "/var/chef/cookbooks/zz-chef-repo_bundle"
+
+  # required options
+  def required_options
+    @required_options ||= Set.new [
+    ]
+  end
+
+  # the options that were set
+  def options
+    @options ||= {}
+  end
+
+  def sub_commands
+    @sub_commands ||= {}
+  end
+
+  def printer
+    @printer ||= Printer.new
+  end
+
+  # define sub commands here
+  def define_sub_commands
+    sub_commands[:deploy_group_create] = Commands::DeployGroupCreate.new
+    sub_commands[:deploy_group_delete] = Commands::DeployGroupDelete.new
+    sub_commands[:deploy_group_list] = Commands::DeployGroupList.new
+    sub_commands[:deploy_group_modify] = Commands::DeployGroupModify.new
+    sub_commands[:add] = Commands::AddInstance.new
+    sub_commands[:delete] = Commands::DeleteInstances.new
+    sub_commands[:list] = Commands::ListInstances.new
+    sub_commands[:deploy] = Commands::DeployInstances.new
+    sub_commands[:maint] = Commands::MaintInstances.new
+    sub_commands[:ssh] = Commands::SSHInstance.new
+    sub_commands[:multi_ssh] = Commands::MultiSSHInstance.new
+    sub_commands[:chef_upload] = Commands::ChefUpload.new
+    sub_commands[:chef_apply] = Commands::ChefBake.new
+    sub_commands[:config_amazon] = Commands::ConfigAmazon.new
+  end
+
+  def setup
+    options.clear
+    set_amazon_options
+    # global options
+    global_options do |opts|
+      opts.banner = "Version: #{VERSION} - Usage: #{CMD} [options] [subcommand [options]]"
+      opts.description = "ZangZing configuration and deploy tool.  You must specify a valid sub command."
+      opts.separator ""
+      opts.separator "Global options are:"
+      opts.on("-v", "--[no-]verbose", "Run verbosely") do |v|
+        options[:verbose] = v
+      end
+
+      opts.on("--akey AmazonAccessKey", "Amazon access key, or environment AWS_ACCESS_KEY_ID.") do |v|
+        options[:access_key] = v
+      end
+
+      opts.on("--skey AmazonSecretKey", "Amazon secret key or environment AWS_SECRET_ACCESS_KEY") do |v|
+        options[:secret_key] = v
+      end
+
+    end
+    add_help_option
+
+    define_sub_commands
+
+    sub_commands.each_pair do |command_name, sub_cmd|
+      command command_name do |opts|
+        sub_cmd.send("register", opts, options)
+      end
+    end
+
+  end
+
+  def force_fail(cmd = nil)
+    # force failure and show options
+    ARGV.clear
+    ARGV << "help"
+    ARGV << cmd unless cmd.nil?
+    opt_parse
+  end
+
+  # validate the options passed
+  def validate(cmd, sub_cmd)
+    required_options.each do |r|
+      if options.has_key?(r) == false
+        puts "Missing options"
+        force_fail
+      end
+    end
+
+    sub_cmd.required_options.each do |r|
+      if sub_cmd.options.has_key?(r) == false
+        puts "Missing options"
+        force_fail(cmd)
+      end
+    end
+  end
+
+  def set_amazon_options
+    json = File.open("/var/chef/amazon.json", 'r') {|f| f.read }
+    ak = JSON.parse(json)
+    options[:access_key] = ak["aws_access_key_id"]
+    options[:secret_key] = ak["aws_secret_access_key"]
+  rescue
+    # do nothing
+  end
+
+  def parse
+    if ARGV.empty?
+      ARGV << "help"
+    end
+
+    cmd = opt_parse()
+    if cmd.nil?
+      force_fail
+    end
+
+    # ok, we have a valid command so dispatch it
+#    puts "cmd: #{cmd}"
+#    puts "options ......"
+#    p options
+#    puts "ARGV:"
+#    p ARGV
+
+    sub_cmd = sub_commands[cmd.to_sym]
+    validate(cmd, sub_cmd)
+
+    # track both types of options
+    ZZSharedLib::Options.global_options = options
+    ZZSharedLib::Options.cmd_options = sub_cmd.options
+
+    # dispatch the command
+    amazon = ZZSharedLib::Amazon.new
+
+    sub_cmd.send("run", options, amazon)
+  end
+
+
+
+  def run(argv = ARGV)
+    exit_code = true
+    begin
+      setup
+      parse
+    rescue SystemExit => ex
+      # ignore direct calls to exit
+    rescue Exception => ex
+      printer.error printer.color(ex.message, :red)
+#      puts ex.backtrace
+      exit_code = false
+    end
+
+    # make sure buffer is flushed
+    # debugger doesn't seem to do this always
+    STDOUT.flush
+
+    return exit_code
+  end
+
+end

data/spec/spec_helper.rb

@@ -0,0 +1,5 @@
+#require 'spec'
+
+$LOAD_PATH.unshift(File.dirname(__FILE__))
+$LOAD_PATH.unshift(File.join(File.dirname(__FILE__), '..', 'lib'))
+require 'zz_deploy'