maws 0.8.0

data/lib/maws/instance/rds.rb

@@ -0,0 +1,84 @@
+require 'maws/instance'
+
+# for RDS instances name == aws_id
+class Instance::RDS < Instance
+  def create
+    return if alive?
+
+    if config(:replica)
+      # READ REPLICA
+      info "creating RDS Read Replica #{name}..."
+      source_role_name = config(:source_role, true)
+
+      source_instance = instances.with_role(source_role_name).first
+
+      if source_instance.nil?
+        error "...can't create read replica - the source role '#{source_role_name}' doesn't exist"
+        return
+      end
+
+      unless source_instance.valid_read_replica_source?
+        error "...can't create read replica - source rds #{source_instance.name} is not valid (#{source_instance.status})!"
+        return
+      end
+
+      result = connection.rds.create_db_instance_read_replica(name, source_instance.name,
+                      :instance_class => config(:instance_class, true),
+                      :availability_zone => region_physical_zone)
+    else
+      info "creating RDS #{name}..."
+
+      # MASTER DB
+      create_opts = {}
+      create_opts[:engine] = config(:engine)
+      create_opts[:engine_version] = config(:engine_version)
+      create_opts[:instance_class] = config(:instance_class)
+      create_opts[:auto_minor_version_upgrade] = config(:auto_minor_version_upgrade)
+      create_opts[:allocated_storage] = config(:allocated_storage)
+      create_opts[:db_name] = config(:db_name)
+      create_opts[:db_parameter_group] = config(:db_parameter_group)
+      create_opts[:db_security_groups] = security_groups
+      create_opts[:backup_retention_period] = config(:backup_retention_period)
+      create_opts[:preferred_backup_window] = config(:preferred_backup_window)
+      create_opts[:preferred_maintenance_window] = config(:preferred_maintenance_window)
+
+      if config(:scope).eql?("region")
+        create_opts[:multi_az] = true
+      else
+        create_opts[:availability_zone] = @command_options.availability_zone
+      end
+
+      master_username = config(:master_username, true)
+      master_password = config(:master_password, true)
+
+      result = connection.rds.create_db_instance(name, master_username, master_password, create_opts)
+    end
+
+    sync_from_description(result)
+    info "...done (RDS #{name} is being created)\n\n"
+  end
+
+  def destroy
+    return unless alive?
+    stoppable_states = %w(available failed storage-full incompatible-parameters incompatible-restore)
+    unless stoppable_states.include? status
+      info "can't destroy RDS #{aws_id} while it is #{status}"
+      return
+    end
+    connection.rds.delete_db_instance(aws_id, :skip_final_snapshot => true)
+    info "destroying RDS #{aws_id}"
+  end
+
+  def valid_read_replica_source?
+    alive? && !config(:replica)
+  end
+
+  def service
+    :rds
+  end
+
+  def display_fields
+    super + [:endpoint_address, :endpoint_port]
+  end
+
+end

data/lib/maws/instance.rb

