ironfan 3.2.2 → 4.0.0

data/lib/ironfan/cluster.rb

@@ -1,118 +0,0 @@
-module Ironfan
-  #
-  # A cluster has many facets. Any setting applied here is merged with the facet
-  # at resolve time; if the facet explicitly sets any attributes they will win out.
-  #
-  class Cluster < Ironfan::ComputeBuilder
-    attr_reader :facets, :undefined_servers
-
-    def initialize(name, attrs={})
-      super(name.to_sym, attrs)
-      @facets            = Mash.new
-      @chef_roles        = []
-      environment          :_default if environment.blank?
-      create_cluster_role
-      create_cluster_security_group unless attrs[:no_security_group]
-    end
-
-    def cluster
-      self
-    end
-
-    def cluster_name
-      name
-    end
-
-    # The auto-generated role for this cluster.
-    # Instance-evals the given block in the context of that role
-    #
-    # @example
-    #   cluster_role do
-    #     override_attributes({
-    #       :time_machine => { :transition_speed => 88 },
-    #     })
-    #   end
-    #
-    # @return [Chef::Role] The auto-generated role for this facet.
-    def cluster_role(&block)
-      @cluster_role.instance_eval( &block ) if block_given?
-      @cluster_role
-    end
-
-    #
-    # Retrieve or define the given facet
-    #
-    # @param [String] facet_name -- name of the desired facet
-    # @param [Hash] attrs -- attributes to configure on the object
-    # @yield a block to execute in the context of the object
-    #
-    # @return [Ironfan::Facet]
-    #
-    def facet(facet_name, attrs={}, &block)
-      facet_name = facet_name.to_sym
-      @facets[facet_name] ||= Ironfan::Facet.new(self, facet_name)
-      @facets[facet_name].receive!(attrs, &block)
-      @facets[facet_name]
-    end
-
-    def has_facet? facet_name
-      @facets.include?(facet_name)
-    end
-
-    def find_facet(facet_name)
-      @facets[facet_name] or raise("Facet '#{facet_name}' is not defined in cluster '#{cluster_name}'")
-    end
-
-    # All servers in this facet, sorted by facet name and index
-    #
-    # @return [Ironfan::ServerSlice] slice containing all servers
-    def servers
-      svrs = @facets.sort.map{|name, facet| facet.servers.to_a }
-      Ironfan::ServerSlice.new(self, svrs.flatten)
-    end
-
-    #
-    # A slice of a cluster:
-    #
-    # If +facet_name+ is nil, returns all servers.
-    # Otherwise, takes slice (given by +*args+) from the requested facet.
-    #
-    # @param [String] facet_name -- facet to slice (or nil for all in cluster)
-    # @param [Array, String] slice_indexes -- servers in that facet (or nil for all in facet).
-    #   You must specify a facet if you use slice_indexes.
-    #
-    # @return [Ironfan::ServerSlice] the requested slice
-    def slice facet_name=nil, slice_indexes=nil
-      return servers if facet_name.nil?
-      find_facet(facet_name).slice(slice_indexes)
-    end
-
-    def to_s
-      "#{super[0..-3]} @facets=>#{@facets.keys.inspect}}>"
-    end
-
-    #
-    # Resolve:
-    #
-    def resolve!
-      facets.values.each(&:resolve!)
-    end
-
-  protected
-
-    # Create a security group named for the cluster
-    # that is friends with everything in the cluster
-    def create_cluster_security_group
-      clname = self.name.to_s # put it in scope
-      cloud.security_group(clname){ authorize_group(clname) }
-    end
-
-    # Creates a chef role named for the cluster
-    def create_cluster_role
-      @cluster_role_name = "#{name}_cluster"
-      @cluster_role      = new_chef_role(@cluster_role_name, cluster)
-      role(@cluster_role_name, :own)
-    end
-
-  end
-end

data/lib/ironfan/compute.rb

