ironfan 3.2.2 → 4.0.0

data/lib/gorillib/resolution.rb

@@ -0,0 +1,119 @@
+require 'gorillib/model/serialization'
+require 'gorillib/serialization/to_wire'
+require 'gorillib/hash/deep_merge'
+
+module Gorillib
+
+  # Make a clean deep-copy of the value, via gorillib semantics if 
+  #   possible, otherwise via marshalling
+  def self.deep_copy(value)
+    case
+    when ( value.respond_to? :to_wire and value.respond_to? :receive )
+      return value.class.receive(value.to_wire)
+    else
+      return Marshal.load(Marshal.dump(value))
+    end
+  end
+
+  module Model
+    Field.class_eval do
+      field :resolver, Symbol, :default => :read_set_or_underlay_attribute
+    end
+  end
+
+  # The attribute :underlay provides an object (preferably another
+  #   Gorillib::Model or the like) that will resolve stacked 
+  #   defaults. If fields are declared with a :resolver, it will 
+  #   apply that call in preference the default rules (self.field
+  #   -> underlay.field -> self.field.default )
+  #
+  # To provide resolve cleanly without read-write loops destroying 
+  #   the separation of concerns, the resolve mechanism has been 
+  #   broken from the regular read-write accessors.
+  #
+  module Resolution
+    extend  Gorillib::Concern
+    include Gorillib::FancyBuilder
+    attr_accessor :underlay
+
+    # Return a fully-resolved copy of this object. All objects
+    #   referenced will be clean deep_copies, and will lack the 
+    #   :underlay accessor. This is by design, to prevent self-
+    #   referential loops (parent->collection->child->owner) 
+    #   when deep_coping.
+    def resolve
+      result = self.class.new
+      self.class.fields.each do |field_name, field|
+        value = read_resolved_attribute(field_name)
+        result.write_attribute(field_name, value) unless value.nil?
+      end
+      result
+    end
+
+    def deep_resolve(field_name)
+      temp = read_set_or_underlay_attribute(field_name)
+      return if temp.nil?
+      if temp.is_a? Gorillib::Collection
+        result = temp.class.new
+        temp.each_pair {|k,v| result[k] = resolve_value(v) }
+      else
+        result = resolve_value(v)
+      end
+      result
+    end
+    
+    def resolve_value(value)
+      return if value.nil?
+      return value.resolve if value.respond_to? :resolve
+      deep_copy(value)
+    end
+
+    def merge_resolve(field_name)
+      field = self.class.fields[field_name] or return
+      result = field.type.new
+      merge_values(result,read_underlay_attribute(field_name))
+      merge_values(result,read_set_attribute(field_name))
+      result
+    end
+
+    def merge_values(target, value=nil)
+      value ||= {}
+      if target.is_a? Gorillib::Collection
+        value.each_pair do |k,v|
+          existing = target[k]
+          if existing && existing.respond_to?(:receive!)
+            target[k].receive! v
+          elsif existing && existing.respond_to?(:merge!)
+            target[k].merge! v
+          else
+            target[k] = v
+          end
+        end
+      else
+        target.receive! value
+      end
+    end
+
+    def read_resolved_attribute(field_name)
+      field = self.class.fields[field_name] or return
+      self.send(field.resolver, 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_resolved_attribute(field_name)
+    end
+
+    def read_set_or_underlay_attribute(field_name)
+      result = read_set_attribute(field_name)
+      return result unless result.nil?
+      read_underlay_attribute(field_name)
+    end
+  end
+
+end

data/lib/ironfan/broker/computer.rb

@@ -0,0 +1,316 @@
+module Ironfan
+  class Broker
+
+    class Computer < Builder
+      collection :resources,    Whatever
+      collection :drives,       Ironfan::Broker::Drive
+      collection :providers,    Ironfan::Provider
+      field :server,            Ironfan::Dsl::Server
+      delegate :[],:[]=,:include?,:delete,
+          :to =>                :resources
+
+      # Only used for bogus servers
+      field :name,              String
+      field :bogus,             Array,          :default => []
+
+      def initialize(*args)
+        super
+        providers[:chef] ||=    Ironfan::Provider::ChefServer
+        return unless server
+        providers[:iaas] =      server.selected_cloud.provider
+        volumes =               server.volumes.values
+        volumes +=              server.implied_volumes
+        volumes.each { |v| self.drive v.name, :volume => v }
+      end
+
+      def name
+        return server.fullname  if server?
+        return @name            if @name
+        "unnamed:#{object_id}"
+      end
+
+      #
+      # Discovery
+      #
+      def correlate
+        chosen_resources.each do |res|
+          unless res.respond_to? :expected_ids
+            Chef::Log.warn("FIXME: Using correlate! instead of on_correlate in #{res}")
+            res.correlate! self
+            return
+          end
+        
+          res.expected_ids(self).each do |id|
+            next unless res.recall? id
+
+            recalled =            res.recall id
+            recalled.users <<     self
+
+            target =              res.resource_type.to_s
+            target +=             "__#{id}" if res.multiple?
+            self[target.to_sym] = recalled
+
+            recalled.on_correlate(self)
+          end
+        end
+      end
+
+      def correlate_with(res)
+      end
+
+      def validate
+        computer = self
+        Ironfan.delegate_to(chosen_resources) { validate_computer! computer }
+      end
+
+      #
+      # Manipulation
+      #
+      def kill(options={})
+        target_resources = chosen_resources(options)
+        resources.each do |res|
+          next unless target_resources.include? res.class
+          res.destroy unless res.shared?
+        end
+      end
+
+      def launch
+        ensure_dependencies
+        providers[:iaas].machine_class.create! self
+        save
+      end
+
+      def stop
+        machine.stop
+        node.announce_state :stopped
+      end
+
+      def start
+        ensure_dependencies
+        machine.start
+        node.announce_state :started
+        save
+      end
+
+      def save(options={})
+        chosen_resources(options).each {|res| res.save! self}
+      end
+
+      #
+      # Utility
+      #
+      def chosen_providers(options={})
+        case options[:providers]
+        when :all,nil   then    [:chef,:iaas]
+        else                    [ (options[:providers]) ]
+        end
+      end
+
+      def chosen_resources(options={})
+        chosen_providers(options).map do |name|
+          providers[name].resources
+        end.flatten
+      end
+
+      def ensure_dependencies
+        chosen_resources.each do |res|
+#           ensure_resource res unless res < Ironfan::IaasProvider::Machine
+          res.create! self unless res < Ironfan::IaasProvider::Machine
+        end
+      end
+
+#       def ensure_resource(type)
+#         if type.multiple?
+#           existing = resources[type.resource_id]
+#         else
+#           
+#         end
+#       end
+
+      #
+      # Display
+      #
+      def to_display(style,values={})
+        unless [:minimal,:default,:expanded].include? style
+          raise "Bad display style #{style}"
+        end
+
+        values["Name"] =        name
+        # We expect these to be over-ridden by the contained classes
+        values["Chef?"] =       "no"
+        values["State"] =       "not running"
+
+        delegate_to([ server, node, machine ].compact) do
+          to_display style, values
+        end
+
+        if style == :expanded
+          values["Startable"]  = display_boolean(stopped?)
+          values["Launchable"] = display_boolean(launchable?)
+        end
+        values["Bogus"] =       bogus.join(',')
+
+        # Only show values that actually have something to show
+        values.delete_if {|k,v| v.to_s.empty?}
+        values
+      end
+      def display_boolean(value)        value ? "yes" : "no";   end
+
+      #
+      # Accessors
+      #
+      def bogus
+        resources.values.map(&:bogus).flatten
+      end
+      def client
+        self[:client]
+      end
+      def machine
+        self[:machine]
+      end
+      def machine=(value)
+        self[:machine] = value
+      end
+      def node
+        self[:node]
+      end
+      def node=(value)
+        self[:node]= value
+      end
+
+      #
+      # Status flags
+      #
+      def bogus?
+        resources.values.any?(&:bogus?)
+      end
+      def client?
+        not client.nil?
+      end
+      def created?
+        machine? and machine.created?
+      end
+      def machine?
+        not machine.nil?
+      end
+      def killable?
+        not permanent? and (node? or created?)
+      end
+      def launchable?
+        not bogus? and not created?
+      end
+      def node?
+        not node.nil?
+      end
+      def permanent?
+        return false unless server?
+        return false unless server.selected_cloud.respond_to? :permanent
+        [true, :true, 'true'].include? server.selected_cloud.permanent
+      end
+      def running?
+        machine? and machine.running?
+      end
+      def server?
+        not server.nil?
+      end
+      def stopped?
+        machine? and machine.stopped?
+      end
+
+    end
+
+    class Computers < Gorillib::ModelCollection
+      self.item_type    = Computer
+      self.key_method   = :object_id
+      delegate :first, :map, :any?,
+          :to           => :values
+      attr_accessor     :cluster
+
+      def initialize(*args)
+        super
+        options = args.pop or return
+        self.cluster = options[:cluster]
+        create_expected!
+      end
+
+      # 
+      # Discovery
+      #
+      def correlate
+        values.each {|computer| computer.correlate }
+      end
+
+      def validate
+        providers = values.map {|c| c.providers.values}.flatten
+        computers = self
+
+        Ironfan.delegate_to(values)     { validate }
+        Ironfan.delegate_to(providers)  { validate computers }
+      end
+
+      #
+      # Manipulation
+      #
+      def kill(options={})
+        Ironfan.delegate_to(values)     { kill(options) }
+      end
+      def launch
+        Ironfan.delegate_to(values)     { launch }
+      end
+      def save(options={})
+        Ironfan.delegate_to(values)     { save(options) }
+      end
+      def start
+        Ironfan.delegate_to(values)     { start }
+      end
+      def stop
+        Ironfan.delegate_to(values)     { stop }
+      end
+
+      # set up new computers for each server in the cluster definition
+      def create_expected!
+        self.cluster.servers.each do |server|
+          self << Computer.new(:server => server)
+        end unless self.cluster.nil?
+      end
+
+      # Return the selection inside another Computers collection
+      def select(&block)
+        result = empty_copy
+        values.select(&block).each{|m| result << m}
+        result
+      end
+
+      def empty_copy
+        result          = self.class.new
+        result.cluster  = self.cluster unless self.cluster.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? and slice_indexes.nil?)
+        result          = empty_copy
+        slice_array     = build_slice_array(slice_indexes)
+        each do |m|
+          result << m if (m.bogus? or (                 # bogus computer or
+            ( m.server.facet_name == facet_name ) and   # facet match and
+              ( slice_array.include? m.server.index or  #   index match or
+                slice_indexes.nil? ) ) )                #   no indexes specified
+        end
+        result
+      end
+      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
+      end
+
+      # Utility function to provide a human-readable list of names
+      def joined_names
+        values.map(&:name).join(", ").gsub(/, ([^,]*)$/, ' and \1')
+      end
+    end
+
+  end
+end

