ironfan 5.0.11 → 6.0.0

data/lib/chef/knife/ironfan_knife_common.rb

@@ -1,5 +1,3 @@
-require 'chef/knife'
-
 module Ironfan
   module KnifeCommon
     attr_accessor :broker
@@ -16,10 +14,11 @@ module Ironfan
       $LOAD_PATH << File.join(Chef::Config[:ironfan_path], '/lib') if Chef::Config[:ironfan_path]
       require 'ironfan'
       $stdout.sync = true
-      Ironfan.ui          = self.ui
-      self.config[:cloud] = Chef::Config[:cloud] if Chef::Config.has_key?(:cloud)
-      Ironfan.chef_config = self.config
-      self.broker         = Ironfan.broker
+      Ironfan.ui           = self.ui
+      self.config[:cloud]  = Chef::Config[:cloud] if Chef::Config.has_key?(:cloud)
+      Ironfan.knife_config = self.config
+      Ironfan.chef_config  = Chef::Config
+      self.broker          = Ironfan.broker
     end
 
     def run()
@@ -51,21 +50,27 @@ module Ironfan
     #
     # @return [Ironfan::ServerSlice] the requested slice
     def get_slice(slice_string, *args)
-      cluster_name, facet_name, slice_indexes = pick_apart(slice_string, *args)
-      desc = predicate_str(cluster_name, facet_name, slice_indexes)
+      realm_name, cluster_name, facet_name, slice_indexes = pick_apart(slice_string, *args)
+      desc = predicate_str(realm_name, cluster_name, facet_name, slice_indexes)
       #
       ui.info("Inventorying servers in #{desc}")
-      cluster   = Ironfan.load_cluster(cluster_name)
-      Chef::Config[:knife][:region] = cluster.servers.to_a.first.cloud(:ec2).region
-      computers =  broker.discover! cluster
+      realm = Ironfan.load_realm(realm_name)
+      realm.clusters.each{ |cluster| Ironfan.load_cluster cluster.name }
+      realm.resolve!
+      Chef::Config[:knife][:region] = realm.clusters.to_a.first.servers.to_a.first.cloud(:ec2).region
+      computers = broker.discover!(realm.clusters.to_a, config[:cloud])
       Chef::Log.info("Inventoried #{computers.size} computers")
       #
-      computers.slice(facet_name, slice_indexes)
+      computers.slice(cluster_name, facet_name, slice_indexes)
     end
 
     def all_computers(slice_string, *args)
-      cluster_name, facet_name, slice_indexes = pick_apart(slice_string, *args)
-      computers = broker.discover! Ironfan.load_cluster(cluster_name)
+      realm_name, cluster_name, facet_name, slice_indexes = pick_apart(slice_string, *args)
+      realm = Ironfan.load_realm(realm_name)
+      realm.clusters.each{ |cluster| Ironfan.load_cluster cluster.name }
+      realm.resolve!
+      clusters = cluster_name ? Array(realm.clusters[cluster_name.to_sym]) : realm.clusters.to_a
+      computers = broker.discover!(clusters, config[:cloud])
       ui.info("Loaded information for #{computers.size} computer(s) in cluster #{cluster_name}")
       computers
     end
@@ -76,11 +81,12 @@ module Ironfan
         ui.info("")
         ui.warn("Please specify server slices joined by dashes and not separate args:\n\n  knife cluster #{sub_command} #{slice_string}\n\n")
       end
-      slice_string.split(/[\s\-]/, 3)
+      slice_string.split(/[\s\-]/, 4)
     end
 