@@ -1,139 +0,0 @@
-require 'ironfan/volume'            # configure external and internal volumes
-module Ironfan
-  #
-  # Base class allowing us to layer settings for facet over cluster
-  #
-  class ComputeBuilder < Ironfan::DslBuilder
-    magic :name, String
-    magic :bogosity, String, :default => false
-    magic :environment, String
-    collection :volumes, Ironfan::Volume, :resolution => ->(f) { merge_resolve(f) }
-
-    attr_reader :cloud, :chef_roles
-    @@role_implications ||= Mash.new
-    @@run_list_rank     ||= 0
-
-    def initialize(builder_name, attrs={})
-      super(attrs)
-      name      builder_name
-      @run_list_info = attrs[:run_list] || Mash.new
-      @clouds  = Mash.new
-    end
-
-    # set the bogosity to a descriptive reason. Anything truthy implies bogusness
-    def bogus?
-      !! self.bogosity
-    end
-
-    # Magic method to produce cloud instance:
-    # * returns the cloud instance, creating it if necessary.
-    # * executes the block in the cloud's object context
-    #
-    # @example
-    #   cloud do
-    #     image_name     'maverick'
-    #     security_group :nagios
-    #   end
-    #
-    #   # defines ec2-specific behavior
-    #   cloud(:ec2) do
-    #     public_ip      '1.2.3.4'
-    #     region         'us-east-1d'
-    #   end
-    #
-    def cloud(cloud_provider=:ec2, attrs={}, &block)
-      case cloud_provider
-      when :ec2
-        klass = Ironfan::CloudDsl::Ec2
-      when :virtualbox
-        klass = Ironfan::CloudDsl::VirtualBox
-      else
-        raise "Only have EC2 and VirtualBox so far"
-      end
-      @clouds[cloud_provider] ||= klass.new(self)
-      @clouds[cloud_provider].receive!(attrs, &block)
-      @clouds[cloud_provider]
-    end
-
-    # sugar for cloud(:ec2)
-    def ec2(attrs={}, &block)
-      cloud(:ec2, attrs, &block)
-    end
-
-    def raid_group(rg_name, attrs={}, &block)
-      raid = volumes[rg_name] || Ironfan::RaidGroup.new(:parent => self, :name => rg_name)
-      raid.receive!(attrs, &block)
-      raid.sub_volumes.each do |sv_name|
-        volume(sv_name){ in_raid(rg_name) ; mountable(false) ; tags({}) }
-      end
-      volumes[rg_name] = raid
-    end
-
-    #
-    # Adds the given role to the run list, and invokes any role_implications it
-    # implies (for instance, defining and applying the 'ssh' security group if
-    # the 'ssh' role is applied.)
-    #
-    # You can specify placement of `:first`, `:normal` (or nil) or `:last`; the
-    # final runlist is assembled as
-    #
-    # * run_list :first  items -- cluster, then facet, then server
-    # * run_list :normal items -- cluster, then facet, then server
-    # * run_list :last   items -- cluster, then facet, then server
-    #
-    # (see Ironfan::Server#combined_run_list for full details though)
-    #
-    def role(role_name, placement=nil)
-      add_to_run_list("role[#{role_name}]", placement)
-      self.instance_eval(&@@role_implications[role_name]) if @@role_implications[role_name]
-    end
-
-    # Add the given recipe to the run list. You can specify placement of
-    # `:first`, `:normal` (or nil) or `:last`; the final runlist is assembled as
-    #
-    # * run_list :first  items -- cluster, then facet, then server
-    # * run_list :normal items -- cluster, then facet, then server
-    # * run_list :last   items -- cluster, then facet, then server
-    #
-    # (see Ironfan::Server#combined_run_list for full details though)
-    #
-    def recipe(name, placement=nil)
-      add_to_run_list(name, placement)
-    end
-
-    # Roles and recipes for this element only.
-    #
-    # See Ironfan::Server#combined_run_list for run_list order resolution
-    def run_list
-      groups = run_list_groups
-      [ groups[:first], groups[:normal], groups[:last] ].flatten.compact.uniq
-    end
-
-    # run list elements grouped into :first, :normal and :last
-    def run_list_groups
-      @run_list_info.keys.sort_by{|item| @run_list_info[item][:rank] }.group_by{|item| @run_list_info[item][:placement] }
-    end
-
-    #
-    # Some roles imply aspects of the machine that have to exist at creation.
-    # For instance, on an ec2 machine you may wish the 'ssh' role to imply a
-    # security group explicity opening port 22.
-    #
-    # @param [String] role_name -- the role that triggers the block
-    # @yield block will be instance_eval'd in the object that calls 'role'
-    #
-    def self.role_implication(name, &block)
-      @@role_implications[name] = block
-    end
-
-  protected
-
-    def add_to_run_list(item, placement)
-      raise "run_list placement must be one of :first, :normal, :last or nil (also means :normal)" unless [:first, :last, :own, nil].include?(placement)
-      @@run_list_rank += 1
-      placement ||= :normal
-      @run_list_info[item] ||= { :rank => @@run_list_rank, :placement => placement }
-    end
-
-  end
-end

