leeroy_app 0.1.0

data/lib/leeroy/state.rb

@@ -0,0 +1,70 @@
+require 'leeroy/types/dash'
+require 'leeroy/types/statedata'
+require 'leeroy/types/statemetadata'
+require 'leeroy/helpers/logging'
+require 'leeroy/helpers/polling'
+require 'leeroy/helpers/state'
+
+module Leeroy
+  class State < Leeroy::Types::Dash
+    include Leeroy::Helpers::Dumpable
+    include Leeroy::Helpers::Logging
+    include Leeroy::Helpers::Polling
+    include Leeroy::Helpers::State
+
+    # state properties
+    property :data, coerce: Leeroy::Types::StateData, default: {}
+    property :metadata, coerce: Leeroy::Types::StateMetadata, default: {}
+
+    def fetch(*args, &block)
+      begin
+        self.data.send(:fetch, *args, &block)
+
+      rescue KeyError => e
+        logger.debug e.message
+
+        not_found = args[0]
+        logger.info "property '#{not_found}' not found in statedata, checking state"
+
+        begin
+          self.send(not_found.to_sym, &block)
+
+        rescue KeyError => e
+          logger.debug e.message
+
+          logger.warn "property '#{not_found}' not found in statedata or state"
+        end
+
+      rescue StandardError => e
+        raise e
+      end
+    end
+
+    def method_missing(method, *args, &block)
+      begin
+        self.data.send(method.to_sym, *args, &block)
+
+      rescue NoMethodError => e
+        logger.debug e.message
+        if self.respond_to?(method.to_sym)
+          self.send(method.to_sym, *args, &block)
+        else
+          raise e
+        end
+
+      rescue StandardError => e
+        raise e
+      end
+    end
+
+    def initialize(*args, &block)
+      super
+
+      self.dump_properties = [
+        :data,
+        :metadata,
+      ]
+    end
+
+  end
+end

data/lib/leeroy/task/base.rb

@@ -0,0 +1,61 @@
+require 'leeroy'
+require 'leeroy/env'
+require 'leeroy/helpers'
+require 'leeroy/helpers/env'
+require 'leeroy/helpers/logging'
+require 'leeroy/helpers/state'
+require 'leeroy/state'
+require 'leeroy/task'
+require 'leeroy/types/mash'
+
+module Leeroy
+  module Task
+    class Base
+
+      include Leeroy::Task
+      include Leeroy::Helpers
+      include Leeroy::Helpers::Env
+      include Leeroy::Helpers::Logging
+      include Leeroy::Helpers::State
+
+      def initialize(params = {})
+        begin
+          @global_options = params.fetch(:global_options, {})
+          logger.debug("global_options: #{self.global_options.to_s}")
+
+          logger.debug("setting options")
+          @options = params.fetch(:options, {})
+          logger.debug("options: #{self.options.to_s}")
+
+          logger.debug("setting args")
+          @args = params.fetch(:args, {})
+          logger.debug("args: #{self.args.to_s}")
+
+          logger.debug("setting env")
+          @env = Leeroy::Env.new({}, params.fetch(:env, ENV))
+          logger.debug("env: #{self.env.to_s}")
+
+          logger.debug("setting state")
+          @state = Leeroy::State.new(state_from_pipe(params.fetch(:state, {})))
+          rotate_task_metadata
+          logger.debug("state: #{self.state}")
+
+          logger.debug("base initialization of #{self.class.to_s} complete")
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def perform(args = self.args, options = self.options, global_options = self.global_options)
+        begin
+          self.logger.info("performing #{self.class.to_s}")
+          self.logger.debug("args: #{args.inspect}")
+          self.logger.debug("options: #{options.inspect}")
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/leeroy/task/image.rb

