ironfan 3.1.7 → 3.2.2

data/lib/ironfan/cluster.rb

@@ -51,7 +51,7 @@ module Ironfan
     def facet(facet_name, attrs={}, &block)
       facet_name = facet_name.to_sym
       @facets[facet_name] ||= Ironfan::Facet.new(self, facet_name)
-      @facets[facet_name].configure(attrs, &block)
+      @facets[facet_name].receive!(attrs, &block)
       @facets[facet_name]
     end
 
@@ -83,7 +83,7 @@ module Ironfan
     #
     # @return [Ironfan::ServerSlice] the requested slice
     def slice facet_name=nil, slice_indexes=nil
-      return Ironfan::ServerSlice.new(self, self.servers) if facet_name.nil?
+      return servers if facet_name.nil?
       find_facet(facet_name).slice(slice_indexes)
     end
 
@@ -103,7 +103,7 @@ module Ironfan
     # Create a security group named for the cluster
     # that is friends with everything in the cluster
     def create_cluster_security_group
-      clname = self.name # put it in scope
+      clname = self.name.to_s # put it in scope
       cloud.security_group(clname){ authorize_group(clname) }
     end
 

data/lib/ironfan/compute.rb

@@ -1,18 +1,23 @@
+require 'ironfan/volume'            # configure external and internal volumes
 module Ironfan
   #
   # Base class allowing us to layer settings for facet over cluster
   #
-  class ComputeBuilder < Ironfan::DslObject
-    attr_reader :cloud, :volumes, :chef_roles
-    has_keys :name, :bogosity, :environment
+  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)
-      set :name, builder_name
+      name      builder_name
       @run_list_info = attrs[:run_list] || Mash.new
-      @volumes = Mash.new
+      @clouds  = Mash.new
     end
 
     # set the bogosity to a descriptive reason. Anything truthy implies bogusness
@@ -36,11 +41,18 @@ module Ironfan
     #     region         'us-east-1d'
     #   end
     #
-    def cloud(cloud_provider=nil, attrs={}, &block)
-      raise "Only have ec2 so far" if cloud_provider && (cloud_provider != :ec2)
-      @cloud ||= Ironfan::Cloud::Ec2.new(self)
-      @cloud.configure(attrs, &block)
-      @cloud
+    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)
@@ -48,39 +60,13 @@ module Ironfan
       cloud(:ec2, attrs, &block)
     end
 
-    # Magic method to describe a volume
-    # * returns the named volume, creating it if necessary.
-    # * executes the block (if any) in the volume's context
-    #
-    # @example
-    #   # a 1 GB volume at '/data' from the given snapshot
-    #   volume(:data) do
-    #     size        1
-    #     mount_point '/data'
-    #     snapshot_id 'snap-12345'
-    #   end
-    #
-    # @param volume_name [String] an arbitrary handle -- you can use the device
-    #   name, or a descriptive symbol.
-    # @param attrs [Hash] a hash of attributes to pass down.
-    #
-    def volume(volume_name, attrs={}, &block)
-      volumes[volume_name] ||= Ironfan::Volume.new(:parent => self, :name => volume_name)
-      volumes[volume_name].configure(attrs, &block)
-      volumes[volume_name]
-    end
-
     def raid_group(rg_name, attrs={}, &block)
-      volumes[rg_name] ||= Ironfan::RaidGroup.new(:parent => self, :name => rg_name)
-      volumes[rg_name].configure(attrs, &block)
-      volumes[rg_name].sub_volumes.each do |sv_name|
+      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]
-    end
-
-    def root_volume(attrs={}, &block)
-      volume(:root, attrs, &block)
+      volumes[rg_name] = raid
     end
 
     #

data/lib/ironfan/deprecated.rb

@@ -1,33 +1,68 @@
 module Ironfan