@@ -0,0 +1,167 @@
+require 'maws/mash'
+require 'maws/instance_matcher'
+require 'maws/instance_display'
+
+
+class Instance
+  attr_accessor :name
+  attr_accessor :region, :zone, :role, :index, :groups, :prefix
+  attr_reader :description
+
+  NA_STATUS = 'n/a'
+
+  def self.create(maws, config, prefix, zone, role, index, options = {})
+    options = mash(options)
+
+    service = options.service || config.combined[role].service
+    region = options.region || config.region
+    name = options.name || name_for(config, prefix, zone, role, index)
+
+    klass = Instance.const_get("#{service.to_s.upcase}")
+
+    klass.new(maws, config, name, region, prefix, zone, role, index)
+  end
+
+  def self.name_for(config, prefix, zone, role, index)
+    add_prefix = prefix.empty? ? "" : prefix + "."
+    "#{add_prefix}#{config.profile.name}-#{role}-#{index}#{zone}"
+  end
+
+  def initialize(maws, config, name, region, prefix, zone, role, index)
+    @maws = maws
+    @config = config
+    @name = name
+    @region = region
+    @zone = zone
+    @role = role
+    @index = index
+
+    @prefix = prefix
+
+    @description = mash
+    @groups = %w(all)
+  end
+
+  def connection
+    @maws.connection
+  end
+
+  def instances
+    @maws.instances
+  end
+
+  def description=(description)
+    # never nil
+    @description = description || mash
+  end
+
+  def logical_zone
+    @zone
+  end
+
+  def physical_zone
+    @zone || @description.physical_zone || @config.specified_zones.first
+  end
+
+  def aws_id
+    description.aws_id
+  end
+
+  def status
+    description.status || 'n/a'
+  end
+
+  def region_zone
+    region + zone
+  end
+
+  def region_physical_zone
+    region + physical_zone
+  end
+
+
+  def terminated?
+    status == 'terminated'
+  end
+
+  def alive?
+    aws_id && !terminated?
+  end
+
+  def to_s
+    "#{name}   #{status}    #{aws_id}"
+  end
+
+  def inspect
+    "<#{self.class} #{to_s}>"
+  end
+
+  def has_approximate_status?(approximate_status)
+    if approximate_status == "n/a" or approximate_status == "terminated"
+      !alive?
+    elsif approximate_status == "ssh"
+      self.respond_to?(:ssh_available?) ? self.ssh_available? : has_approximate_status?("available")
+    elsif approximate_status == "running" || approximate_status == "available"
+      status == "running" || status == "available"
+    else
+      approximate_status == status
+    end
+  end
+
+  def method_missing(method_name, *args, &block)
+    config(method_name) ||
+    description[method_name] ||
+    @config.command_line[method_name]
+  end
+
+  def config(key, required=false)
+    if required && @config.combined[role][key].nil?
+      raise ArgumentError.new("Missing required config: #{key}")
+    end
+
+    @config.combined[role][key]
+  end
+
+  def security_groups
+    groups = config(:security_groups).to_a.dup
+    groups << "#{service}_default"
+
+    if @config.profile.security_rules and @config.profile.security_rules[role]
+      groups << "#{@profile.name}-#{role_name}"
+    end
+
+    groups
+  end
+
+  def service
+    raise ArgumentError, "No service for generic instance"
+  end
+
+  def display_fields
+    [:zone, :name, :status]
+  end
+
+  def display
+    InstanceDisplay.new(self, display_fields)
+  end
+
+  def matches?(filters={})
+    approximate_status = filters.delete(:approximate_status)
+    matched = InstanceMatcher.matches?(self, filters)
+
+    # approximate status is not a single state
+    # it might require an ssh connection
+    matched &&= has_approximate_status?(approximate_status) if approximate_status
+    matched
+  end
+
+  protected
+
+end
+
+# load all instance files
+Dir.glob(File.dirname(__FILE__) + '/instance/*.rb') {|file| require file}
+
+
+
+

data/lib/maws/instance_collection.rb

@@ -0,0 +1,98 @@
+class InstanceCollection
+  include Enumerable
+
+  attr_accessor :members
+
+  def initialize(members = [])
+    @members = members.sort_by {|m| [m.region, m.zone.to_s, m.role.to_s, m.index || 1]}
+  end
+
+  def add(instance)
+    @members << instance
+  end
+
+  def each
+    @members.each {|m| yield m}
+  end
+
+  def empty?
+    @members.empty?
+  end
+
+  def first
+    @members.first
+  end
+
+  def *(x)
+    @members * x
+  end
+
+  def matching(filters = {})
+    InstanceCollection.new(self.find_all {|i| i.matches?(filters)})
+  end
+
+  def not_matching(filters)
+    InstanceCollection.new(self.find_all {|i| !i.matches?(filters)})
+  end
+
+  def services
+    self.map {|i| i.service}.uniq
+  end
+
+  def roles
+    map{|i| i.role}.uniq
+  end
+
+  def zones
+    map{|i| i.zone}.uniq
+  end
+
+  def roles_in_order_of(roles_list)
+    roles.sort_by {|r| roles_list.index(r)}
+  end
+
+  # scopes
+  def specified
+    self.matching(:groups => 'specified')
+  end
+
+  def not_specified
+    self.not_matching(:groups => 'specified')
+  end
+
+  def aws
+    self.matching(:groups => 'aws')
+  end
+
+  def alive
+    self.matching(:alive? => true)
+  end
+
+  def not_alive
+    self.matching(:alive? => false)
+  end
+
+  def with_service(service)
+    self.matching(:service => service.to_sym)
+  end
+
+  def with_role(role)
+    self.matching(:role => role)
+  end
+
+  def with_zone(zone)
+    self.matching(:zone => zone)
+  end
+
+  def without_role(role)
+    self.not_matching(:role => role)
+  end
+
+  def ebs
+    with_service(:ebs)
+  end
+
+  def with_approximate_status(status)
+    self.matching(:approximate_status => status)
+  end
+end

data/lib/maws/instance_display.rb