@@ -0,0 +1,126 @@
+require 'leeroy'
+require 'leeroy/task'
+require 'leeroy/helpers/aws'
+require 'leeroy/helpers/polling'
+require 'leeroy/types/image'
+require 'leeroy/types/phase'
+
+module Leeroy
+  module Task
+    class Image < Leeroy::Task::Base
+      include Leeroy::Helpers::AWS
+      include Leeroy::Helpers::Polling
+
+      def perform(args = self.args, options = self.options, global_options = self.global_options)
+        begin
+          super(args, options, global_options)
+
+          phase = Leeroy::Types::Phase.new(self.state.fetch('phase', options[:phase]))
+          self.state.phase = phase
+
+          # create image
+          image_params = _genImageParams(phase)
+
+          logger.debug "image_params: #{image_params.inspect}"
+
+          image = Leeroy::Types::Image.new(image_params)
+          resp = ec2Request(:create_image, image.run_params)
+
+          imageid = resp.image_id
+          logger.debug "imageid: #{imageid}"
+
+          self.state.imageid = imageid
+
+          _prepImageCreationPolling
+          poll(imageid)
+
+          dump_state
+
+          logger.debug "done performing for #{self.class}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      private
+
+      def _prepImageCreationPolling
+        # poll to make sure image is created
+        self.poll_callback = lambda do |imageid|
+          begin
+            run_params = { :image_ids => [imageid], :owners => ['self'] }
+            resp = ec2Request(:describe_images, run_params)
+
+            state = resp.images[0].state
+
+            if state == 'pending'
+              logger.debug "image #{imageid} still pending"
+              nil
+            elsif state == 'available'
+              logger.debug "image #{imageid} available"
+              imageid
+            else
+              raise "image creation failed: #{resp.images[0].state_reason.message}"
+            end
+
+          rescue Aws::EC2::Errors::InvalidAMIIDNotFound => e
+            logger.debug "instance #{instanceid} not found"
+            nil
+          rescue StandardError => e
+            raise e
+          end
+        end
+
+        self.poll_timeout = checkEnv('LEEROY_POLL_TIMEOUT').to_i
+        self.poll_interval = checkEnv('LEEROY_POLL_INTERVAL').to_i
+      end
+
+      def _genImageParams(phase, state = self.state, env = self.env, ec2 = self.ec2, options = self.options)
+        begin
+          logger.debug "generating params for creating an EC2 image"
+
+          image_params = Leeroy::Types::Mash.new
+
+          image_params.phase = phase
+
+          # get instance_id from state or options
+          instance_id = state.instanceid? ? state.instanceid : options[:instance]
+          raise "Unable to determine instance ID, exiting." if instance_id.nil?
+          logger.debug "instance_id: #{instance_id}"
+          image_params.instance_id = instance_id
+
+          # were we given an app_name?
+          app_name = state.app_name? ? state.app_name : checkEnv('LEEROY_APP_NAME')
+          logger.debug "app_name: #{app_name}"
+
+          # were we given an image index?
+          index = _genImageIndex(state, env, ec2, options).to_s
+          logger.debug "index: #{index}"
+
+          # build target depends on phase
+          build_target = phase == 'gold_master' ? 'master' : checkEnv('LEEROY_BUILD_TARGET')
+
+          image_params.name = [app_name, build_target, index].join('-')
+
+          image_params
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def _genImageIndex(state = self.state, env = self.env, ec2 = self.ec2, options = self.options)
+        begin
+          logger.debug "determining gold master instance ID"
+
+          options[:index] or getGoldMasterImageIndex.to_i + 1
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+    end
+  end
+end

data/lib/leeroy/task/instantiate.rb