data/lib/ironfan/discovery.rb

@@ -1,190 +0,0 @@
-module Ironfan
-  class Cluster
-
-    def discover!
-      @aws_instance_hash = {}
-      discover_ironfan!
-      discover_chef_nodes!
-      discover_fog_servers!  unless Ironfan.chef_config[:cloud] == false
-      discover_chef_clients!
-      discover_volumes!
-    end
-
-    def chef_clients
-      return @chef_clients if @chef_clients
-      @chef_clients = []
-
-      # Oh for fuck's sake -- the key used to index clients changed from
-      # 'clientname' in 0.10.4-and-prev to 'name' in 0.10.8. Rather than index
-      # both 'clientname' and 'name', they switched it -- so we have to fall
-      # back.  FIXME: While the Opscode platform is 0.10.4 I have clientname
-      # first (sorry, people of the future). When it switches to 0.10.8 we'll
-      # reverse them (suck it people of the past).
-      # Also sometimes the server returns results that are nil on
-      # recently-expired clients, so that's annoying too.
-      clients, wtf, num = Chef::Search::Query.new.search(:client, "clientname:#{cluster_name}-*") ; clients.compact!
-      clients, wtf, num = Chef::Search::Query.new.search(:client, "name:#{cluster_name}-*") if clients.blank?
-      clients.each do |client_hsh|
-        next if client_hsh.nil?
-        # Return values from Chef::Search seem to be inconsistent across chef
-        # versions (sometimes a hash, sometimes an object). Fix if necessary.
-        client_hsh = Chef::ApiClient.json_create(client_hsh) unless client_hsh.is_a?(Chef::ApiClient)
-        @chef_clients.push( client_hsh )
-      end
-      @chef_clients
-    end
-
-    # returns client with the given name if in catalog, nil otherwise
-    def find_client(cl_name)
-      chef_clients.find{|ccl| ccl.name == cl_name }
-    end
-
-    def chef_nodes
-      return @chef_nodes if @chef_nodes
-      @chef_nodes = []
-      Chef::Search::Query.new.search(:node,"cluster_name:#{cluster_name}") do |n|
-        @chef_nodes.push(n) unless n.blank? || (n.cluster_name != cluster_name.to_s)
-      end
-      @chef_nodes
-    end
-
-    # returns node with the given name if in catalog, nil otherwise
-    def find_node(nd_name)
-      chef_nodes.find{|nd| nd.name == nd_name }
-    end
-
-  protected
-
-    def fog_servers
-      @fog_servers ||= Ironfan.fog_servers.select{|fs| fs.key_name == cluster_name.to_s && (fs.state != "terminated") }
-    end
-
-    # Walk the list of chef nodes and
-    # * vivify the server,
-    # * associate the chef node
-    # * if the chef node knows about its instance id, memorize that for lookup
-    #   when we discover cloud instances.
-    def discover_chef_nodes!
-      chef_nodes.each do |chef_node|
-        if chef_node["cluster_name"] && chef_node["facet_name"] && chef_node["facet_index"]
-          cluster_name = chef_node["cluster_name"]
-          facet_name   = chef_node["facet_name"]
-          facet_index  = chef_node["facet_index"]
-        elsif chef_node.name
-          ( cluster_name, facet_name, facet_index ) = chef_node.name.split(/-/)
-        else
-          next
-        end
-        svr = Ironfan::Server.get(cluster_name, facet_name, facet_index)
-        svr.chef_node   chef_node
-        @aws_instance_hash[ chef_node.ec2.instance_id ] = svr if chef_node[:ec2] && chef_node.ec2.instance_id
-      end
-    end
-
-    # Walk the list of servers, asking each to discover its chef client.
-    def discover_chef_clients!
-      servers.each(&:chef_client)
-    end
-
-    # calling #servers vivifies each facet's Ironfan::Server instances
-    def discover_ironfan!
-      self.servers
-    end
-
-    def discover_fog_servers!
-      # If the fog server is tagged with cluster/facet/index, then try to
-      # locate the corresponding machine in the cluster def
-      # Otherwise, try to get to it through mapping the aws instance id
-      # to the chef node name found in the chef node
-      fog_servers.each do |fs|
-        if fs.tags["cluster"] && fs.tags["facet"] && fs.tags["index"] && fs.tags["cluster"] == cluster_name.to_s
-          svr = Ironfan::Server.get(fs.tags["cluster"], fs.tags["facet"], fs.tags["index"])
-        elsif @aws_instance_hash[fs.id]
-          svr = @aws_instance_hash[fs.id]
-        else
-          next
-        end
-
-        # If there already is a fog server there, then issue a warning and slap
-        # the just-discovered one onto a server with an arbitrary index, and
-        # mark both bogus
-        if existing_fs = svr.fog_server
-          if existing_fs.id != fs.id
-            ui.warn "Duplicate fog instance found for #{svr.fullname}: #{fs.id} and #{existing_fs.id}!!"
-            old_svr = svr
-            svr     = old_svr.facet.server(1_000 + svr.facet_index.to_i)
-            old_svr.bogosity :duplicate
-            svr.bogosity     :duplicate
-          end
-        end
-        svr.fog_server = fs
-      end
-    end
-
-    def discover_volumes!
-      servers.each(&:discover_volumes!)
-    end
-
-    def discover_addresses!
-      servers.each(&:discover_addresses!)
-    end
-
-  end # Ironfan::Cluster
-end
-
-module Ironfan
-
-  def self.fog_connection
-    @fog_connection ||= Fog::Compute.new({
-        :provider              => 'AWS',
-        :aws_access_key_id     => Chef::Config[:knife][:aws_access_key_id],
-        :aws_secret_access_key => Chef::Config[:knife][:aws_secret_access_key],
-        :region                => Chef::Config[:knife][:region]
-      })
-  end
-
-  def self.fog_servers
-    return @fog_servers if @fog_servers
-    Chef::Log.debug("Using fog to catalog all servers")
-    @fog_servers = Ironfan.fog_connection.servers.all
-  end
-
-  def self.fog_addresses
-    return @fog_addresses if @fog_addresses
-    Chef::Log.debug("Using fog to catalog all addresses")
-    @fog_addresses = {}.tap{|hsh| Ironfan.fog_connection.addresses.each{|fa| hsh[fa.public_ip] = fa } }
-  end
-
-  def self.fog_volumes
-    @fog_volumes || fetch_fog_volumes
-  end
-
-  def self.fetch_fog_volumes
-    Chef::Log.debug("Using fog to catalog all volumes")
-    @fog_volumes = Ironfan.fog_connection.volumes
-  end
-
-  def self.fog_keypairs
-    return @fog_keypairs if @fog_keypairs
-    Chef::Log.debug("Using fog to catalog all keypairs")
-    @fog_keypairs = {}.tap{|hsh| Ironfan.fog_connection.key_pairs.each{|kp| hsh[kp.name] = kp } }
-  end
-
-  def self.dry_run?
-    Ironfan.chef_config[:dry_run]
-  end
-
-  def self.placement_groups
-    return @placement_groups if @placement_groups
-    Chef::Log.debug("Using fog to catalog all placement_groups")
-    resp = self.fog_connection.describe_placement_groups unless dry_run?
-    return {} unless resp.respond_to?(:body) && resp.body.present?
-    arr = resp.body['placementGroupSet']
-    @placement_groups = arr.inject({}){|acc, pg| acc[pg['groupName']] = pg ; acc }
-  end
-
-  def safely *args, &block
-    Ironfan.safely(*args, &block)
-  end
-
-end