@@ -0,0 +1,84 @@
+class InstanceDisplay
+  def self.display_collection_for_role(role, instances)
+    headers = instances.first.display.headers
+    service_title = instances.first.service.to_s.downcase
+    info "\n\n**** " + role.upcase + " * #{service_title} ****************"
+
+    # separate by zone
+    previous_zone = instances.zones.first
+    rows = []
+    instances.map {|instance|
+      if previous_zone == instance.zone
+        rows << instance.display.values
+      else
+         previous_zone = instance.zone
+         rows << instance.display.blank_values
+         rows << instance.display.values
+       end
+    }
+
+    info table(headers, *rows)
+  end
+
+  def initialize(instance, fields)
+    @instance = instance
+    @fields = fields
+  end
+
+  def headers
+    @fields.map {|f| f.to_s.upcase.gsub('_', ' ')}
+  end
+
+  def values
+    @fields.collect do |field|
+      value = value(field, @instance.send(field))
+    end
+  end
+
+  def blank_values
+    @fields.map { "" }
+  end
+
+  def value(field, value)
+    if field.to_sym == :status
+      status(value)
+    else
+      value.to_s
+    end
+  end
+
+  def status(status)
+    case status
+    when 'unknown' : '?'
+    when 'non-existant' : 'n/a'
+    when 'terminated' : 'n/a (terminated)'
+    else status.to_s
+    end
+  end
+
+  def pretty_details
+    title = @instance.name.to_s.upcase
+    data = @instance.description.description
+
+    InstanceDisplay.pretty_describe(title, data)
+  end
+
+  def self.pretty_describe(title, data)
+    pretty_describe_heading(title)
+    if data.is_a? String
+      info data
+    else
+      ap data
+    end
+    pretty_describe_footer
+  end
+
+  def self.pretty_describe_heading(title)
+    title = title[0,62]
+    info "++++++++++ " + title + " " + ("+" * (75 - title.length))
+  end
+
+  def self.pretty_describe_footer
+    info "+-------------------------------------------------------------------------------------+\n\n\n"
+  end
+end

data/lib/maws/instance_matcher.rb

@@ -0,0 +1,27 @@
+class InstanceMatcher
+  def self.matches?(instance, filters)
+    filters.each {|filter, expected_value|
+      value = instance.send(filter)
+      if value.is_a? Array
+        return false if value.find_all {|v| value_matches?(v, expected_value)}.empty?
+      else
+        return false unless value_matches?(value, expected_value)
+      end
+    }
+    true
+  end
+
+  private
+  def self.value_matches?(value, expected_value)
+    if expected_value.is_a? Array
+      return false unless expected_value.include?(value)
+    else
+      if !expected_value # treat false/nil as the same
+        return !value
+      else
+        return false if expected_value != value
+      end
+    end
+    true
+  end
+end

data/lib/maws/loader.rb