@@ -0,0 +1,200 @@
+require 'leeroy'
+require 'leeroy/task'
+require 'leeroy/helpers/aws'
+require 'leeroy/helpers/polling'
+
+module Leeroy
+  module Task
+    class Instantiate < Leeroy::Task::Base
+      include Leeroy::Helpers::AWS
+      include Leeroy::Helpers::Polling
+
+      def perform(args = self.args, options = self.options, global_options = self.global_options)
+        begin
+          super(args, options, global_options)
+
+          phase = Leeroy::Types::Phase.new(self.state.fetch('phase', options[: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
+
+      def initialize(*args, &block)
+        super
+
+      end
+
+      private
+
+      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
+
+      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
+
+      def _readSemaphore(phase)
+        begin
+          template = File.join(checkEnv('LEEROY_PROVISIONING_TEMPLATE_PREFIX'), "#{phase}.erb")
+          logger.debug "processing template '#{template}'"
+
+          # this is heinous
+          # http://stackoverflow.com/a/22777806/17597
+          rendered = String.new
+
+          begin
+            old_stdout = $stdout
+            $stdout = StringIO.new('','w')
+            ERB.new(File.read(template)).run
+            rendered = $stdout.string
+          ensure
+            $stdout = old_stdout
+          end
+
+          rendered
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      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
+
+      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}"
+
+          # AMI id depends on phase
+          if phase == 'gold_master'
+            image_id = checkEnv('LEEROY_AWS_LINUX_AMI')
+          elsif phase == 'application'
+            image_id = state.imageid
+          end
+
+          instance_params.phase = phase
+
+          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
+    end
+  end
+end

data/lib/leeroy/task/sleep.rb

@@ -0,0 +1,29 @@
+require 'leeroy/task'
+
+module Leeroy
+  module Task
+    class Sleep < Leeroy::Task::Base
+
+      def perform(args = self.args, options = self.options, global_options = self.global_options)
+        super(args, options, global_options)
+
+        begin
+          logger.debug "performing for #{self.class}"
+          logger.debug "state: #{self.state}"
+
+          interval = self.options[:interval].to_i
+          logger.debug "sleeping: #{interval} seconds"
+
+          sleep interval
+
+          dump_state
+
+          logger.debug "done performing for #{self.class}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/leeroy/task/stub.rb

@@ -0,0 +1,40 @@
+require 'leeroy/task'
+
+module Leeroy
+  module Task
+    class Stub < Leeroy::Task::Base
+
+      def perform(args = self.args, options = self.options, global_options = self.global_options)
+        super
+
+        begin
+          logger.debug "performing for #{self.class}"
+          logger.debug "state: #{self.state}"
+          message = self.state.message
+
+          increment = self.options[:increment].to_i
+          logger.debug "increment: #{increment}"
+
+          logger.info "old message: #{message}"
+
+          if message.nil?
+            message = increment
+          else
+            message = message.to_i + increment
+          end
+
+          state.message = message
+
+          logger.info "new message: #{message}"
+
+          dump_state
+
+          logger.debug "done performing for #{self.class}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+    end
+  end
+end

data/lib/leeroy/task/terminate.rb

@@ -0,0 +1,49 @@
+require 'leeroy'
+require 'leeroy/task'
+require 'leeroy/helpers/aws'
+
+module Leeroy
+  module Task
+    class Terminate < Leeroy::Task::Base
+      include Leeroy::Helpers::AWS
+
+      def perform(args = self.args, options = self.options, global_options = self.global_options)
+        begin
+          super(args, options, global_options)
+
+          # destroy instance
+          terminated = destroyInstance
+
+          instanceid = self.state.instanceid
+          if terminated.include?(instanceid)
+            # clean up semaphore if present
+            semaphore = self.state.semaphore
+
+            if semaphore.nil?
+              # guess at semaphore from instance ID
+              s3_object = buildS3ObjectName(instanceid, 'semaphores')
+              bucket = checkEnv('LEEROY_S3_BUCKET')
+              semaphore = Leeroy::Types::Semaphore.new(bucket: bucket, object: s3_object, payload: '')
+            end
+
+            unless semaphore.nil?
+              logger.debug "clearing semaphore #{semaphore}"
+              clearSemaphore(semaphore)
+            end
+
+            logger.debug "clearing instanceid #{instanceid} from state"
+            self.state.instanceid = nil
+          end
+
+          dump_state
+
+          logger.debug "done performing for #{self.class}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+    end
+  end
+end

data/lib/leeroy/task.rb

@@ -0,0 +1,17 @@
+require 'leeroy'
+require 'leeroy/helpers'
+require 'leeroy/helpers/env'
+require 'leeroy/helpers/logging'
+require 'leeroy/helpers/state'
+require 'leeroy/task/base'
+
+module Leeroy
+  module Task
+    include Leeroy::Helpers
+    include Leeroy::Helpers::Env
+    include Leeroy::Helpers::State
+    include Leeroy::Helpers::Logging
+    attr_reader :global_options, :options, :args
+
+  end
+end

data/lib/leeroy/types/dash.rb

@@ -0,0 +1,17 @@
+require 'hashie'
+
+module Leeroy
+  module Types
+    class Dash < Hashie::Dash
+      include Hashie::Extensions::KeyConversion
+      include Hashie::Extensions::MethodAccess
+      include Hashie::Extensions::IndifferentAccess
+      include Hashie::Extensions::Dash::Coercion
+
+      def dumper
+        self.to_hash
+      end
+
+    end
+  end
+end

data/lib/leeroy/types/image.rb

@@ -0,0 +1,53 @@
+require 'leeroy'
+require 'leeroy/types/dash'
+require 'leeroy/types/mash'
+require 'leeroy/types/phase'
+require 'leeroy/helpers/dumpable'
+require 'leeroy/helpers/logging'
+
+module Leeroy
+  module Types
+    class Image < Leeroy::Types::Dash
+      include Leeroy::Helpers::Dumpable
+      include Leeroy::Helpers::Logging
+
+      property :phase, required: true, coerce: Leeroy::Types::Phase
+      property :aws_params
+
+      # AWS-specific params
+      property :instance_id, required: true
+      property :name, required: true
+
+      def initialize(*args, &block)
+        self.aws_params = [
+          :instance_id,
+          :name,
+        ]
+
+        self.dump_properties = self.aws_params
+
+        super
+      end
+
+      def run_params
+        begin
+          run_params = Leeroy::Types::Mash.new
+
+          self.aws_params.each {|key| run_params.store(key.to_s, self.fetch(key))}
+
+          logger.debug "run_params: #{run_params.inspect}"
+
+          run_params
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def to_s
+        self.instance_id
+      end
+
+    end
+  end
+end