+  def self.deprecated call, replacement=nil
+    correction = ", use #{replacement} instead" if replacement
+    ui.warn "The '#{call}' statement is deprecated #{caller(2).first.inspect}#{correction}"
+  end
+
+  class DslBuilder    
+    def to_hash
+      Ironfan.deprecated 'to_hash', 'attributes'
+      attributes
+    end
+    def to_mash
+      Ironfan.deprecated 'to_mash', 'attributes'
+      attributes
+    end
+    def reverse_merge!(attrs={})
+      Ironfan.deprecated 'reverse_merge!', 'receive!'
+      receive!(attrs)
+    end
+    def configure(attrs={},&block)
+      Ironfan.deprecated 'configure', 'receive!'
+      receive!(attrs, &block)
+    end
+  end
+
+  class ComputeBuilder
+    def root_volume(attrs={}, &block)
+      Ironfan.deprecated 'root_volume', 'volume(:root)'
+      volume(:root, attrs, &block)
+    end
+  end
 
   class Cluster
-    #
-    # **DEPRECATED**: This doesn't really work -- use +reverse_merge!+ instead
-    #
     def use(*clusters)
-      ui.warn "The 'use' statement is deprecated #{caller.inspect}"
+      Ironfan.deprecated 'use', 'underlay'
       clusters.each do |c|
         other_cluster =  Ironfan.load_cluster(c)
-        reverse_merge! other_cluster
+        cluster.underlay        other_cluster
       end
       self
     end
-
   end
 
   class Server
-    # **DEPRECATED**: Please use +fullname+ instead.
     def chef_node_name name
-      ui.warn "[DEPRECATION] `chef_node_name` is deprecated.  Please use `fullname` instead."
+      Ironfan.deprecated 'chef_node_name', 'fullname'
       fullname name
     end
+
+    def composite_volumes
+      Ironfan.deprecated 'composite_volumes', 'volumes'
+      volumes
+    end
   end
 
-  class Cloud::Ec2
-    # **DEPRECATED**: Please use +public_ip+ instead.
+  class CloudDsl::Ec2
     def elastic_ip(*args, &block)
+      Ironfan.deprecated 'elastic_ip', 'public_ip'
       public_ip(*args, &block)
     end
   end
 
+  class Volume
+    def defaults
+      Ironfan.deprecated 'defaults'
+    end
+  end
 end

data/lib/ironfan/discovery.rb

@@ -76,7 +76,7 @@ module Ironfan
           next
         end
         svr = Ironfan::Server.get(cluster_name, facet_name, facet_index)
-        svr.chef_node = chef_node
+        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

data/lib/ironfan/dsl_builder.rb

@@ -0,0 +1,99 @@
+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,14 +1,13 @@
 module Ironfan
   class Facet < Ironfan::ComputeBuilder
     attr_reader :cluster
-    has_keys  :instances
+    magic :instances, Integer, :default => 1
 
     def initialize cluster, facet_name, attrs={}
       super(facet_name.to_sym, attrs)
       @cluster    = cluster
       @servers    = Mash.new
       @chef_roles = []
-      @settings[:instances] ||= 1
       create_facet_role
       create_facet_security_group unless attrs[:no_security_group]
     end
@@ -55,7 +54,7 @@ module Ironfan
     def server(idx, attrs={}, &block)
       idx = idx.to_i
       @servers[idx] ||= Ironfan::Server.new(self, idx)
-      @servers[idx].configure(attrs, &block)
+      @servers[idx].receive!(attrs, &block)
       @servers[idx]
     end
 

data/lib/ironfan/fog_layer.rb

@@ -33,6 +33,7 @@ module Ironfan
         :key_name             => cloud.keypair.to_s,
         # Fog does not actually create tags when it creates a server.
         :tags                 => {
+          :name               => self.fullname,
           :cluster            => cluster_name,
           :facet              => facet_name,
           :index              => facet_index, },
@@ -72,11 +73,12 @@ module Ironfan
     end
 
     def discover_volumes!
-      composite_volumes.each do |vol_name, vol|
-        my_vol = volumes[vol_name]
-        next if my_vol.fog_volume
+      result = self.class.fields[:volumes].type.new
+      volumes.each_pair do |vol_name, definition|
+        next if definition.fog_volume
         next if Ironfan.chef_config[:cloud] == false