data/lib/ironfan/dsl_builder.rb

@@ -1,99 +0,0 @@
-module Gorillib
-  module Model
-    Field.class_eval do
-      field :resolution, Whatever
-    end
-  end
-  module Underlies
-    include Gorillib::FancyBuilder
-    attr_accessor :underlay
-
-    def read_attribute(field_name)
-      field = self.class.fields[field_name] or return
-      return override_resolve(field_name) unless field.resolution.is_a? Proc
-      return self.instance_exec(field_name, &field.resolution)
-    end
-
-    def override_resolve(field_name)
-      result = read_set_or_underlay(field_name)
-      return result unless result.nil?
-      read_unset_attribute(field_name)
-    end
-
-    def merge_resolve(field_name)
-      attr = {}
-      if self.class.fields[field_name].respond_to? :item_type
-        attr[:item_type] = self.class.fields[field_name].item_type
-      end
-      result = self.class.fields[field_name].type.new(attr)
-      result.receive! read_underlay_attribute(field_name) || {}
-      result.receive! read_set_attribute(field_name) || {}
-      return result unless result.empty?
-      read_unset_attribute(field_name)
-    end
-
-    def read_set_attribute(field_name)
-      attr_name = "@#{field_name}"
-      instance_variable_get(attr_name) if instance_variable_defined?(attr_name)
-    end
-
-    def read_underlay_attribute(field_name)
-      return if @underlay.nil?
-      underlay.read_set_or_underlay(field_name)
-    end
-    
-    def read_set_or_underlay(field_name)
-      result = read_set_attribute(field_name)
-      return result unless result.nil?
-      read_underlay_attribute(field_name)
-    end
-
-  end
-end
-
-module Ironfan
-  #
-  # This class is intended as a drop-in replacement for DslObject, using 
-  #   Gorillib::Builder setup, instead its half-baked predecessor.
-  #
-  # The magic attribute :underlay provides an object (preferably another
-  #   Gorillib::Model or the like) that will respond with defaults. If 
-  #   fields are declared with a resolution lambda, it will apply that 
-  #   lambda in preference to the normal resolution rules (self.field
-  #   -> underlay.magic -> self.field.default )
-  #
-  module DslHooks
-    def self.ui() Ironfan.ui ; end
-    def ui()      Ironfan.ui ; end
-
-    # helper method for turning exceptions into warnings
-    def safely(*args, &block) Ironfan.safely(*args, &block) ; end
-
-    def step(desc, *style)
-      ui.info("  #{"%-15s" % (name.to_s+":")}\t#{ui.color(desc.to_s, *style)}")
-    end
-  end
-
-  class DslBuilder
-    include Gorillib::FancyBuilder
-    include Gorillib::Underlies
-    include Ironfan::DslHooks
-  end
-
-  class DslBuilderCollection < Gorillib::ModelCollection
-    include Ironfan::DslHooks
-    include Enumerable
-#     #
-#     # Enumerable
-#     #
-#     def each(&block)
-#       @servers.each(&block)
-#     end
-#     def length
-#       @servers.length
-#     end
-#     def empty?
-#       length == 0
-#     end
-  end
-end

