staugaard-cloudmaster 0.1.3 → 0.1.4

data/VERSION.yml

@@ -1,4 +1,4 @@
 --- 
 :major: 0
 :minor: 1
-:patch: 3
+:patch: 4

data/app/active_set_factory.rb

@@ -0,0 +1,16 @@
+# This is a factory for ActiveSet implementations.
+require 'factory'
+
+module Cloudmaster
+  class ActiveSetFactory 
+    include Factory
+    def ActiveSetFactory.create(type, *params)
+      name = type.nil? ? 'none' : type.to_s
+      require 'active_set_' + name.downcase
+      class_name = 'ActiveSet' + name.capitalize
+      active_set = Factory.create_object_from_string(class_name, *params)
+      raise "Bad configuration -- bad active_set #{class_name}" unless active_set
+      active_set
+    end
+  end
+end

data/app/active_set_none.rb

@@ -0,0 +1,16 @@
+# This implementation of ActiveSet does nothing
+# It is appropriate when you don't want the active set.
+
+module Cloudmaster
+  class ActiveSetNone
+    def initialize(config)
+    end
+
+    def valid?
+      true
+    end
+
+    def update(active_set)
+    end
+  end
+end

data/app/active_set_queue.rb

@@ -0,0 +1,27 @@
+require 'aws_context'
+
+# This implementation of ActiveSet writes the active set to a queue
+
+module Cloudmaster
+  class ActiveSetQueue
+    def initialize(config)
+      @sqs = AwsContext.instance.sqs
+      active_set_queue_name = config.append_env(config[:active_set_queue])
+      @active_set_queue = NamedQueue.new(active_set_queue_name)
+    end
+
+    private
+
+    public
+
+    def valid?
+      ! @active_set_queue.nil?
+    end
+
+    def update(active_set)
+      body = active_set
+      body = ' ' if body.empty?
+      @sqs.send_message(@active_set_queue, body)
+    end
+  end
+end

data/app/active_set_s3.rb

@@ -0,0 +1,25 @@
+require 'aws_context'
+
+# This implementation of ActiveSet writes the active set to S3.
+
+module Cloudmaster
+  class ActiveSetS3
+    def initialize(config)
+      @s3 = AwsContext.instance.s3
+      @config = config
+    end
+
+    private
+
+    public
+
+    def valid?
+      @config[:active_set_bucket] && @config[:active_set_key]
+    end
+
+    def update(active_set)
+      @s3.create_object(@config[:active_set_bucket], 
+          @config.append_env(@config[:active_set_key]), :data => active_set)
+    end
+  end
+end

data/app/configuration.rb