-        my_vol.fog_volume = Ironfan.fog_volumes.find do |fv|
+        vol = definition.dup
+        vol.fog_volume = Ironfan.fog_volumes.find do |fv|
           ( # matches the explicit volume id
             (vol.volume_id && (fv.id == vol.volume_id)    ) ||
             # OR this server's machine exists, and this volume is attached to
@@ -90,19 +92,21 @@ module Ironfan
               (fv.tags['device'] == vol.device.to_s) )
             )
         end
-        next unless my_vol.fog_volume
-        my_vol.volume_id(my_vol.fog_volume.id)                        unless my_vol.volume_id.present?
-        my_vol.availability_zone(my_vol.fog_volume.availability_zone) unless my_vol.availability_zone.present?
-        check_server_id_pairing(my_vol.fog_volume, my_vol.desc)
+        next unless vol.fog_volume
+        vol.volume_id(vol.fog_volume.id)                        unless vol.volume_id.present?
+        vol.availability_zone(vol.fog_volume.availability_zone) unless vol.availability_zone.present?
+        check_server_id_pairing(vol.fog_volume, vol.desc)
+        result[vol.name] = vol
       end
+      write_attribute(:volumes,result)
     end
 
     def attach_volumes
       return unless in_cloud?
       discover_volumes!
-      return if composite_volumes.empty?
+      return if volumes.empty?
       step("  attaching volumes")
-      composite_volumes.each do |vol_name, vol|
+      volumes.each_pair do |vol_name, vol|
         next if vol.volume_id.blank? || (vol.attachable != :ebs)
         if (not vol.in_cloud?) then  Chef::Log.debug("Volume not found: #{vol.desc}") ; next ; end
         if (vol.has_server?)   then check_server_id_pairing(vol.fog_volume, vol.desc) ; next ; end

data/lib/ironfan/private_key.rb

@@ -5,7 +5,7 @@ module Ironfan
   # A private key -- chef client key, ssh key, etc.
   #
   # The key is a pro
-  class PrivateKey < Ironfan::DslObject
+  class PrivateKey < Ironfan::DslBuilder
     attr_reader   :name
     attr_reader   :proxy
     attr_reader   :on_update

data/lib/ironfan/security_group.rb

@@ -1,20 +1,22 @@
 module Ironfan
-  module Cloud
+  module CloudDsl
+    class SecurityGroup < Ironfan::DslBuilder
+      magic :name, String
+      magic :description, String
+      magic :group_authorizations, Array
+      magic :group_authorized_by, Array
+      magic :range_authorizations, Array
 
-    class SecurityGroup < DslObject
-      has_keys :name, :description, :owner_id
-      attr_reader :group_authorizations
-      attr_reader :range_authorizations
+      def initialize params
+        name                    params[:name].to_s
+        description             "ironfan generated group #{name}"
+        group_authorizations    []
+        group_authorized_by     []
+        range_authorizations    []
+      end
 
-      def initialize cloud, group_name, group_description=nil, group_owner_id=nil
-        super()
-        set :name, group_name.to_s
-        description group_description || "ironfan generated group #{group_name}"
-        @cloud         = cloud
-        @group_authorizations = []
-        @group_authorized_by  = []
-        @range_authorizations = []
-        owner_id(group_owner_id || Chef::Config[:knife][:aws_account_id])
+      def to_key
+        name
       end
 
       @@all = nil
@@ -52,34 +54,34 @@ module Ironfan
       end
 
       def authorize_group(group_name, owner_id=nil)
-        @group_authorizations << [group_name.to_s, owner_id]
+        group_authorizations << [group_name.to_s, owner_id]
       end
 
       def authorized_by_group(other_name)
-        @group_authorized_by << other_name.to_s
+        group_authorized_by << other_name.to_s
       end
 
       def authorize_port_range(range, cidr_ip = '0.0.0.0/0', ip_protocol = 'tcp')
         range = (range .. range) if range.is_a?(Integer)