@@ -0,0 +1,173 @@
+require 'yaml'
+
+require 'maws/maws'
+
+require 'maws/profile_loader'
+require 'maws/command_loader'
+
+require 'maws/command_options_parser'
+
+class Loader
+
+  def initialize(base_path, config_config_path)
+    @base_path = base_path
+    @cc_path = config_config_path
+    @commands_path = File.expand_path("commands/", File.dirname(__FILE__))
+
+    # stores all config
+    @config = mash
+    @command = nil
+
+    Loader.config_file_must_exist!('main', @cc_path)
+
+    @command_options_parser = CommandOptionsParser.new(@config)
+  end
+
+  def load_and_run
+    load_config
+    load_command
+    initialize_command
+
+    parse_command_line_options
+    verify_command
+
+    @maws = Maws.new(@config, @command)
+    @command.maws = @maws
+
+    @maws.run!
+  end
+
+  private
+
+  def load_config
+    @config.config = mash(YAML.load_file(@cc_path))
+
+    @config.config.paths.commands = @commands_path
+    @config.config.paths.base = @base_path
+    @config.config.paths.config = @cc_path
+    @config.config.paths.template_output = 'tmp/'
+
+    expand_config_paths
+
+    load_aws_key
+    glob_available_profiles_and_commands
+    read_core_command_line_options
+    exit_with_basic_help_usage if needs_basic_help_usage?
+    exit_on_missing_profile
+    exit_on_missing_command
+
+    ProfileLoader.new(@config).load
+  end
+
+  def load_command
+    CommandLoader.new(@config).load
+  end
+
+  def initialize_command
+    @command = @config.command_class.new(@config)
+  end
+
+  def parse_command_line_options
+    @command_options_parser.process_command_options(@command)
+    @command.process_options
+  end
+
+  def verify_command
+    @command.verify_options
+    @command.verify_configs
+  end
+
+  def load_aws_key
+    Loader.config_file_must_exist!('aws_key', @config.config.paths.aws_key)
+
+    @config.aws_key = mash
+
+    key_id, secret_key = *File.read(@config.config.paths.aws_key).lines.map {|l| l.chomp}
+    @config.aws_key.key_id = key_id
+    @config.aws_key.secret_key = secret_key
+  end
+
+  def glob_available_profiles_and_commands
+    available_profiles = mash
+    available_commands = mash
+
+    Dir.glob(@config.config.paths.profiles + '/*.yml').each {|path|
+      name = File.basename(path,'.yml')
+      available_profiles[name] = path
+    }
+
+    Dir.glob(@config.config.paths.commands + '/*.rb').each {|path|
+      name = File.basename(path,'.rb')
+      available_commands[name] = path
+    }
+
+    @config.config.available_profiles = available_profiles
+    @config.config.available_commands = available_commands
+  end
+
+  def read_core_command_line_options
+    @config.command_line = mash
+    @config.command_line.profile_name = ARGV.shift
+    @config.command_line.command_name = ARGV.shift
+  end
+
+  def needs_basic_help_usage?
+    profile_name = @config.command_line.profile_name
+    command_name = @config.command_line.command_name
+
+    profile_name.blank? ||
+    command_name.blank? ||
+    profile_name == '-h' ||
+    profile_name == '--help' ||
+    command_name == '-h' ||
+    command_name == '--help'
+  end
+
+  def exit_with_basic_help_usage
+    profile_name = @config.command_line.profile_name
+    command_name = @config.command_line.command_name
+
+    profile_name = nil if profile_name == '-h' || profile_name == '--help'
+    command_name = nil if command_name == '-h' || command_name == '--help'
+
+    exit_with_basic_usage(profile_name, command_name)
+  end
+
+  def exit_on_missing_profile
+    profile_name = @config.command_line.profile_name
+
+    if @config.config.available_profiles[profile_name].blank?
+      puts "ERROR: no such profile: #{profile_name}"
+      exit_with_basic_usage(profile_name, @config.command_line.command_name)
+    end
+  end
+
+  def exit_on_missing_command
+    command_name = @config.command_line.command_name
+
+    if @config.config.available_commands[command_name].blank?
+      puts "ERROR: no such command: #{command_name}"
+      exit_with_basic_usage(@config.command_line.profile_name, command_name)
+    end
+  end
+
+  def exit_with_basic_usage(profile_name, command_name)
+    puts @command_options_parser.usage(profile_name, command_name)
+    exit(1)
+  end
+
+  def expand_config_paths
+    base_path = @config.config.paths.base
+    @config.config.paths.each { |path_name, path_location|
+      @config.config.paths[path_name] = File.expand_path(path_location, base_path)
+    }
+  end
+
+  def self.config_file_must_exist!(name, path)
+    unless File.exists? path
+      error "No #{name} config: #{path} found. Quiting!"
+      exit(1)
+    end
+  end
+
+end

data/lib/maws/logger.rb

@@ -0,0 +1,66 @@
+class NullLogger
+  def error str
+  end
+
+  def warn str
+  end
+
+  def info str
+  end
+
+  def debug str
+  end
+end
+
+
+class RightAWSLogger
+  def error str
+    $stderr.puts "[ERROR]: #{str}"
+  end
+
+  def warn str
+    puts "[warning]: #{str}"
+  end
+
+  def info str
+    puts "---- " + str.to_s
+  end
+
+  def debug str
+    puts str
+  end
+end
+
+class MawsLogger
+  def error str
+    $stderr.puts "[ERROR]: #{str}"
+  end
+
+  def warn str
+    puts "[warning]: #{str}"
+  end
+
+  def info str
+    puts str
+  end
+
+  def debug str
+    puts str
+  end
+end
+
+$logger ||= MawsLogger.new
+$right_aws_logger ||= RightAWSLogger.new
+
+
+def info str
+  $logger.info str
+end
+
+def error str
+  $logger.error str
+end
+
+def warn str
+  $logger.warn str
+end

data/lib/maws/mash.rb

@@ -0,0 +1,9 @@
+require 'hashie'
+
+class Hashie::Mash
+  undef :count # usually count is the number of keys mash has
+end
+
+def mash(x = {})
+  Hashie::Mash.new x
+end