maws 0.8.0

data/lib/maws/maws.rb

@@ -0,0 +1,102 @@
+require 'maws/instance_collection'
+require 'maws/specification'
+require 'maws/connection'
+
+
+class Maws
+  attr_reader :instances, :config, :command, :connection, :descriptions
+
+  def initialize(config, command)
+    @config = config
+    @command = command
+
+    @connection = Connection.new(@config)
+
+    @instances = InstanceCollection.new
+    @specification = Specification.new(@config, @config.command_line.selection || "")
+  end
+
+  def services
+    @specification.services
+  end
+
+  def specified_roles
+    @specification.roles
+  end
+
+  def specified_zones
+    @specification.zones
+  end
+
+  def run!
+    connect
+    info "\n"
+    info "REGION: #{@config.region}"
+    info "AVAILABLE ZONES: #{@connection.available_zones.join(', ')}"
+    build_instances
+
+    info "\n"
+    info "QUERYING SERVICES: #{instances.services.join(', ')}"
+    info "TOTAL #{@config.profile.name.upcase} ON AWS: #{instances.aws.count}  "
+    info "TOTAL SELECTED: #{instances.specified.count}"
+    info "TOTAL SELECTED ON AWS: #{instances.specified.aws.count}"
+
+    @command.run!
+  end
+
+  def connect(services = nil)
+    services ||= @specification.services
+    @connection.connect(services)
+
+    @config.available_zones = @connection.available_zones
+    @config.specified_zones = @specification.zones
+  end
+
+  def resync_instances
+    @descriptions = @connection.descriptions(services)
+    @descriptions.each {|description|
+      instance = @instances.matching(:aws_id => description.aws_id).first
+      instance.description = description if instance
+    }
+  end
+
+  def build_instances
+    @descriptions = @connection.descriptions(services)
+
+    create_from_descriptions
+    create_from_specification
+  end
+
+  def create_from_descriptions
+    @descriptions.map { |description|
+      instance = description.create_instance(self, @config)
+      @instances.add(instance)
+      instance.groups << "aws"
+    }
+  end
+
+  def create_from_specification
+    @specification.existing_instances = @instances.matching(:groups => 'aws')
+
+    prefix = @config.prefix
+    @specification.role_indexes.each {|role_name, indexes|
+      @specification.zones_for_role(role_name).each {|zone|
+        indexes.each do |index|
+          instance = find_or_create_specified(prefix, zone, role_name, index)
+          instance.groups << "specified"
+        end
+      }
+    }
+  end
+
+  def find_or_create_specified(prefix, zone, role_name, index)
+    found = @instances.matching({:zone => zone, :role => role_name, :index => index, :prefix => prefix})
+    if !found.empty?
+      found.first
+    else
+      instance = Instance.create(self, @config, prefix, zone, role_name, index)
+      @instances.add(instance)
+      instance
+    end
+  end
+end

data/lib/maws/profile_loader.rb

@@ -0,0 +1,92 @@
+class ProfileLoader
+  RESERVED_ROLE_NAMES = %w(roles lanes name zones aliases settings security_rules)
+
+  def initialize(config)
+    @config = config
+  end
+
+  def load
+    # assumes profile file is known to exist already
+    load_profile
+    load_roles
+    load_security_rules
+
+    exit_on_missing_roles
+    create_combined
+  end
+
+  private
+
+  def load_profile
+    profile_name = @config.command_line.profile_name
+    profile_path = @config.config.available_profiles[profile_name]
+
+    @config.profile = mash(YAML.load_file(profile_path))
+    @config.profile.name = profile_name
+
+    @config.available_roles = @config.profile.keys - RESERVED_ROLE_NAMES
+    sort_available_roles_by_appearance_in_profile(profile_path)
+  end
+
+  def sort_available_roles_by_appearance_in_profile(profile_path)
+    # hacky, but does the job
+    profile_text = File.read(profile_path)
+    @config.available_roles = @config.available_roles.sort_by {|role_name| profile_text.index(role_name+":")}
+  end
+
+  def load_roles
+    roles_file_name = @config.profile.roles
+    roles_file_path = File.join(@config.config.paths.roles, roles_file_name) + ".yml"
+    Loader.config_file_must_exist!('roles file', roles_file_path)
+
+    @config.roles = mash(YAML.load_file(roles_file_path))
+    @config.roles.name = roles_file_name
+  end
+
+  def load_security_rules
+    security_rules_file_name = @config.profile.security_rules
+
+    if security_rules_file_name.blank?
+    else
+      security_rules_file_path = File.join(@config.config.paths.security_rules, security_rules_file_name) + ".yml"
+      Loader.config_file_must_exist!('security rules file', security_rules_file_path)
+
+      @config.security_rules = mash(YAML.load_file(security_rules_file_path))
+    end
+  end
+
+  def exit_on_missing_roles
+    profile_config_role_names = @config.profile.keys - RESERVED_ROLE_NAMES
+    roles_config_role_names = @config.roles.keys - RESERVED_ROLE_NAMES
+
+    unknown_roles_in_profile_config = profile_config_role_names - roles_config_role_names
+
+    unless unknown_roles_in_profile_config.empty?
+      error "Undefined roles [%s] in profile '%s'" % [unknown_roles_in_profile_config.join(', '), @config.profile.name]
+      exit(1)
+    end
+  end
+
+  def create_combined
+    @config.combined = mash
+    # combine roles
+    @config.available_roles.each {|role_name|
+      @config.combined[role_name] = @config.roles[role_name].deep_merge(@config.profile[role_name])
+
+      # now combine configurations - these are arrays that need to be unioned
+      @config.combined[role_name].configurations = []
+      # first collect all configurations with the same name for this role
+      grouped_configurations = ((@config.roles[role_name].configurations || []) +
+                                (@config.profile[role_name].configurations || [])).
+                                      group_by {|c| c.name }
+      # now merge all for the same name
+      grouped_configurations.each {|name, configurations|
+        merged_configuration = configurations.inject(configurations.first) { |merged, configuration| merged.deep_merge(configuration)}
+        @config.combined[role_name].configurations << merged_configuration
+      }
+    }
+
+    # combine settings
+    @config.combined.settings = @config.roles.settings.deep_merge(@config.profile.settings)
+  end
+end