-        @range_authorizations << [range, cidr_ip, ip_protocol]
-      end
-
-      def group_permission_already_set?(fog_group, other_name, authed_owner)
-        return false if fog_group.ip_permissions.nil?
-        fog_group.ip_permissions.any? do |existing_permission|
-          existing_permission["groups"].include?({"userId" => authed_owner, "groupName" => other_name}) &&
-            existing_permission["fromPort"] == 1 &&
-            existing_permission["toPort"]   == 65535
-        end
+        range_authorizations << [range, cidr_ip, ip_protocol]
       end
-
-      def range_permission_already_set?(fog_group, range, cidr_ip, ip_protocol)
-        return false if fog_group.ip_permissions.nil?
-        fog_group.ip_permissions.include?(
-          { "groups"=>[], "ipRanges"=>[{"cidrIp"=>cidr_ip}],
-            "ipProtocol"=>ip_protocol, "fromPort"=>range.first, "toPort"=>range.last})
-      end
-
+# 
+#       def group_permission_already_set?(fog_group, other_name, authed_owner)
+#         return false if fog_group.ip_permissions.nil?
+#         fog_group.ip_permissions.any? do |existing_permission|
+#           existing_permission["groups"].include?({"userId" => authed_owner, "groupName" => other_name}) &&
+#             existing_permission["fromPort"] == 1 &&
+#             existing_permission["toPort"]   == 65535
+#         end
+#       end
+# 
+#       def range_permission_already_set?(fog_group, range, cidr_ip, ip_protocol)
+#         return false if fog_group.ip_permissions.nil?
+#         fog_group.ip_permissions.include?(
+#           { "groups"=>[], "ipRanges"=>[{"cidrIp"=>cidr_ip}],
+#             "ipProtocol"=>ip_protocol, "fromPort"=>range.first, "toPort"=>range.last})
+#       end
+# 
       # FIXME: so if you're saying to yourself, "self, this is some soupy gooey
       # code right here" then you and your self are correct. Much of this is to
       # work around old limitations in the EC2 api. You can now treat range and
@@ -110,22 +112,22 @@ module Ironfan
           rescue StandardError => err ; handle_security_group_error(err) ; end
         end
       end
-
-      def handle_security_group_error(err)
-        if (/has already been authorized/ =~ err.to_s)
-          Chef::Log.debug err
-        else
-          ui.warn(err)
-        end
-      end
-
+# 
+#       def handle_security_group_error(err)
+#         if (/has already been authorized/ =~ err.to_s)
+#           Chef::Log.debug err
+#         else
+#           ui.warn(err)
+#         end
+#       end
+# 
       def self.step(group_name, desc, *style)
         ui.info("  group #{"%-15s" % (group_name+":")}\t#{ui.color(desc.to_s, *style)}")
       end
       def step(desc, *style)
         self.class.step(self.name, desc, *style)
       end
-
     end
+
   end
 end

data/lib/ironfan/server.rb

@@ -7,15 +7,20 @@ module Ironfan
   # or if it exists in the real world (as revealed by Fog)
   #
   class Server < Ironfan::ComputeBuilder
-    attr_reader   :cluster, :facet, :facet_index, :tags
-    attr_accessor :chef_node, :fog_server
+    magic :cluster, Cluster
+    magic :facet, Facet
+    magic :facet_index, Integer
+    attr_reader :tags
+
+    magic :chef_node, Whatever, :default => -> owner,name { owner.cluster.find_node(name) || false }
+    attr_accessor :fog_server
 
     @@all ||= Mash.new
 
     def initialize facet, idx
-      @cluster     = facet.cluster
-      @facet       = facet
-      @facet_index = idx
+      cluster           facet.cluster
+      facet             facet
+      facet_index       idx
       @fullname    = [cluster_name, facet_name, facet_index].join('-')
       super(@fullname)
       @tags = { "name" => name, "cluster" => cluster_name, "facet"   => facet_name, "index" => facet_index, }
@@ -40,13 +45,13 @@ module Ironfan
       Ironfan::ServerSlice.new(cluster, [self])
     end
 