@@ -0,0 +1,85 @@
+require 'inifile'
+require 'basic_configuration'
+require 'pp'
+
+# Configuration
+# Read an ini file and create a configuration.
+# The configuration contains the aws configuration, the defaults, and all the pool sections.
+
+module Cloudmaster
+
+  class Configuration < BasicConfiguration
+    attr_reader :default, :pools
+
+    # Create a config structure by reading the given config_filenames.
+    # The base class handles the aws config and the default config.
+    def initialize(config_files = [], opts = [])
+      @pools = []
+      @default = {}
+      @opts = opts
+      # search for config files in this directory too
+      super(config_files, [ File.dirname(__FILE__)])
+      @default.merge!({:user_data => { 
+        :aws_env => @aws[:aws_env],
+        :aws_access_key => @aws[:aws_access_key],
+	:aws_secret_key => @aws[:aws_secret_key]}})
+    end
+
+    def refresh
+      @pools = []
+      @default = {}
+      super
+    end
+
+    private
+
+    # Read the config file
+    def read(config_file)
+      ini = super(config_file)
+      return nil unless ini
+      
+      @default.merge!(ini['default'])
+
+      # Handle each of the pool sections
+      ini.each_section do |section|
+        vals = ini[section]
+        # Look for sections of the form Pool-<name>
+        if section.index("pool-") == 0
+	  name = section[5..-1].to_sym
+	  vals[:name] = name
+	  @pools << section_config(vals) if @opts.empty? || @opts.include?(name)
+	end
+      end
+    end
+
+    # Supply the section defaults, based on the aws config and the section name.
+    # If there is no name, then there are no defaults,
+    # TODO Most of these should be hanled by policy or its subclasses.
+    def section_defaults(name)
+      return nil unless name
+      { 
+        # generic
+        :ami_name => "#{@aws[:aws_user]}-ami-#{name}",
+        :security_groups => [name.to_s],
+	:key_pair_name => "#{@aws[:aws_user]}-kp",
+	# policy plugin
+        :work_queue_name => "#{name}-work",
+        :status_queue_name => "#{name}-status",
+        :manual_queue_name => "#{name}-manual",
+	# active_set plugin
+        :active_set_bucket => "#{@aws[:aws_bucket]}",
+        :active_set_key => "active-set/#{name}-instances",
+        :active_set_item => "active-set-#{name}-instances",
+        :active_set_queue_name => "#{name}-active-set",
+      }
+    end
+
+    # Perform configuration for a single section of the config file.
+    # If the conventions for image names, queues, and bucket
+    # is followed, then this is all the aws configuration needed.
+    # This associates a policy symbol with the instance.
+    def section_config(config)
+      section_defaults(config[:name]).merge(config)
+    end
+  end
+end

data/app/default-config.ini

@@ -0,0 +1,95 @@
+#
+# EC2 Instance Manager configuration default parameters
+
+
+[default]
+# defaults to name in section heading
+# in this case <name> is default because section is Pool-default
+name=nil
+# The logger to use
+logger=file
+logfile=STDOUT
+# must be supplied -- no default
+# job, resource, or default
+policy=nil
+# how often policy is evaluated
+policy_interval=60
+# status parser
+status_parser=std
+# how often queue is monitored
+poll_interval=5  
+# how many status and log messages received at once
+receive_count=10
+# work queue name
+# default name comes from heading: work-<name}
+work_queue_name=nil
+# status queue name
+# default name comes from heading: status-<name>
+status_queue_name=nil
+# store active-set updates in this S3 bucket
+# default comes from aws_bucket in AWS section above
+active_set_bucket=nil
+# the key to use for storing active-set entries in S3
+# the default is build from aws_user in AWS section: active-set/<name>-instances
+active_set_key=nil
+# if enabled, active set is written this often (minutes)
+active_set_interval=1
+# by default, active set is disabled
+active_set_type=none
+# the name of the image to start
+# default is build from AWS entries: <aws_user>-ami-<name>-<aws-env>
+ami_name=nil
+# the keypair to use
+# default is built from the aws_key in the AWS section: <keypair-name>
+key_pair_name=nil
+security_groups=[ ]
+instance_type="m1.small"
+# the user data sent to the instance when it starts
+# the default containes the aws_env, the aws_access_key and the
+# aws_secret_key
+# given in hash notation in quotes: "{:key1 => value1, :key2 => value2}"
+user_data={}
+# the time (in minutes) between checking instances
+audit_instance_interval=1
+# maximum number of instances allowed
+maximum_number_of_instances=2
+# minimum number of instances allowed
+minimum_number_of_instances=0
+# the maximum instances started in one policy interval
+start_limit=1
+# the minimum instance lifetime, in minutes
+minimum_lifetime=55
+# the minimum time a server stays active (in minutes)
+minimum_active_time=10
+# the maximum number of instances to stop in one policy interval
+stop_limit=1
+# if no status is received for this time (in minutes) then
+# the instance is considered dead can will be stopped
+watchdog_interval=10
+# in job policy, if work queue size is greater than 
+# start_threshold * number of
+start_threshold=2
+#in job policy, if more than idle_threshold active instances 
+# with load 0 exist, stop some of them
+idle_threshold=1
+# in resource policy, the limits that it tries
+# to keep servers within
+target_upper_load=0.75
+target_lower_load=0.25
+# in resource policy, divide the queue depth by this
+# factor to get the number of new servers needed
+queue_load_factor=2
+# in resource policy, the minimum load on  shutdown
+# server before it is stopped
+shut_down_threshold=0
+# how long to wait after shutdown before termination
+# in minutes
+shut_down_interval=60
+# how often to give summary (depth/instances/load)
+# default of 0 means give every poll_interval
+summary_interval=0
+# how often to vie instance reports
+instance_report_interval=60
+# if set, it is a patname to a directory where individual log files
+# are written for each instance
+instance_log=""