data/lib/maws/specification.rb

@@ -0,0 +1,127 @@
+class Specification
+  LARGEST_INDEX = 999
+
+  attr_accessor :existing_instances
+
+  def initialize(config, spec)
+    @config = config
+    @spec = spec
+  end
+
+  # [:ec2, :rds, :elb]
+  def services
+    roles.map { |role_name|
+      @config.roles[role_name].service
+    }.compact.uniq.map{|service| service.to_sym}
+  end
+
+  # ['a', 'b', 'd']
+  def zones
+    found = @config.available_zones.find_all {|az|
+      @spec.match(%r{\b#{az}\b})
+    }
+    found.empty? ? @config.available_zones : found
+  end
+
+  def zones_for_role(role)
+    if @config.combined[role].scope != 'zone'
+      [nil]
+    else
+      zones
+    end
+  end
+
+  # {'app' => [1,2,3,4], 'web' => [3], 'db' => [4,5,6,7,8,9,10,11,12]}
+  def role_indexes
+    indexes = {}
+    roles.each {|role_name|
+      indexes[role_name] = indexes_range_for_role(role_name)
+    }
+
+    indexes.delete_if {|role, index_range| index_range.nil?}
+    indexes.each {|role, index_range| indexes[role] = resolve_index_range(role, index_range)}
+
+    indexes
+  end
+
+  # ('app', [nil, *]) => [1,2,3,4,5,6,7]
+  def resolve_index_range(role, range)
+    lower = range[0]
+    upper = range[1]
+
+    lower = 1 if lower.nil?
+
+    # replace upper
+    if upper == '*'
+      # max existing index
+      max_existing = @existing_instances.matching(:role => role).map {|i| i.index}.max.to_i
+      max_profile = @config.profile[role].count
+
+      upper = [max_profile, max_existing].max
+    end
+
+    if upper.nil?
+      # max index in profile
+      upper = @config.profile[role].count
+    end
+
+    lower.upto(upper).to_a
+  end
+
+  def indexes_range_for_role(role)
+    # 'app'       =>  [nil, nil, nil]     => [nil, nil]
+    # 'app-'      =>  [nil, nil, nil]     => [nil, nil]
+    # 'app-*'     =>  ["*", nil, nil]     => [nil, '*']
+    # 'app-3'     =>  ["3", nil, nil]     => [3,3]
+    # 'app-3-'    =>  ["3", '-', nil]     => [3, nil]
+    # 'app-3-*'   =>  ["3", '-', "*"]     => [3, '*']
+    # 'app-1-3'   =>  ["1", '-', "3"]     => [1, 3]
+
+    # '*' => [nil, '*']
+    # ''  => [nil, nil]
+
+
+    md = @spec.match(%r{\b#{role}(?=\b)-?(?![^\*\d\s])(\d+|\*)?(-)?(\d+|\*)?})
+
+    # no match, either badly formed specification
+    # or '*' or '' (star and blank) specs
+    if md.nil?
+      anyzone = zones.join('')
+      index = if @spec.match(%r{^[#{anyzone}\s]*\*[#{anyzone}\s]*$}) # single '*' with zones
+        [nil, '*']
+      elsif @spec.match(%r{^[#{anyzone}\s]*$}) # blank
+        [nil, nil]
+      else
+        nil
+      end
+      return index
+    end
+
+    lower, separator, upper = md[1], md[2], md[3]
+
+    return nil unless lower.nil? || lower == '*' || lower =~ /^\d+$/
+    return nil unless upper.nil? || upper == '*' || upper =~ /^\d+$/
+
+
+
+    # convert to integers
+    lower = lower.to_i unless lower == '*' or lower.nil?
+    upper = upper.to_i unless upper == '*' or upper.nil?
+
+    # single star is upper bound, not lower bound
+    lower, upper = upper, lower if lower == '*'
+
+    # lower digit without separator and without upper digit means single index
+    if lower and separator.nil? and upper.nil?
+      upper = lower
+    end
+
+    [lower, upper]
+  end
+
+  def roles
+    roles = @config.available_roles.find_all { |role_name| @spec.include?(role_name) }
+    roles = @config.available_roles if roles.blank? # use all if none are specified
+    roles
+  end
+end

data/lib/maws/ssh.rb

@@ -0,0 +1,7 @@
+require 'net/ssh'
+
+class Net::SSH::Authentication::KeyManager
+  def use_agent?
+    false
+  end
+end