data/lib/ironfan/broker/drive.rb

@@ -0,0 +1,21 @@
+module Ironfan
+  class Broker
+
+    class Drive < Builder
+      field :node,              Hash,           :default => {}
+      field :disk,              Ironfan::Provider::Resource
+      field :volume,            Ironfan::Dsl::Volume
+
+      field :name,              String
+
+      def volume=(value)
+        super
+        return unless value
+        # inscribe the cluster DSL values into chef attributes
+        volume.attributes.each_pair {|k,v| node[k.to_s] = v }
+      end
+
+    end
+
+  end
+end

data/lib/ironfan/broker.rb

@@ -0,0 +1,37 @@
+# This module is intended to read in a cluster DSL description, and broker
+#   out to the various cloud providers, to control instance life-cycle and
+#   handle provider-specific amenities (SecurityGroup, Volume, etc.) for 
+#   them.
+module Ironfan
+  def self.broker
+    @@broker ||= Ironfan::Broker.new
+  end
+
+  class Broker < Builder
+    # Take in a Dsl::Cluster, return Computers populated with
+    #   all discovered resources that correlate, plus bogus computers
+    #   corresponding to 
+    def discover!(cluster)
+      # Get fully resolved servers, and build Computers using them
+      computers = Computers.new(:cluster => cluster.resolve)
+      providers = computers.map{|c| c.providers.values}.flatten.uniq
+
+      delegate_to(providers) { load cluster }
+      computers.correlate
+      computers.validate
+      computers
+    end
+
+    def display(computers,style)
+      defined_data = computers.map {|m| m.to_display(style) }
+      if defined_data.empty?
+        ui.info "Nothing to report"
+      else
+        headings = defined_data.map{|r| r.keys}.flatten.uniq
+        Formatador.display_compact_table(defined_data, headings.to_a)
+      end
+    end
+
+  end
+
+end