-    def bogosity val=nil
-      @settings[:bogosity] = val  if not val.nil?
-      return @settings[:bogosity] if not @settings[:bogosity].nil?
-      return :bogus_facet         if facet.bogus?
-      # return :out_of_range      if (self.facet_index.to_i >= facet.instances)
-      false
-    end
+#     def bogosity val=nil
+#       @settings[:bogosity] = val  if not val.nil?
+#       return @settings[:bogosity] if not @settings[:bogosity].nil?
+#       return :bogus_facet         if facet.bogus?
+#       # return :out_of_range      if (self.facet_index.to_i >= facet.instances)
+#       false
+#     end
 
     def in_cloud?
       !! fog_server
@@ -85,7 +90,7 @@ module Ironfan
     end
 
     def permanent?
-      !! self.cloud.permanent
+      [true, :true, 'true'].include?(self.cloud.permanent)
     end
 
     def killable?
@@ -118,13 +123,12 @@ module Ironfan
     # Resolve:
     #
     def resolve!
-      reverse_merge!(facet)
-      reverse_merge!(cluster)
-      @settings[:run_list] = combined_run_list
-      #
-      cloud.reverse_merge!(facet.cloud)
-      cloud.reverse_merge!(cluster.cloud)
-      #
+      facet.underlay              = cluster
+      self.underlay               = facet
+
+      facet.cloud.underlay        = cluster.cloud
+      cloud.underlay              = facet.cloud
+
       cloud.user_data({
           :chef_server            => chef_server_url,
           :validation_client_name => validation_client_name,
@@ -185,36 +189,6 @@ module Ironfan
         cg[:last],   fg[:last],   sg[:last], ].flatten.compact.uniq
     end
 
-    #
-    # This prepares a composited view of the volumes -- it shows the cluster
-    # definition overlaid by the facet definition overlaid by the server
-    # definition.
-    #
-    # This method *does* auto-vivify an empty volume declaration on the server,
-    # but doesn't modify it.
-    #
-    # This code is pretty smelly, but so is the resolve! behavior. advice welcome.
-    #
-    def composite_volumes
-      vols = {}
-      self.volumes.each do |vol_name, vol|
-        vols[vol_name]         ||= self.volumes[vol_name].dup
-        vols[vol_name].reverse_merge!(vol)
-      end
-      facet.volumes.each do |vol_name, vol|
-        self.volumes[vol_name] ||= Ironfan::Volume.new(:parent => self, :name => vol_name)
-        vols[vol_name]         ||= self.volumes[vol_name].dup
-        vols[vol_name].reverse_merge!(vol)
-      end
-      cluster.volumes.each do |vol_name, vol|
-        self.volumes[vol_name] ||= Ironfan::Volume.new(:parent => self, :name => vol_name)
-        vols[vol_name]         ||= self.volumes[vol_name].dup
-        vols[vol_name].reverse_merge!(vol)
-      end
-      vols.each{|vol_name, vol| vol.availability_zone self.default_availability_zone }
-      vols
-    end
-
     # FIXME -- this will break on some edge case wehre a bogus node is
     # discovered after everything is resolve!d
     def default_availability_zone
@@ -269,7 +243,7 @@ module Ironfan
       return unless created?
       step("  labeling servers and volumes")
       fog_create_tags(fog_server, self.fullname, tags)
-      composite_volumes.each do |vol_name, vol|
+      volumes.each_pair do |vol_name, vol|
         if vol.fog_volume
           fog_create_tags(vol.fog_volume, vol.desc,
             { "server" => self.fullname, "name" => "#{name}-#{vol.name}", "device" => vol.device, "mount_point" => vol.mount_point, "cluster" => cluster_name, "facet"   => facet_name, "index"   => facet_index, })
@@ -278,7 +252,7 @@ module Ironfan
     end
 
     def block_device_mapping
-      composite_volumes.values.map(&:block_device_mapping).compact
+      volumes.values.map(&:block_device_mapping).compact
     end
 
     # ugh. non-dry below.