class Leeroy::Task::Instantiate

Public Class Methods

new(*args, &block) click to toggle source
Calls superclass method Leeroy::Helpers::Polling::new
# File lib/leeroy/task/instantiate.rb, line 60
def initialize(*args, &block)
  super

end

Public Instance Methods

perform(args = self.args, options = self.options, global_options = self.global_options) click to toggle source
Calls superclass method Leeroy::Task::Base#perform
# File lib/leeroy/task/instantiate.rb, line 16
def perform(args = self.args, options = self.options, global_options = self.global_options)
  begin
    super(args, options, global_options)

    phase = Leeroy::Types::Phase.resolve(self.state.fetch('phase'), options[:phase])
    logger.debug "phase: #{phase}"
    self.state.phase = phase

    # resolve various AWS resources from human-readable inputs
    _resolveResources

    # create instance
    instance = Leeroy::Types::Instance.new(_genInstanceParams)
    resp = ec2Request(:run_instances, instance.run_params)
    instanceid = resp.instances[0].instance_id
    self.state.instanceid = instanceid

    # wait until instance is starting
    _prepInstanceCreationPolling
    poll(instanceid)

    # tag instance
    instance_name = phase == 'gold_master' ? getGoldMasterInstanceName : getApplicationInstanceName
    createTags({'Name' => instance_name})

    # write semaphore
    s3_object = buildS3ObjectName(instanceid, 'semaphores')
    payload = _readSemaphore(phase)
    semaphore = setSemaphore(genSemaphore(s3_object, payload))
    self.state.semaphore = semaphore

    # wait until instance is done provisioning
    _prepInstanceProvisionPolling
    poll(semaphore)

    dump_state

    logger.debug "done performing for #{self.class}"

  rescue StandardError => e
    raise e
  end
end

Private Instance Methods

_genInstanceParams(state = self.state, env = self.env, ec2 = self.ec2, options = self.options) click to toggle source
# File lib/leeroy/task/instantiate.rb, line 137
def _genInstanceParams(state = self.state, env = self.env, ec2 = self.ec2, options = self.options)
  begin
    logger.debug "generating params for creating an EC2 instance"

    # gather the necessary parameters
    instance_params = Leeroy::Types::Mash.new

    instance_params.security_group_ids = Array(state.sgid)
    instance_params.subnet_id = state.subnetid

    instance_params.key_name = checkEnv('LEEROY_BUILD_SSH_KEYPAIR')
    instance_params.instance_type = checkEnv('LEEROY_BUILD_INSTANCE_TYPE')

    instance_params.min_count = 1
    instance_params.max_count = 1

    instance_params.store('iam_instance_profile', {:name =>  checkEnv('LEEROY_BUILD_PROFILE_NAME')})

    # some parameters depend on phase
    phase = options[:phase]
    logger.debug "phase is #{phase}"

    instance_params.phase = phase

    # AMI id depends on phase
    image_id = case phase
    when 'gold_master'
      checkEnv('LEEROY_AWS_LINUX_AMI')
    when 'application'
      state.imageid || getImageByName(genImageName('gold_master'))
    else
      nil
    end

    raise "unable to determine image ID for phase '#{phase}'" if image_id.nil?

    instance_params.image_id = image_id

    # user_data file depends on phase
    user_data = File.join(checkEnv('LEEROY_USER_DATA_PREFIX'), phase)
    if File.readable?(user_data)
      instance_params.user_data = IO.readlines(user_data).join('')
    else
      raise "You must provide a readable user data script at #{user_data}."
    end

    logger.debug "instance_params: #{instance_params.inspect}"

    instance_params

  rescue StandardError => e
    raise e
  end
end
_prepInstanceCreationPolling() click to toggle source
# File lib/leeroy/task/instantiate.rb, line 67
def _prepInstanceCreationPolling
  # poll to make sure instance is created
  self.poll_callback = lambda do |instanceid|
    begin
      run_params = { :instance_ids => [instanceid] }
      resp = ec2Request(:describe_instances, run_params)

    rescue Aws::EC2::Errors::InvalidInstanceIDNotFound => e
      logger.debug "instance #{instanceid} not found"
      nil
    rescue StandardError => e
      raise e
    end
  end

  self.poll_timeout = 30
  self.poll_interval = 2
end
_prepInstanceProvisionPolling() click to toggle source
# File lib/leeroy/task/instantiate.rb, line 86
def _prepInstanceProvisionPolling
  # poll until semaphore has been removed
  self.poll_callback = lambda {|s| checkSemaphore(s).nil?}
  self.poll_timeout = checkEnv('LEEROY_POLL_TIMEOUT').to_i
  self.poll_interval = checkEnv('LEEROY_POLL_INTERVAL').to_i
end
_readSemaphore(phase) click to toggle source
# File lib/leeroy/task/instantiate.rb, line 93
def _readSemaphore(phase)
  begin
    template = File.join(checkEnv('LEEROY_PROVISIONING_TEMPLATE_PREFIX'), "#{phase}.erb")
    renderTemplate(template, binding)

  rescue StandardError => e
    raise e
  end
end
_resolveResources(state = self.state, env = self.env, ec2 = self.ec2, options = self.options) click to toggle source
# File lib/leeroy/task/instantiate.rb, line 103
def _resolveResources(state = self.state, env = self.env, ec2 = self.ec2, options = self.options)
  begin
    # resolve VPC ID
    if state.vpcid?
      vpcid = state.vpcid
    else
      vpcname = checkEnv('LEEROY_BUILD_VPC')
      vpcid = getVpcId(vpcname)
      state.vpcid = vpcid
    end

    # resolve security group
    if state.sgid?
      sgid = state.sgid
    else
      sgname = checkEnv('LEEROY_BUILD_SECURITY_GROUP')
      sgid = getSgId(sgname, vpcname, vpcid)
      state.sgid = sgid
    end

    # resolve subnet
    if state.subnetid?
      subnetid = state.subnetid
    else
      subnetname = checkEnv('LEEROY_BUILD_SUBNET')
      subnetid = getSubnetId(subnetname, vpcid)
      state.subnetid = subnetid
    end

  rescue StandardError => e
    raise e
  end
end