data/lib/ironfan/builder.rb

@@ -0,0 +1,14 @@
+module Ironfan
+
+  class Builder
+    include Gorillib::Builder
+
+    def self.ui() Ironfan.ui ; end
+    def ui()      Ironfan.ui ; end
+
+    def delegate_to(*args,&block)
+      Ironfan.delegate_to(*args,&block)
+    end
+  end
+
+end

data/lib/ironfan/deprecated.rb

@@ -1,68 +1,26 @@
 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}"
+    correction = ", " if replacement
+    ui.error "The '#{call}' statement is deprecated#{correction} (in #{caller(2).first.inspect}). It looks like you are using an outdated DSL definition: please see https://github.com/infochimps-labs/ironfan/wiki/Upgrading-to-v4 for all the necessary upgrade steps."
+    exit(1)
   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
-    def use(*clusters)
-      Ironfan.deprecated 'use', 'underlay'
-      clusters.each do |c|
-        other_cluster =  Ironfan.load_cluster(c)
-        cluster.underlay        other_cluster
+  class Dsl
+    class Cloud
+      def defaults
+        Ironfan.deprecated 'defaults'
       end
-      self
     end
-  end
-
-  class Server
-    def chef_node_name name
-      Ironfan.deprecated 'chef_node_name', 'fullname'
-      fullname name
-    end
-
-    def composite_volumes
-      Ironfan.deprecated 'composite_volumes', 'volumes'
-      volumes
-    end
-  end
-
-  class CloudDsl::Ec2
-    def elastic_ip(*args, &block)
-      Ironfan.deprecated 'elastic_ip', 'public_ip'
-      public_ip(*args, &block)
+    
+    class Compute
+      def cloud(provider=nil)
+        if provider.nil?
+          Ironfan.deprecated 'cloud(nil)','use cloud(:ec2) instead'
+          provider = :ec2
+        end
+        super(provider)
+      end
     end