data/lib/ironfan/facet.rb

@@ -1,143 +0,0 @@
-module Ironfan
-  class Facet < Ironfan::ComputeBuilder
-    attr_reader :cluster
-    magic :instances, Integer, :default => 1
-
-    def initialize cluster, facet_name, attrs={}
-      super(facet_name.to_sym, attrs)
-      @cluster    = cluster
-      @servers    = Mash.new
-      @chef_roles = []
-      create_facet_role
-      create_facet_security_group unless attrs[:no_security_group]
-    end
-
-    def cluster_name
-      cluster.name
-    end
-
-    def facet_name
-      name
-    end
-
-    # The auto-generated role for this facet.
-    # Instance-evals the given block in the context of that role,
-    #
-    # @example
-    #   facet_role do
-    #     override_attributes({
-    #       :time_machine => { :transition_speed => 88 },
-    #     })
-    #   end
-    #
-    # @return [Chef::Role] The auto-generated role for this facet.
-    def facet_role(&block)
-      @facet_role.instance_eval( &block ) if block_given?
-      @facet_role
-    end
-
-    def assign_volume_ids(volume_name, *volume_ids)
-      volume_ids.flatten.zip(servers).each do |volume_id, server|
-        server.volume(volume_name){ volume_id(volume_id) } if server
-      end
-    end
-
-    #
-    # Retrieve or define the given server
-    #
-    # @param [Integer] idx  -- the index of the desired server
-    # @param [Hash] attrs -- attributes to configure on the object
-    # @yield a block to execute in the context of the object
-    #
-    # @return [Ironfan::Facet]
-    #
-    def server(idx, attrs={}, &block)
-      idx = idx.to_i
-      @servers[idx] ||= Ironfan::Server.new(self, idx)
-      @servers[idx].receive!(attrs, &block)
-      @servers[idx]
-    end
-
-    # if the server has been added to this facet or is in range
-    def has_server? idx
-      (idx.to_i < instances) || @servers.include?(idx.to_i)
-    end
-
-    #
-    # Slicing
-    #
-
-    # All servers in this facet
-    #
-    # @return [Ironfan::ServerSlice] slice containing all servers
-    def servers
-      slice(indexes)
-    end
-
-    #
-    # A slice of servers from this facet, in index order
-    #
-    # If +slice_indexes+ is nil, returns all servers.
-    # Otherwise, takes slice (given by +*args+) from the requested facet.
-    #
-    # @param [Array, String] slice_indexes -- servers in that facet (or nil for all in facet).
-    #
-    # @return [Ironfan::ServerSlice] the requested slice
-    def slice(slice_indexes=nil)
-      slice_indexes = self.indexes if slice_indexes.blank?
-      slice_indexes = indexes_from_intervals(slice_indexes) if slice_indexes.is_a?(String)
-      svrs = Array(slice_indexes).map(&:to_i).sort!.select{|idx| has_server?(idx) }.map{|idx| server(idx) }
-      Ironfan::ServerSlice.new(self.cluster, svrs)
-    end
-
-    # all valid server indexes
-    def valid_indexes
-      (0 ... instances).to_a # note the '...'
-    end
-
-    # indexes in the 0...instances range plus bogus ones that showed up
-    # (probably from chef or fog)
-    def indexes
-      [@servers.keys, valid_indexes].flatten.compact.uniq.sort
-    end
-
-    #
-    # Resolve:
-    #
-    def resolve!
-      servers.each(&:resolve!)
-    end
-
-  protected
-
-    def create_facet_security_group
-      cloud.security_group("#{cluster_name}-#{facet_name}")
-    end
-
-    # Creates a chef role named for the facet
-    def create_facet_role
-      @facet_role_name = "#{cluster_name}_#{facet_name}"
-      @facet_role      = new_chef_role(@facet_role_name, cluster, self)
-      role(@facet_role_name, :own)
-    end
-
-    #
-    # Given a string enumerating indexes to select returns a flat array of
-    # indexes. The indexes will be unique but in an arbitrary order.
-    #
-    # @example
-    #   facet = Ironfan::Facet.new('foo', 'bar')
-    #   facet.indexes_from_intervals('1,2-3,8-9,7') # [1, 2, 3, 8, 9, 7]
-    #   facet.indexes_from_intervals('1,3-5,4,7')   # [1, 3, 4, 5, 7]
-    #
-    def indexes_from_intervals intervals
-      intervals.split(",").map do |term|
-        if    term =~ /^(\d+)-(\d+)$/ then ($1.to_i .. $2.to_i).to_a
-        elsif term =~ /^(\d+)$/       then  $1.to_i
-        else  ui.warn("Bad interval: #{term}") ; nil
-        end
-      end.flatten.compact.uniq
-    end
-
-  end
-end