-    def predicate_str(cluster_name, facet_name, slice_indexes)
-      [ "#{ui.color(cluster_name, :bold)} cluster",
+    def predicate_str(realm_name, cluster_name, facet_name, slice_indexes)
+      [ "#{ui.color(realm_name, :bold)} realm",
+        (cluster_name  ? "#{ui.color(cluster_name, :bold)} cluster"  : "#{ui.color("all", :bold)} clusters"),
         (facet_name    ? "#{ui.color(facet_name, :bold)} facet"      : "#{ui.color("all", :bold)} facets"),
         (slice_indexes ? "servers #{ui.color(slice_indexes, :bold)}" : "#{ui.color("all", :bold)} servers")
       ].join(', ')
@@ -185,10 +191,44 @@ module Ironfan
       end
     end
 
+    def wait_for_ssh(computer)
+      ssh = Chef::Knife::Ssh.new
+      ssh.ui = ui
+      ssh.name_args = [ computer.name, "ls" ]
+      ssh.config[:ssh_user] = Chef::Config[:knife][:ssh_user] || config[:ssh_user]
+      ssh.config[:ssh_password] = config[:ssh_password]
+      ssh.config[:ssh_port] = Chef::Config[:knife][:ssh_port] || config[:ssh_port]
+      ssh.config[:ssh_gateway] = Chef::Config[:knife][:ssh_gateway] || config[:ssh_gateway]
+      ssh.config[:forward_agent] = Chef::Config[:knife][:forward_agent] || config[:forward_agent]
+      ssh.config[:identity_file] = Chef::Config[:knife][:identity_file] || config[:identity_file]
+      ssh.config[:manual] = true
+      ssh.config[:host_key_verify] = Chef::Config[:knife][:host_key_verify] || config[:host_key_verify]
+      ssh.config[:on_error] = :raise
+      session = ssh.session
+      return true
+    rescue Errno::ETIMEDOUT
+      Chef::Log.debug("ssh to #{computer.name} timed out")
+      return false
+    rescue Errno::ECONNREFUSED
+      Chef::Log.debug("ssh connection to #{computer.name} refused")
+      yield
+      return false
+    rescue Errno::EHOSTUNREACH
+      Chef::Log.debug("ssh host #{computer.name} unreachable")
+      yield
+      return false
+    rescue 
+      Chef::Log.debug("something else went wrong while wating for ssh host #{computer.name}")
+      raise
+      return false
+    else
+      session && session.close
+      session = nil
+    end
+      
     #
     # Utilities
     #
-
     def sub_command
       self.class.sub_command
     end

data/lib/chef/knife/ironfan_script.rb

@@ -15,9 +15,6 @@
 # See the License for the specific language governing permissions and
 # limitations under the License.
 #
-
-require File.expand_path('ironfan_knife_common', File.dirname(File.realdirpath(__FILE__)))
-
 module Ironfan
   class Script < Chef::Knife
     include Ironfan::KnifeCommon

data/lib/ironfan/broker/computer.rb

@@ -34,6 +34,7 @@ module Ironfan
       # Discovery
       #
       def correlate
+        Chef::Log.info chosen_resources
         chosen_resources.each do |res|
           res.expected_ids(self).each do |id|
             next unless res.recall? id
@@ -272,12 +273,12 @@ module Ironfan
       self.item_type  = Computer
       self.key_method = :object_id
       delegate        :first, :map, :any?, :to => :values
-      attr_accessor   :cluster
+      attr_accessor   :clusters
 
       def initialize(*args)
         super
         options = args.pop or return
-        self.cluster = options[:cluster]
+        self.clusters = options[:clusters]
         create_expected!
       end
 
@@ -338,9 +339,10 @@ module Ironfan
 
       # set up new computers for each server in the cluster definition
       def create_expected!
-        self.cluster.servers.each do |server|
+        servers = self.clusters.map{ |c| c.servers.to_a }.flatten
+        servers.each do |server|
           self << Computer.new(:server => server)
-        end unless self.cluster.nil?
+        end unless self.clusters.nil?
       end
 
       # Return the selection inside another Computers collection
@@ -352,23 +354,24 @@ module Ironfan
 
       def empty_copy
         result          = self.class.new
-        result.cluster  = self.cluster unless self.cluster.nil?
+        result.clusters = self.clusters unless self.clusters.nil?
         result
       end
 
       # Find all selected computers, as well as any bogus computers from discovery
-      def slice(facet_name=nil, slice_indexes=nil)
-        return self if (facet_name.nil? && slice_indexes.nil?)
-        slice_array     = build_slice_array(slice_indexes)
+      def slice(cluster_name = nil, facet_name = nil, slice_indexes = nil)
+        return self if cluster_name.nil? && facet_name.nil? && slice_indexes.nil?
+        slice_array = build_slice_array(slice_indexes)
         select do |mach|
-          mach.bogus? or (
+          mach.bogus? || (
             # facet match, and index match (or no indexes specified)
-            (mach.server.facet_name == facet_name) &&
+            (mach.server.cluster_name == cluster_name) &&                          
+            (mach.server.facet_name == facet_name || facet_name.nil?) &&
             (slice_array.include?(mach.server.index) || slice_indexes.nil?))
         end
       end
 
-      def build_slice_array(slice_indexes)
+      def build_slice_array slice_indexes
         return [] if slice_indexes.nil?
         raise "Bad slice_indexes: #{slice_indexes}" if slice_indexes =~ /[^0-9\.,]/
         eval("[#{slice_indexes}]").map {|idx| idx.class == Range ? idx.to_a : idx}.flatten

data/lib/ironfan/broker.rb

@@ -11,22 +11,27 @@ module Ironfan
     # Take in a Dsl::Cluster; return Computers populated with all discovered
     #   resources that correlate; computers corresponding to partial or
     #   unrecognizable resources are labeled as bogus.
-    def discover!(cluster)
+    def discover!(clusters, with_cloud = true)
 
       # Get fully resolved servers, and build Computers using them
-      computers = Computers.new(:cluster => cluster)
-      #
-      providers = computers.map{|c| c.providers.values }.flatten.uniq
-      Ironfan.parallel(providers) do |provider|
-        Ironfan.step cluster.name, "Loading #{provider.handle}", :cyan
-        provider.load cluster
+      computers = Computers.new(clusters: Array(clusters))
+      #      
+      if with_cloud
+        providers = computers.map{|c| c.providers.values }.flatten.uniq
+        Ironfan.parallel(providers) do |provider|
+          clusters.each do |cluster|
+            Ironfan.step cluster.name, "Loading #{provider.handle}", :cyan
+            provider.load cluster
+          end
+        end
+        #
+        clusters.each do |cluster|
+          Ironfan.step cluster.name, "Reconciling DSL and provider information", :cyan
+        end
+        computers.correlate
+        computers.validate
       end
       #
-      Ironfan.step cluster.name, "Reconciling DSL and provider information", :cyan
-
-      computers.correlate
-      computers.validate
-      #
       computers
     end
 

data/lib/ironfan/cookbook_requirements.rb

@@ -0,0 +1,155 @@
+module Ironfan
+
+  module CookbookRequirements
+    extend Gorillib::Concern
+
+    def join_req(req1, req2)
+      # order requirements by operation: =, >=, ~>
+      req1, req2       = (req1.constraint < req2.constraint) ? [req1, req2] : [req2, req1]
+      cn1, cn2         = [req1.constraint, req2.constraint]
+      vers1, vers2     = [cn1.split.last, cn2.split.last]
+      vers1_c, vers2_c = [vers1.split('.'), vers2.split('.')]
+      op1, op2         = [req1, req2].map{ |x| x.constraint.split.first }
+
+      if    op1 == '='  && op2 == '='
+        join_eq_eq(req1, req2)
+      elsif op1 == '>=' && op2 == '>='
+        join_geq_geq(req1, req2)
+      elsif op1 == '~>' && op2 == '~>'
+        join_agt_agt(req1, req2)
+      elsif op1 == '='  && op2 == '>='
+        join_eq_gte(req1, req2)
+      elsif op1 == '='  && op2 == '~>'
+        join_eq_agt(req1, req2)
+      elsif op1 == '>=' && op2 == '~>'
+        join_gte_agt(req1, req2)
+      end
+    end
+
+    def cookbook_req(name, constraint)
+      (@cookbook_reqs ||= []) << self.class.new_req(name, constraint)
+    end
+
+    def children
+      []
+    end
+
+    def cookbook_reqs
+      Hash[_cookbook_reqs.map{ |x| [x.name, x.constraint] }]
+    end
+
+    def _cookbook_reqs
+      [
+       *shallow_cookbook_reqs,
+       *child_cookbook_reqs
+      ].group_by(&:name).values.map do |group|
+        group.inject{ |result, req| join_req(result, req) }
+      end
+    end
+
+    private
+
+    #-----------------------------------------------------------------------------------------------
+
+    def join_eq_eq(req1, req2)
+      (vers(req1) == vers(req2)) ? req1 : bad_reqs(req1, req2)
+    end
+
+    def join_geq_geq(req1, req2)
+      (vers(req1) >= vers(req2)) ? req1 : req2
+    end
+
+    def join_agt_agt(req1, req2)
+      if vers_a(req1).size == vers_a(req2).size &&
+          vers_a_head(req1).zip(vers_a_head(req2)).all?{|v1,v2| v1 == v2}
+        (req1.constraint > req2.constraint) ? req1 : req2
+      else
+        bad_reqs(req1, req2)
+      end
+    end
+
+    def join_eq_gte(req1, req2)
+      vers(req1) >= vers(req2) ? req1 : bad_reqs(req1, req2)
+    end
+
+    def join_eq_agt(req1, req2)
+      if match_v_head(req1, req2) &&
+          vers_a(req1)[vers_a(req2).size - 1] >= vers_a(req2).last
+        req1
+      else
+        bad_reqs(req1, req2)
+      end
+    end
+
+    def join_gte_agt(req1, req2)
+      if match_v_head(req1, req2) && vers(req1) <= vers(req2)
+        req2
+      else
+        bad_reqs(req1, req2)
+      end
+    end
+
+    def match_v_head(req1, req2)
+      vers_a_head(req1, vers_a(req2).size).zip(vers_a_head(req2)).all?{|v1,v2| v1 == v2}      
+    end
+
+    def op req
+      req.constraint.split.first
+    end
+
+    def vers req
+      req.constraint.split.last
+    end
+
+    def vers_a req
+      vers(req).split('.')
+    end
+
+    def vers_a_head(req, last = 0)
+      vers_a(req)[0...last - 1]
+    end
+
+    #-----------------------------------------------------------------------------------------------
+
+    def bad_reqs(req1, req2)
+      raise ArgumentError.new("#{req1.name}: cannot reconcile #{req1.constraint} with #{req2.constraint}")
+    end
+
+    def child_cookbook_reqs
+      children.map(&:_cookbook_reqs).flatten(1)
+    end
+    
+    def shallow_cookbook_reqs
+      @cookbook_reqs || self.class.default_cookbook_reqs
+    end
+
+    module ClassMethods
+
+      def require_strict_versioning?
+        @require_strict = true if @require_strict.nil?
+        @require_strict
+      end
+
+      def require_strict_versioning choice
+        @require_strict = choice
+      end
+
+      def new_req(name, constraint)
+        if constraint.start_with?('>=') && require_strict_versioning?
+          raise StandardError.new("Please don't use >= constraints. They're too vague!")
+        else
+          Ironfan::Plugin::CookbookRequirement.new(name: name, constraint: constraint)
+        end
+      end
+      
+      def default_cookbook_reqs
+        @default_cookbook_reqs ||= []
+      end
+      
+      def cookbook_req(name, constraint)
+        default_cookbook_reqs << new_req(name, constraint)
+      end
+
+    end
+  end
+end

data/lib/ironfan/dsl/cloud.rb

@@ -14,6 +14,8 @@ module Ironfan
             when :virtualbox then VirtualBox
             when :vsphere    then Vsphere
             when :rds        then Rds
+            when :openstack  then OpenStack
+            when :static     then Static
             else raise "Unsupported cloud #{obj[:name]}"
             end
         end

data/lib/ironfan/dsl/cluster.rb

@@ -1,35 +1,45 @@
 module Ironfan
   class Dsl
-
     class Cluster < Ironfan::Dsl::Compute
-      collection :facets,       Ironfan::Dsl::Facet,   :resolver => :deep_resolve
       include Ironfan::Plugin::Base; register_with Ironfan::Dsl::Realm
 
-      def children
-        facets.to_a + components.to_a
+      collection :facets, Ironfan::Dsl::Facet, resolver: :deep_resolve
+
+      def self.plugin_hook(owner, attrs, plugin_name, full_name, &blk)
+        owner.cluster(plugin_name, new(attrs.merge(name: full_name, owner: owner)))
+        _project(cluster, &blk)
+      end
+
+      def self.definitions
+        @clusters ||= {}
       end
 
-      def initialize(attrs={},&block)
+      def self.define(attrs = {}, &blk)
+        cl = new(attrs)
+        cl.receive!({}, &blk) # the ordering of the initialize method is super fragile
+        definitions[attrs[:name].to_sym] = cl
+      end
+      
+      def initialize(attrs = {}, &blk)
         super
-        self.cluster_role       Ironfan::Dsl::Role.new(:name => "#{attrs[:name]}-cluster")
-        self.realm_name         attrs[:owner].name unless attrs[:owner].nil?
-        self.cluster_names      attrs[:owner].cluster_names unless attrs[:owner].nil?
+        self.cluster_role  Ironfan::Dsl::Role.new(name: "#{attrs[:name]}-cluster")
+        self.realm_name    attrs[:owner].name          unless attrs[:owner].nil?
+        self.cluster_names attrs[:owner].cluster_names unless attrs[:owner].nil?
       end
 
       # Utility method to reference all servers from constituent facets
       def servers
-        result = Gorillib::ModelCollection.new(:item_type => Ironfan::Dsl::Server, :key_method => :full_name)
-        facets.each {|f| f.servers.each {|s| result << s} }
+        result = Gorillib::ModelCollection.new(item_type: Ironfan::Dsl::Server, key_method: :full_name)
+        facets.each{ |f| f.servers.each{ |s| result << s } }
         result
       end
 
-      def cluster_name
-        name
+      def children
+        facets.to_a + components.to_a
       end
 
-      def self.plugin_hook owner, attrs, plugin_name, full_name, &blk
-        owner.cluster(plugin_name, new(attrs.merge(name: full_name, owner: owner)))
-        _project cluster, &blk
+      def cluster_name
+        name
       end
     end
   end

data/lib/ironfan/dsl/component.rb

@@ -6,14 +6,14 @@ module Ironfan
       include Ironfan::Plugin::Base; register_with Ironfan::Dsl::Compute
 
       field :cluster_name, Symbol
-      field :facet_name, Symbol
-      field :realm_name, Symbol
-      field :name, Symbol
+      field :facet_name,   Symbol
+      field :realm_name,   Symbol
+      field :name,         Symbol
 
       def initialize(attrs, &blk)
-        attrs.merge!(facet_name: (attrs[:owner].name unless attrs[:owner].nil? or not attrs[:owner].is_a?(Facet)),
+        attrs.merge!(facet_name:   (attrs[:owner].name unless attrs[:owner].nil? or not attrs[:owner].is_a?(Facet)),
                      cluster_name: (attrs[:owner].cluster_name unless attrs[:owner].nil?),
-                     realm_name: (attrs[:owner].realm_name unless attrs[:owner].nil?))
+                     realm_name:   (attrs[:owner].realm_name unless attrs[:owner].nil?))
         super attrs, &blk
       end
 
@@ -34,8 +34,8 @@ module Ironfan
 
       def self.from_node(node = NilCheckDelegate.new(nil))
         cluster_name = node['cluster_name'].to_s
-        super(node).tap{|x| x.receive!(cluster_name: cluster_name,
-                                       realm_name: cluster_name.split('_').first)}
+        realm_name = node['realm_name'].to_s
+        super(node).tap{ |x| x.receive!(cluster_name: cluster_name, realm_name: realm_name) }                                        
       end
 
       def self.announce_name
@@ -94,7 +94,7 @@ module Ironfan
         end
       end
 
-      def set_discovery compute, keys
+      def set_discovery(compute, keys)
         if server_cluster
           wire_to(compute, full_server_cluster, keys)
         else
@@ -110,14 +110,11 @@ module Ironfan
         discovery = {discovers: keys.reverse.inject(full_server_cluster_v){|hsh,key| {key => hsh}}}
         (compute.facet_role || compute.cluster_role).override_attributes(discovery)
 
-        # FIXME: This is Ec2-specific and probably doesn't belong here.
         client_group_v = client_group(compute)
         server_group_v = security_group(full_server_cluster_v)
 
-        if create_security_groups
-          group_edge(compute.cloud(:ec2), client_group_v, :authorized_by_group, server_group_v)
-          group_edge(compute.cloud(:ec2), client_group_v, :authorize_group,     server_group_v) if bidirectional
-        end
+        group_edge(compute, client_group_v, :authorized_by_group, server_group_v)
+        group_edge(compute, client_group_v, :authorize_group,     server_group_v) if bidirectional
 
         Chef::Log.debug("discovered #{announce_name} for #{cluster_name}: #{discovery}")
       end
@@ -125,11 +122,11 @@ module Ironfan
       protected
 
       def client_group(compute)
-        security_group(compute.cluster_name)
+        security_group(compute.cluster_name, (compute.name if compute.is_a?(Facet)))
       end
       
       def full_server_cluster
-        "#{realm_name}_#{server_cluster}"
+        server_cluster
       end
 
       def group_edge(cloud, group_1, method, group_2)

data/lib/ironfan/dsl/compute.rb

@@ -15,24 +15,26 @@ module Ironfan
 
     class Compute < Ironfan::Dsl
       @@run_list_rank = 0
-      field      :name,         String
+      field      :name,           String
 
       # Resolve each of the following as a merge of their container's attributes and theirs
-      collection :components,   Ironfan::Dsl::Component,   :resolver => :merge_resolve, :key_method => :name
+      collection :components,     Ironfan::Dsl::Component, :resolver => :merge_resolve, :key_method => :name
       collection :run_list_items, RunListItem,             :resolver => :merge_resolve, :key_method => :name
       collection :clouds,       Ironfan::Dsl::Cloud,       :resolver => :merge_resolve, :key_method => :name
       collection :volumes,      Ironfan::Dsl::Volume,      :resolver => :merge_resolve, :key_method => :name
+      collection :security_groups, Ironfan::Dsl::SecurityGroup, :resolver => :merge_resolve, :key_method => :name
 
       # Resolve these normally (overriding on each layer)
-      magic      :environment,  Symbol,                    :default => :_default
-      magic      :use_cloud,    Symbol
+      magic      :environment,    Symbol,                  default: :_default
+      magic      :realm_name,     Symbol,                  default: :_default
+      magic      :use_cloud,      Symbol
 
-      member     :cluster_role, Ironfan::Dsl::Role
-      member     :facet_role,   Ironfan::Dsl::Role
+      member     :cluster_role,   Ironfan::Dsl::Role
+      member     :facet_role,     Ironfan::Dsl::Role
 
-      magic      :cluster_names, Whatever
-      magic      :realm_name,    Symbol
+      magic      :cluster_names,  Whatever
 
+      magic      :dns_domain,    String
       field      :source_file,   String
 
       extend Gorillib::Concern

data/lib/ironfan/dsl/ec2.rb

@@ -30,12 +30,13 @@ module Ironfan
       magic :auto_elastic_ip,           String
       magic :allocation_id,             String
       magic :region,                    String,         :default => ->{ default_region }
-      collection :security_groups,      Ironfan::Dsl::Ec2::SecurityGroup, :key_method => :name
+      collection :security_groups,      Ironfan::Dsl::SecurityGroup, :key_method => :name
       magic :ssh_user,                  String,         :default => ->{ image_info[:ssh_user] }
       magic :ssh_identity_dir,          String,         :default => ->{ Chef::Config.ec2_key_dir }
       magic :subnet,                    String
       magic :validation_key,            String,         :default => ->{ IO.read(Chef::Config.validation_key) rescue '' }
       magic :vpc,                       String
+      magic :dns_search_domain,         String,         :default => 'internal'
 
       def domain;                       vpc.nil? ? 'standard' : 'vpc';       end
 
@@ -125,31 +126,6 @@ module Ironfan
         end
       end
 
-      class SecurityGroup < Ironfan::Dsl
-        field :name,                    String
-        field :group_authorized,        Array, :default => []
-        field :group_authorized_by,     Array, :default => []
-        field :range_authorizations,    Array, :default => []
-
-        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]
-          range_authorizations.compact!
-          range_authorizations.uniq!
-        end
-
-        def authorized_by_group(other_name)
-          group_authorized_by << other_name.to_s
-          group_authorized_by.compact!
-          group_authorized_by.uniq!
-        end
-
-        def authorize_group(other_name)
-          group_authorized << other_name.to_s
-          group_authorized.compact!
-          group_authorized.uniq!
-        end
-      end
 
       class ElasticLoadBalancer
 

data/lib/ironfan/dsl/facet.rb

@@ -4,29 +4,31 @@ module Ironfan
     class Facet < Ironfan::Dsl::Compute
       include Ironfan::Plugin::Base; register_with Ironfan::Dsl::Cluster
 
-      magic      :instances,    Integer,                :default => 1
-      collection :servers,      Ironfan::Dsl::Server,   :resolver => :deep_resolve
+      magic      :instances,    Integer,              default: 1
+      collection :servers,      Ironfan::Dsl::Server, resolver: :deep_resolve
       field      :cluster_name, String
 
-      def initialize(attrs={},&block)
-        self.cluster_names      attrs[:owner].cluster_names unless attrs[:owner].nil?
-        self.realm_name         attrs[:owner].realm_name unless attrs[:owner].nil?
-        self.cluster_name       = attrs[:owner].cluster_name unless attrs[:owner].nil?
-        self.name               = attrs[:name] unless attrs[:name].nil?
-        self.facet_role         Ironfan::Dsl::Role.new(:name => "#{full_name}-facet")
+      def self.plugin_hook(owner, attrs, plugin_name, full_name, &blk)
+        facet = owner.facet(plugin_name, new(attrs.merge(name: plugin_name, owner: owner)))
+        _project(facet, &blk)
+      end
+
+      def initialize(attrs = {}, &blk)
+        self.cluster_names  attrs[:owner].cluster_names unless attrs[:owner].nil?
+        self.realm_name     attrs[:owner].realm_name    unless attrs[:owner].nil?
+        self.cluster_name = attrs[:owner].cluster_name  unless attrs[:owner].nil?
+        self.name         = attrs[:name]                unless attrs[:name].nil?
+        self.facet_role     Ironfan::Dsl::Role.new(name: "#{full_name}-facet")
         super
-        for i in 0 .. instances-1; server(i); end
+        (0..instances - 1).each{ |idx| server idx }
       end
 
       def children
         servers.to_a + components.to_a
       end
 
-      def full_name()           "#{cluster_name}-#{name}";      end
-
-      def self.plugin_hook owner, attrs, plugin_name, full_name, &blk
-        facet = owner.facet(plugin_name, new(attrs.merge(name: plugin_name, owner: owner)))
-        _project facet, &blk
+      def full_name
+        "#{cluster_name}-#{name}"
       end
     end
   end