-  end
 
-  class Volume
-    def defaults
-      Ironfan.deprecated 'defaults'
-    end
   end
 end

data/lib/ironfan/dsl/cloud.rb

@@ -0,0 +1,21 @@
+module Ironfan
+  class Dsl
+
+    class Cloud < Ironfan::Dsl
+      magic :default_cloud,           :boolean,       :default => false
+
+      # Factory out to subclasses 
+      def self.receive(obj,&block)
+        obj[:_type] = case obj[:name]
+          when        :ec2;           Ec2
+          when        :virtualbox;    VirtualBox
+          else;       raise "Unsupported cloud #{obj[:name]}"
+        end unless native?(obj)
+        super
+      end
+
+      def implied_volumes()     Ironfan.noop(self,__method__,*p);      end
+    end
+
+  end
+end

data/lib/ironfan/dsl/cluster.rb

@@ -0,0 +1,27 @@
+module Ironfan
+  class Dsl
+
+    class Cluster < Ironfan::Dsl::Compute
+      collection :facets,       Ironfan::Dsl::Facet,   :resolver => :deep_resolve
+
+      def initialize(attrs={},&block)
+        super
+        self.cluster_role       Ironfan::Dsl::Role.new(:name => "#{attrs[:name]}_cluster")
+        self.expand_servers!
+      end
+
+      def expand_servers!
+        facets.each {|facet| facet.expand_servers! }
+        servers
+      end
+
+      # Utility method to reference all servers from constituent facets
+      def servers
+        result = Gorillib::ModelCollection.new(:item_type => Ironfan::Dsl::Server, :key_method => :fullname)
+        facets.each {|f| f.servers.each {|s| result << s} }
+        result
+      end
+    end
+
+  end
+end