leeroy_app 0.1.0

data/lib/leeroy/helpers/aws.rb

@@ -0,0 +1,403 @@
+require 'aws-sdk'
+require 'base64'
+
+require 'leeroy/helpers'
+require 'leeroy/helpers/env'
+
+require 'leeroy/types/instance'
+require 'leeroy/types/mash'
+require 'leeroy/types/semaphore'
+
+module Leeroy
+  module Helpers
+    module AWS
+      include Leeroy::Helpers
+
+      attr :ec2, :s3
+
+      def initialize(*args, &block)
+        super(*args, &block)
+
+        logger.debug "initializing AWS helpers"
+
+        @ec2 = Aws::EC2::Client.new
+        @s3 = Aws::S3::Client.new
+
+        logger.debug "AWS helpers initialized"
+      end
+
+      # EC2
+
+      def ec2Request(method, params = {}, ec2 = self.ec2, options = self.options, global_options = self.global_options)
+        begin
+          logger.debug "constructing EC2 request for '#{method}'"
+          logger.debug "params: #{params.inspect}"
+
+          params_mash = Leeroy::Types::Mash.new(params)
+          params = params_mash
+
+          dry_run = global_options[:op] ? false : true
+
+          params.dry_run = dry_run
+
+          logger.debug "params: #{params.inspect}"
+
+          resp = ec2.send(method.to_sym, params)
+
+          logger.debug "resp: #{resp.inspect}"
+
+          resp
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def getVpcId(vpcname, ec2 = self.ec2)
+        begin
+          logger.debug "getting VPC ID for '#{vpcname}'"
+
+          resp = ec2Request(:describe_vpcs, {:filters => [{name: 'tag:Name', values: [vpcname]}]})
+          vpcs = resp.vpcs
+          logger.debug "vpcs: #{vpcs.inspect}"
+
+          if vpcs.length < 1
+            raise "No VPC found with the name '#{vpcname}'."
+          elsif vpcs.length > 1
+            raise "Multiple VPCs found with the name '#{vpcname}'."
+          else
+            vpcid = vpcs[0].vpc_id
+          end
+
+          logger.debug "vpcid: #{vpcid}"
+          vpcid
+
+        rescue Aws::EC2::Errors::DryRunOperation => e
+          logger.info e.message
+          "DRYRUN_DUMMY_VALUE: #{self.class.to_s}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def getSgId(sgname, vpcname, vpcid, ec2 = self.ec2)
+        begin
+          logger.debug "getting SG ID for '#{sgname}'"
+
+          resp = ec2Request(:describe_security_groups, {:filters => [{name: 'vpc-id', values: [vpcid]}]})
+          security_groups = resp.security_groups
+
+          # now filter by sgname
+          sgmatcher = %r{#{vpcname}-#{sgname}-.*}
+          security_group = security_groups.select { |sg| sg.group_name =~ sgmatcher}
+          logger.debug "security_group: #{security_group.inspect}"
+
+          if security_group.length < 1
+            raise "No SG found with the name '#{sgname}'."
+          elsif security_group.length > 1
+            raise "Multiple SGs found with the name '#{sgname}'."
+          else
+            sgid = security_group[0].group_id
+          end
+
+          logger.debug "sgid: #{sgid}"
+          sgid
+
+        rescue Aws::EC2::Errors::DryRunOperation => e
+          logger.info e.message
+          "DRYRUN_DUMMY_VALUE: #{self.class.to_s}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def getSubnetId(subnetname, vpcid, ec2 = self.ec2)
+        begin
+          logger.debug "getting Subnet ID for '#{subnetname}'"
+
+          resp = ec2Request(:describe_subnets, {:filters => [{name: 'vpc-id', values: [vpcid]}, {name: 'tag:Name', values: [subnetname]}]})
+          subnets = resp.subnets
+          logger.debug "subnets: #{subnets.inspect}"
+
+          if subnets.length < 1
+            raise "No Subnet found with the name '#{subnetname}'."
+          elsif subnets.length > 1
+            raise "Multiple Subnets found with the name '#{subnetname}'."
+          else
+            subnetid = subnets[0].subnet_id
+          end
+
+          logger.debug "subnetid: #{subnetid}"
+          subnetid
+
+        rescue Aws::EC2::Errors::DryRunOperation => e
+          logger.info e.message
+          "DRYRUN_DUMMY_VALUE: #{self.class.to_s}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def destroyInstance(state = self.state, env = self.env, ec2 = self.ec2, options = self.options)
+        begin
+          # did we get instance ID(s)?
+          instanceids = options.fetch(:instance, nil)
+          if instanceids.nil?
+            instanceids = Array(state.instanceid)
+          end
+
+          logger.debug "instanceids: #{instanceids}"
+
+          run_params = Leeroy::Types::Mash.new
+          run_params.instance_ids = instanceids
+
+          resp = ec2Request(:terminate_instances, run_params)
+
+          resp.terminating_instances.collect { |i| i.instance_id }.sort
+
+        rescue Aws::EC2::Errors::DryRunOperation => e
+          logger.info e.message
+          "DRYRUN_DUMMY_VALUE: #{self.class.to_s}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+
+      def createTags(tags = {}, resourceids = [], state = self.state, env = self.env, ec2 = self.ec2, options = self.options)
+        begin
+          if resourceids.length == 0
+            if state.instanceid?
+              logger.debug "no resourceids provided for tagging, defaulting to instanceid #{state.instanceid} from state"
+              resourceids.push(state.instanceid.to_s)
+            end
+          end
+
+          run_params = Leeroy::Types::Mash.new
+
+          logger.debug "resourceids: #{resourceids}"
+          run_params.resources = resourceids
+
+          tag_array = tags.collect {|key,value| {'key' => key, 'value' => value}}
+
+          logger.debug "tags: #{tags}"
+          logger.debug "tag_array: #{tag_array}"
+          run_params.tags = tag_array
+
+          resp = ec2Request(:create_tags, run_params)
+
+        rescue Aws::EC2::Errors::DryRunOperation => e
+          logger.info e.message
+          "DRYRUN_DUMMY_VALUE: #{self.class.to_s}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def filterImages(selector, collector = lambda { |x| x }, state = self.state, env = self.env, ec2 = self.ec2, options = self.options)
+        begin
+          run_params = Leeroy::Types::Mash.new
+
+          run_params.owners = ['self']
+
+          resp = ec2Request(:describe_images, run_params)
+
+          # now filter based on callback
+          resp.images.select {|x| selector.call(x)}.collect {|x| collector.call(x)}
+
+        rescue Aws::EC2::Errors::DryRunOperation => e
+          logger.info e.message
+          "DRYRUN_DUMMY_VALUE: #{self.class.to_s}"
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def getGoldMasterInstanceName(env_name = 'LEEROY_GOLD_MASTER_NAME')
+        checkEnv(env_name)
+      end
+
+      def getApplicationInstanceName(index, env_app = 'LEEROY_APP_NAME', env_name = 'LEEROY_BUILD_TARGET')
+        name_prefix = [checkEnv(env_app), checkEnv(env_name), index].join('-')
+        logger.debug "name_prefix: #{name_prefix}"
+
+        if index.nil?
+          # determine the index by looking at existing images
+          selector = lambda {|image| image.name =~ /^#{name_prefix}/}
+          # and extract the names
+          collector = lambda {|image| image.name}
+
+          image_names = filterImages(selector, collector)
+          logger.debug image_names.awesome_inspect
+        end
+
+      end
+
+      def getGoldMasterImageIndex(env_prefix = 'LEEROY_GOLD_MASTER_IMAGE_PREFIX')
+        name_prefix = checkEnv(env_prefix)
+        logger.debug "name_prefix: #{name_prefix}"
+
+        # determine the index by looking at existing images
+        selector = lambda {|image| image.name =~ /^#{name_prefix}/}
+        # and extract the names
+        collector = lambda {|image| image.name}
+
+        image_names = filterImages(selector, collector)
+        image_numbers = image_names.collect do |name|
+          if name =~ /(\d+)$/
+            image_number = $1.to_i
+          end
+        end
+
+        latest_image = image_numbers.sort.compact.uniq.pop
+        logger.debug "latest_image: #{latest_image}"
+
+        latest_image
+
+      end
+
+      # S3
+
+      def s3Request(method, params = {}, s3 = self.s3, options = self.options, global_options = self.global_options)
+        begin
+          logger.debug "constructing S3 request for '#{method}'"
+
+          params_mash = Leeroy::Types::Mash.new(params)
+          params = params_mash
+
+          logger.debug "params: #{params.inspect}"
+
+          resp = s3.send(method.to_sym, params)
+
+          logger.debug "resp: #{resp.inspect}"
+
+          resp
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def buildS3ObjectName(key, type, prefixes = Leeroy::Env::S3_PREFIXES)
+        begin
+          logger.debug "building S3 prefix (key: #{key}, type: #{type})"
+          pfx = Leeroy::Types::Mash.new(prefixes)
+          root = pfx.jenkins
+          prefix = pfx.fetch(type,type)
+
+          # FIXME i should do this with URI
+          [root, prefix, key].join('/')
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def genSemaphore(object, payload = '', bucket = checkEnv('LEEROY_S3_BUCKET'))
+        begin
+          logger.debug "creating a semaphore"
+
+          semaphore = Leeroy::Types::Semaphore.new(bucket: bucket, object: object, payload: payload)
+          logger.debug "semaphore: #{semaphore}"
+
+          semaphore
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def setSemaphore(semaphore)
+        begin
+          unless semaphore.kind_of?(Leeroy::Types::Semaphore)
+            semaphore = Leeroy::Types::Semaphore.new(semaphore)
+          end
+
+          logger.debug "setting a semaphore"
+
+          run_params = Leeroy::Types::Mash.new
+
+          run_params.body = semaphore.payload
+          run_params.bucket = semaphore.bucket
+          run_params.key = semaphore.object
+
+          resp = s3Request(:put_object, run_params)
+
+          semaphore
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def clearSemaphore(semaphore)
+        begin
+          logger.debug "semaphore.class: #{semaphore.class}"
+
+          if semaphore.kind_of?(Leeroy::Types::Semaphore)
+            logger.debug "received a semaphore, continuing"
+          else
+            logger.debug "did not receive a semaphore, initializing"
+            semaphore = Leeroy::Types::Semaphore.new(semaphore)
+          end
+
+          run_params = Leeroy::Types::Mash.new
+          run_params.bucket = semaphore.bucket
+          run_params.key = semaphore.object
+
+          # is the object present in S3?
+          resp = checkSemaphore(semaphore)
+
+          if checkSemaphore(semaphore)
+            logger.debug "#{semaphore} present, deleting"
+            resp = s3Request(:delete_object, run_params)
+          else
+            logger.debug "#{semaphore} not present, continuing"
+          end
+
+          semaphore
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def checkSemaphore(semaphore)
+        begin
+          unless semaphore.kind_of?(Leeroy::Types::Semaphore)
+            semaphore = Leeroy::Types::Semaphore.new(semaphore)
+          end
+
+          run_params = Leeroy::Types::Mash.new
+          run_params.bucket = semaphore.bucket
+          run_params.key = semaphore.object
+
+          # is the object present in S3?
+          logger.debug "checking for presence of #{semaphore}"
+          resp = s3Request(:head_object, run_params)
+
+          if resp.delete_marker.nil?
+            resp
+          else
+            logger.debug "#{semaphore} already deleted"
+            nil
+          end
+
+        rescue Aws::S3::Errors::NotFound => e
+          logger.debug "#{semaphore} not found"
+          nil
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+    end
+  end
+end

data/lib/leeroy/helpers/dumpable.rb

@@ -0,0 +1,72 @@
+require 'multi_json'
+
+require 'leeroy/types/mash'
+require 'leeroy/helpers/logging'
+
+module Leeroy
+  module Helpers
+    module Dumpable
+
+      attr_accessor :dump_properties
+
+      def dump
+        begin
+          logger.debug "beginning dump"
+
+          dump_mash = Leeroy::Types::Mash.new
+
+          dump_properties = self.dump_properties
+          logger.debug "dump_properties: #{dump_properties.inspect}"
+
+          if dump_properties.length == 0
+            logger.warn "dumping an object with no dump_properties set, this is unlikely to end well"
+          end
+
+          self.dump_properties.each do |property|
+            logger.debug "dumping property '#{property.to_s}'"
+            if self.respond_to?(property.to_sym)
+              begin
+                raw = self.fetch(property.to_s)
+
+                # logger.debug "raw: #{raw.inspect}"
+
+                cooked = raw.respond_to?(:dumper) ? raw.dumper : raw
+
+                # logger.debug "cooked: #{cooked.inspect}"
+
+                dump_mash.store(property.to_s, cooked)
+
+              rescue KeyError => e
+                logger.debug e.message
+              end
+            end
+          end
+
+          logger.debug "dump_mash: #{dump_mash.inspect}"
+
+          MultiJson.dump(dump_mash.to_hash)
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def dumper
+        begin
+          dump_hash = {}
+
+          self.dump_properties.each do |property|
+            the_prop = self.send(property.to_sym)
+            dump_hash[property] = the_prop.respond_to?(:dumper) ? the_prop.dumper : the_prop
+          end
+
+          dump_hash
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+    end
+  end
+end

data/lib/leeroy/helpers/env.rb

@@ -0,0 +1,42 @@
+require 'awesome_print'
+
+require 'leeroy/env'
+require 'leeroy/helpers'
+
+module Leeroy
+  module Helpers
+    module Env
+      include Leeroy::Helpers
+
+      attr_reader :env
+
+      def checkEnv(param, check = lambda { |x| ! x.nil? }, errmsg = "You must provide #{param} in the environment.", env = self.env)
+        begin
+          logger.debug "checking for '#{param}' in environment"
+
+          # get param from env
+          candidate = env.fetch(param, nil)
+          logger.debug "candidate: #{candidate}"
+
+          # check it against the check
+          check_passed = check.call(candidate)
+          logger.debug "check_passed: #{check_passed}"
+
+          if check_passed
+            candidate
+          else
+            raise errmsg
+          end
+
+        rescue NoMethodError => e
+          logger.error "unable to read environment! env: #{env.inspect}"
+          raise e
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+    end
+  end
+end

data/lib/leeroy/helpers/logging.rb

@@ -0,0 +1,36 @@
+require 'yell'
+require 'yell-adapters-syslog'
+
+require 'leeroy/helpers'
+require 'leeroy/helpers/env'
+
+module Leeroy
+  module Helpers
+    module Logging
+      include Leeroy::Helpers
+
+      # constants
+      TRUNCATE_THRESHOLD = 60
+
+      TRACE_FORMAT = "%d [%5L] %p (%M): %m"
+      TRACE_LEVELS = [:debug]
+
+      # define a logger
+      # Yell.new :stderr, name: self.class.to_s, format: TRACE_FORMAT, trace: TRACE_LEVELS, level: :debug
+      if ENV['ENVIRONMENT'] == 'production'
+        Yell.new :syslog, name: self.class.to_s, format: TRACE_FORMAT, trace: TRACE_LEVELS, level: :info, facility: :user
+      else
+        Yell.new :stderr, name: self.class.to_s, format: TRACE_FORMAT, trace: TRACE_LEVELS, level: :debug
+      end
+
+      # make this class loggable
+      self.class.send :include, Yell::Loggable
+
+      # make logger an instance method
+      def logger
+        self.class.logger
+      end
+
+    end
+  end
+end

data/lib/leeroy/helpers/polling.rb

@@ -0,0 +1,67 @@
+require 'smart_polling'
+
+require 'leeroy/helpers'
+require 'leeroy/helpers/env'
+require 'leeroy/types/mash'
+
+module Leeroy
+  module Helpers
+    module Polling
+      include Leeroy::Helpers
+      include Leeroy::Helpers::Env
+
+      POLL_CALLBACK = lambda {|x| raise 'this is the default callback, did you forget to set the poll_callback attribute?'}
+      POLL_TIMEOUT = 600 # seconds
+      POLL_INTERVAL = 10 # seconds
+
+      attr_accessor :poll_callback, :poll_timeout, :poll_interval, :poll_response
+
+      def poll(*args)
+        begin
+          logger.debug "beginning to poll"
+
+          callback = self.poll_callback
+          raise "callback must be a Proc" unless callback.kind_of?(Proc)
+
+          timeout = self.poll_timeout
+          interval = self.poll_interval
+
+          logger.debug "callback: #{callback.inspect}"
+          logger.debug "polling every #{interval} seconds for #{timeout} seconds"
+
+          SmartPolling.poll(timeout: timeout, interval: interval) do
+            poll_arg = args[0]
+            logger.debug "poll_arg: #{poll_arg.inspect}"
+            self.poll_response = callback.call(poll_arg)
+          end
+
+          response = self.poll_response
+          logger.debug "response: #{response.inspect}"
+
+          response
+
+        rescue Interrupt => e
+          logger.fatal "Keyboard interrupt"
+          raise e
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def initialize(*args, &block)
+        begin
+          super
+
+          @poll_callback = POLL_CALLBACK
+          @poll_timeout = POLL_TIMEOUT
+          @poll_interval = POLL_INTERVAL
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+    end
+  end
+end

data/lib/leeroy/helpers/state.rb

@@ -0,0 +1,59 @@
+require 'fcntl'
+require 'multi_json'
+
+require 'leeroy/helpers'
+
+module Leeroy
+  module Helpers
+    module State
+      include Leeroy::Helpers
+
+      attr_accessor :state
+
+      def state_from_pipe(state = {}, global_options = self.global_options)
+        begin
+          state.merge(load_state)
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def load_state
+        begin
+          logger.debug "loading state from stdin if available"
+
+          _stdin? ?  MultiJson.load($stdin.read, :symbolize_keys => true) : {}
+
+        rescue StandardError => e
+          raise e
+        end
+      end
+
+      def dump_state
+        logger.debug "dumping state to stdout"
+        $stdout.puts self.state.dump
+      end
+
+      def rotate_task_metadata
+        logger.debug "rotating task metadata"
+        if self.state.metadata.task?
+          self.state.metadata.previous = self.state.metadata.task
+        end
+        self.state.metadata.task = self.class.to_s
+      end
+
+      def to_s
+        "#{self.metadata},#{self.data}"
+      end
+
+      private
+
+      # this is preposterous BS and doubtless not portable to Windows
+      def _stdin?
+        $stdin.fcntl(Fcntl::F_GETFL, 0) == 0
+      end
+
+    end
+  end
+end

data/lib/leeroy/helpers.rb

@@ -0,0 +1,9 @@
+require 'leeroy'
+
+module Leeroy
+  module Helpers
+
+    private
+
+  end
+end