data/app/ec2_image_enumerator.rb

@@ -0,0 +1,41 @@
+require 'aws_context'
+
+module Cloudmaster
+
+  # Provides enumerators for EC2 images.
+  # The information is read once from EC2 and stored.
+  # It is then enumearted one image at a time.
+  # The stored list of images can also be searched 
+  # Get the EC2 images and store them.
+  # Allow lookup by matching on the name.
+  class EC2ImageEnumerator
+    include Enumerable
+
+    # Create the enumerator.  Fetch and store the complete image list.
+    def initialize
+      @images = AwsContext.instance.ec2.describe_images
+    end
+
+    # Enumerate each image
+    def each
+      @images.each { |image| yield image }
+    end
+
+    # Look for the image with the given name.
+    # Return the image id if exactly one is found, throw exception otherwise.
+    # Uses the set of images we fetched in the constructor and stored.
+    # The fetch is slow, so we don't want to repeat it.
+    def find_image_id_by_name(image_name)
+      filter = Regexp.new(image_name)
+      images = find_all {|i| i[:location] =~ /#{image_name}/}
+      case images.length
+      when 0
+        raise "Bad Configuration -- image #{image_name} not found"
+      when 1
+        images[0][:id]
+      else
+        raise "Bad configuration -- multiple images #{image_name}"
+      end
+    end
+  end
+end

data/app/ec2_instance_enumerator.rb

@@ -0,0 +1,25 @@
+require 'aws_context'
+
+module Cloudmaster
+
+  # Provides an enumerator for EC2 instances.
+  # Query for instances when object created.
+  # Handles all instances we own, or just ones maching a list of ids.
+  class EC2InstanceEnumerator
+    include Enumerable
+
+    # Get the list of instances from EC2
+    def initialize(*ids)
+      @instances =  AwsContext.instance.ec2.describe_instances(*ids)
+    end
+
+    # Enumerator each instance
+    def each
+      @instances.each do |group| 
+        group[:instances].each do |instance|
+          yield instance
+        end
+      end
+    end
+  end
+end

data/app/instance.rb

@@ -0,0 +1,146 @@
+module Cloudmaster
+
+  # Holds information about a specific instance.
+  # When we create an instance in EC2, we create one of these classes to hold
+  # information about the instance.  Instances are members of the InstancePool.
+  #
+  # Each instance holds the following information:
+  #  * id -- instance id
+  #  * public_dns -- the public dns name of the instance
+  #  * load_estimate -- last reported load -- between 0 and 1
+  #  * state -- startup, active, shut_down
+  #  * start_time -- (local) time when the instance was started
+  #  * last_status_time -- (local) time when the last status was received
+  #  * last_timestamp -- (remote) timestamp of last report
+  #
+  # The state here differs from the EC2 state.  We only track instances in
+  # EC@ state pending or running.  Our state is controlled by status messages
+  # received and by stop policies.
+  class Instance
+    attr_reader :id, :load_estimate, :state, :state_change_time
+    attr_accessor :public_dns
+    attr_accessor :load_estimate, :state   # for testing only
+    attr_reader :status_time, :timestamp   # for testing only
+    
+    # Create an instance object, reflecting some instance that was stated
+    # or discovered running.
+    # New instance objects know their instance id, their public DNS (once this is known) and their load estimate.
+     def initialize(id, public_dns, config)
+      @config = config
+      @id = id
+      @public_dns = public_dns
+      @load_estimate = 0
+      @start_time = @status_time = Clock.now
+      @active_time = Clock.at(0)
+      @state_change_time = Clock.now
+      @timestamp = Clock.at(0)
+      @state = :startup
+    end
+    
+    # Return a report of the instance's state, load estimate, and time 
+    # since the last status message was received.
+    def report
+      "State: #{@state} Load: #{sprintf("%.2f", @load_estimate)} Time Since Status: #{time_since_status.round}"
+    end
+
+    def update_state(state)
+      old_state, @state = @state, state
+      @state_change_time = Clock.now
+      if old_state != :active && @state == :active
+	@active_time = Clock.now
+      elsif @old_state == :active && @state != :active
+	@active_time = Clock.at(0)
+      end
+    end
+
+    # Update the state and estimated load based on status message
+    # Ignore the status message if it was sent earlier than
+    # one we have already processed.  This is important, because
+    # SQS routinely delivers messages out of order.
+    def update_status(msg)
+      if message_more_recent?(msg[:timestamp])
+        @timestamp = msg[:timestamp]
+        @status_time = Clock.now
+	update_state(msg[:state].to_sym) if msg[:state] 
+        @load_estimate = msg[:load_estimate] if msg[:load_estimate]
+      end
+    end
+
+#    private
+    
+    # Return true if the given timestamp is more recent than the last.
+    # This calculation takes place with times from the <b>sender's</b>
+    # clock.  In other words, it is comparing values based on two timestamps
+    # created by the message sender.
+    def message_more_recent?(timestamp)
+      ! timestamp.nil? && timestamp > @timestamp
+    end
+
+    # Return the number of seconds since the last message was received.
+    # This uses local time only.
+    def time_since_status
+      Clock.now - @status_time
+    end
+
+    # Return the number of seconds since the last status message with
+    # a state field in it.  This uses local times only.
+    def time_since_state_change
+      Clock.now - @state_change_time
+    end
+
+    # Return the number of seconds since the instance was started.
+    def time_since_startup
+      Clock.now - @start_time
+    end
+
+    # Return the number of seconds since the instance became active.
+    def time_since_active
+      Clock.now - @active_time
+    end
+
+    public
+
+    # Return true if the instance has lived at least as long
+    # as its minimum lifetime.
+    def minimum_lifetime_elapsed?
+    lifetime = @config[:minimum_lifetime].to_i * 60
+    return true if lifetime <= 0
+    time_since_startup > lifetime
+    end
+    
+    # Return true if the instance has been active at least as long
+    # as its minimum active time.
+    def minimum_active_time_elapsed?
+    active_time = @config[:minimum_active_time].to_i * 60
+    return true if active_time <= 0
+    time_since_active > active_time
+    end
+    
+    # Return true if the instance has lived and has been active for its
+    # respective minimum times.
+    def minimum_time_elapsed?
+      minimum_lifetime_elapsed? && minimum_active_time_elapsed?
+    end
+
+    # Return true if the instance has not received a status message
+    # in the watchdog interval.
+    def watchdog_time_elapsed?
+      interval = @config[:watchdog_interval].to_i * 60
+      return false if interval <= 0
+      time_since_status > interval
+    end
+
+    # Shut down an instance by putting it in the "shut_down" state.
+    # After this is can either be activated again or stopped.
+    def shutdown
+      update_state(:shut_down)
+    end
+
+    # Make the instance active.  This is usually done after the
+    # instance is shut down, but before it is stopped, it needs to
+    # become active again.
+    def activate
+      update_state(:active)
+    end
+  end
+end