ironfan 3.2.2 → 4.0.0

data/lib/ironfan/provider/chef/node.rb

@@ -0,0 +1,133 @@
+module Ironfan
+  class Provider
+    class ChefServer
+
+      class Node < Ironfan::Provider::Resource
+        delegate :[], :[]=, :add_to_index, :apply_expansion_attributes,
+            :attribute, :attribute=, :attribute?, :automatic_attrs,
+            :automatic_attrs=, :cdb_destroy, :cdb_save, :chef_environment,
+            :chef_environment=, :chef_server_rest, :class_from_file,
+            :construct_attributes, :consume_attributes,
+            :consume_external_attrs, :consume_run_list, :cookbook_collection,
+            :cookbook_collection=, :couchdb, :couchdb=, :couchdb_id,
+            :couchdb_id=, :couchdb_rev, :couchdb_rev=, :create, :default,
+            :default_attrs, :default_attrs=, :default_unless,
+            :delete_from_index, :destroy, :display_hash, :each,
+            :each_attribute, :each_key, :each_value, :expand!, :find_file,
+            :from_file, :has_key?, :include_attribute, :index_id, :index_id=,
+            :index_object_type, :key?, :keys,
+            :load_attribute_by_short_filename, :load_attributes, :name, :node,
+            :normal, :normal_attrs, :normal_attrs=, :normal_unless, :override,
+            :override_attrs, :override_attrs=, :override_unless, :recipe?,
+            :recipe_list, :recipe_list=, :reset_defaults_and_overrides, :role?,
+            :run_list, :run_list=, :run_list?, :run_state, :run_state=, :save,
+            :set, :set_if_args, :set_or_return, :set_unless, :drive, :tags,
+            :to_hash, :update_from!, :validate, :with_indexer_metadata,
+          :to => :adaptee
+
+        def initialize(*args)
+          super
+          self.adaptee ||= Chef::Node.new
+        end
+
+        def self.shared?()              false;  end
+        def self.multiple?()            false;  end
+#         def self.resource_type()        self;   end
+        def self.resource_type()        :node;   end
+        def self.expected_ids(computer) [computer.server.fullname];   end
+
+        def to_display(style,values={})
+          values["Chef?"] =     adaptee.nil? ? "no" : "yes"
+          values
+        end
+
+        def save!(computer)
+          prepare_from computer
+          save
+        end
+
+        def create!(computer)
+          prepare_from computer
+
+          client = computer[:client]
+          unless File.exists?(client.key_filename)
+            raise("Cannot create chef node #{name} -- client #{@chef_client} exists but no client key found in #{client.key_filename}.")
+          end
+          ChefServer.post_rest("nodes", adaptee, :client => client)
+        end
+
+        def prepare_from(computer)
+          organization =                Chef::Config.organization
+          normal[:organization] =       organization unless organization.nil?
+
+          server =                      computer.server
+          chef_environment =            server.environment
+          run_list.instance_eval        { @run_list_items = server.run_list }
+          normal[:cluster_name] =       server.cluster_name
+          normal[:facet_name] =         server.facet_name
+          normal[:permanent] =          computer.permanent?
+          normal[:volumes] =            {}
+          computer.drives.each {|v| normal[:volumes][v.name] = v.node}
+        end
+
+        def announce_state state
+          set[:state] = state
+          save
+        end
+
+        def conterminous_with_machine?
+          true
+        end
+
+        #
+        # Discovery
+        #
+        def self.load!(cluster=nil)
+          ChefServer.search(:node,"name:#{cluster.name}-*") do |raw|
+            next if raw.blank?
+            node = Node.new
+            node.adaptee = raw
+            remember node
+          end
+        end
+
+        def on_correlate(computer)
+          self['volumes'].each do |name,volume|
+            computer.drive(name).node.merge! volume
+          end
+        end
+
+        def self.validate_computer!(computer)
+          return unless computer.node and not computer[:client]
+          computer.node.bogus << :node_without_client
+        end
+
+        #
+        # Manipulation
+        #
+        def self.create!(computer)
+          return if computer.node?
+          node = Node.new
+          node.name           computer.server.fullname
+          node.create!        computer
+          computer.node =     node
+          remember            node
+        end
+
+        def self.destroy!(computer)
+          return unless computer.node?
+          forget computer.node.name
+          computer.node.destroy
+          computer.delete(:node)
+        end
+
+        def self.save!(computer)
+          return unless computer.node?
+          computer.node.save! computer
+        end
+
+      end
+
+    end
+  end
+end

data/lib/ironfan/provider/chef/role.rb

@@ -0,0 +1,69 @@
+module Ironfan
+  class Provider
+    class ChefServer
+
+      class Role < Ironfan::Provider::Resource
+        delegate :active_run_list_for, :add_to_index, :cdb_destroy, :cdb_save,
+          :chef_server_rest, :class_from_file, :couchdb, :couchdb=,
+          :couchdb_id, :couchdb_id=, :couchdb_rev, :couchdb_rev=, :create,
+          :default_attributes, :delete_from_index, :description, :destroy,
+          :env_run_list, :env_run_lists, :environment, :environments,
+          :from_file, :index_id, :index_id=, :index_object_type, :name,
+          :override_attributes, :recipes, :run_list, :run_list_for, :save,
+          :set_or_return, :to_hash, :update_from!, :validate,
+          :with_indexer_metadata,
+        :to => :adaptee
+
+        def self.shared?()      true;   end
+        def self.multiple?()    true;   end
+#         def self.resource_type()        self;   end
+        def self.resource_type()        :role;   end
+        def self.expected_ids(computer)
+          [ computer.server.cluster_role.name.to_s,
+            computer.server.facet_role.name.to_s ]
+        end
+
+        def initialize(config={})
+          super
+          if self.adaptee.nil? and not config[:expected].nil?
+            expected = config[:expected]
+            desc = "Ironfan generated role for #{expected.name}"
+            self.adaptee = Chef::Role.new
+            self.name                   expected.name
+            self.override_attributes    expected.override_attributes
+            self.default_attributes     expected.default_attributes
+            self.description            desc
+          end
+          raise "Missing adaptee" if self.adaptee.nil?
+          self
+        end
+
+        # 
+        # Discovery
+        #
+        def self.load!(cluster)
+          ChefServer.search(:role,"name:#{cluster.name}_*") do |raw|
+            next if raw.blank?
+            remember Role.new(:adaptee => raw)
+          end
+        end
+
+        #
+        # Manipulation
+        #
+        def self.save!(computer)
+          dsl_roles = []
+          dsl_roles << computer.server.cluster_role
+          dsl_roles << computer.server.facet_role
+
+          dsl_roles.each do |dsl_role|
+            next if recall? dsl_role.name       # Handle each role only once
+            role = remember new(:expected => dsl_role)
+            role.save
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ironfan/provider/chef.rb

@@ -0,0 +1,28 @@
+module Ironfan
+  class Provider
+
+    class ChefServer < Ironfan::Provider
+      
+      def self.resources
+        [ Client, Node, Role ]
+      end
+
+      #
+      # Utility functions
+      #
+      def self.post_rest(type, content, options={})
+        params = [ Chef::Config[:chef_server_url] ]
+        if options[:client]
+          params << options[:client].name
+          params << options[:client].key_filename
+        end
+        Chef::REST.new(*params).post_rest(type,content)
+      end
+
+      def self.search(*params,&block)
+        Chef::Search::Query.new.search(*params,&block)
+      end
+    end
+
+  end
+end

data/lib/ironfan/provider/ec2/ebs_volume.rb

@@ -0,0 +1,137 @@
+module Ironfan
+  class Provider
+    class Ec2
+
+      class EbsVolume < Ironfan::Provider::Resource
+        delegate :_dump, :attached_at, :attached_at=, :attributes,
+            :availability_zone, :availability_zone=, :collection, :collection=,
+            :connection, :connection=, :created_at, :created_at=,
+            :delete_on_termination, :delete_on_termination=, :destroy, :device,
+            :device=, :dup_attributes!, :force_detach, :id, :id=, :identity,
+            :identity=, :merge_attributes, :missing_attributes, :new_record?,
+            :ready?, :reload, :requires, :requires_one, :save, :server,
+            :server=, :server_id, :server_id=, :size, :size=, :snapshot,
+            :snapshot_id, :snapshot_id=, :snapshots, :state, :state=,
+            :symbolize_keys, :tags, :tags=, :wait_for,
+          :to => :adaptee
+        field :dsl_volume,        Ironfan::Dsl::Volume
+
+        def self.shared?()      false;  end
+        def self.multiple?()    true;   end
+        def self.resource_type()        :ebs_volume;   end
+        def self.expected_ids(computer)
+          computer.server.volumes.values.map do |volume|
+            saved = computer.node[:volumes][volume.name][:volume_id] rescue nil
+            ebs_name = "#{computer.server.fullname}-#{volume.name}"
+            [ volume.volume_id, saved, ebs_name]
+          end.flatten.compact
+        end
+
+        def name
+          tags["Name"] || tags["name"] || id
+        end
+
+        def ephemeral_device?
+          false
+        end
+
+        #
+        # Discovery
+        #
+        def self.load!(cluster=nil)
+          Ec2.connection.volumes.each do |vol|
+            next if vol.blank?
+            ebs = EbsVolume.new(:adaptee => vol)
+            # Already have a volume by this name
+            if recall? ebs.name
+              ebs.bogus <<              :duplicate_volumes
+              recall(ebs.name).bogus << :duplicate_volumes
+              remember ebs, :append_id => "duplicate:#{ebs.id}"
+            else
+              remember ebs
+            end
+          end
+        end
+
+        def on_correlate(computer)
+          Chef::Log.warn("ebs_volume::on_correlate is incomplete")
+        end
+
+#         def self.correlate!(computer)
+#           Chef::Log.warn("CODE SMELL: overly large method: #{caller}")
+#           return unless computer.server?
+#           computer.server.volumes.each do |volume|
+#             unless volume.attachable.to_s == 'ebs'
+#               Chef::Log.debug("Ignoring non-EBS volume = #{volume}")
+#               next
+#             end
+# 
+#             drive =             computer.drive(volume.name)
+#             drive.node =        computer.node[:volumes][volume.name].to_hash rescue {}
+#             if drive.node.has_key? :volume_id
+#               node_volume_id =  drive.node[:volume_id]
+#             end
+#             ebs_name =          "#{computer.server.fullname}-#{volume.name}"
+# 
+#             volume_id =         volume.volume_id
+#             volume_id ||=       node_volume_id
+# 
+#             # Volumes may match against name derived from the cluster definition,
+#             #   or volume_id from the cluster definition or node
+#             case
+#             when (recall? ebs_name)
+#               ebs =             recall ebs_name
+#             when (volume_id and recall? volume_id)
+#               ebs =             recall volume_id
+#             else
+#               log_message =     "Volume not found: name = #{ebs_name}"
+#               log_message +=    ", volume_id = #{volume_id}"
+#               Chef::Log.debug(log_message)
+#               next
+#             end
+# 
+#             # Make sure all the known volume_ids match
+#             [ ebs.id, volume.volume_id, node_volume_id ].compact.each do |id|
+#               id == volume_id or ebs.bogus << :volume_id_mismatch
+#             end if volume_id
+# 
+#             computer.bogus +=   ebs.bogus
+#             ebs.owner =         computer.object_id
+#             drive.volume =      volume
+#             drive.disk =        ebs
+#           end
+#         end
+        def self.validate_computer!(computer)
+          Chef::Log.warn("ebs_volume::validate_computer! is incomplete")
+#             # Make sure all the known volume_ids match
+#             [ ebs.id, volume.volume_id, node_volume_id ].compact.each do |id|
+#               id == volume_id or ebs.bogus << :volume_id_mismatch
+#             end if volume_id
+        end
+
+        #
+        # Manipulation
+        #
+
+        def self.save!(computer)
+          Ironfan.step(computer.name,"syncing EBS volumes",:blue)
+          computer.drives.each do |drive|
+            # Only worry about computers with ebs volumes
+            ebs = drive.disk or next
+            # Only attach volumes if they aren't already attached
+            if ebs.server_id.nil?
+              Ironfan.step(computer.name, "  - attaching #{ebs.name}", :blue)
+              Ironfan.safely do
+                ebs.device =          drive.volume.device
+                ebs.server =          computer.machine.adaptee
+              end
+            end
+            # Record the volume information in chef
+            drive.node['volume_id'] =  ebs.id
+          end
+        end
+      end
+
+    end
+  end
+end

data/lib/ironfan/provider/ec2/elastic_ip.rb

@@ -0,0 +1,10 @@
+module Ironfan
+  class Provider
+    class Ec2
+
+      class ElasticIp < Ironfan::Provider::Resource
+
+      end
+    end
+  end
+end

data/lib/ironfan/provider/ec2/key_pair.rb

@@ -0,0 +1,65 @@
+module Ironfan
+  class Provider
+    class Ec2
+
+      class KeyPair < Ironfan::Provider::Resource
+        delegate :_dump, :collection, :collection=, :connection,
+            :connection=, :destroy, :fingerprint, :fingerprint=, :identity,
+            :identity=, :name, :name=, :new_record?, :public_key,
+            :public_key=, :reload, :requires, :requires_one, :save,
+            :symbolize_keys, :wait_for, :writable?, :write,
+          :to => :adaptee
+        field :key_filename,    String,
+            :default => ->{ "#{KeyPair.key_dir}/#{name}.pem" }
+
+        def self.shared?()      true;   end
+        def self.multiple?()    false;  end
+        def self.resource_type()        :key_pair;   end
+        def self.expected_ids(computer)   [computer.server.cluster_name];   end
+
+        def private_key
+          File.open(key_filename, "rb").read
+        end
+
+        def private_key=(body=nil)
+          File.open(key_filename, "w", 0600){|f| f.print( body ) }
+        end
+
+        #
+        # Discovery
+        #
+        def self.load!(cluster=nil)
+          Ec2.connection.key_pairs.each do |keypair|
+            register keypair unless keypair.blank?
+          end
+        end
+
+        #
+        # Manipulation
+        #
+
+        def self.create!(computer)
+          name = computer.server.cluster_name
+          return if recall? name
+          Ironfan.step(name, "creating key pair for #{name}", :blue)
+          result = Ec2.connection.create_key_pair(name)
+          private_key = result.body["keyMaterial"]
+          load!  # Reload to get the native object
+          recall(name).private_key = private_key
+        end
+
+        #
+        # Utility
+        #
+
+        def self.key_dir
+          return Chef::Config.ec2_key_dir if Chef::Config.ec2_key_dir
+          dir = "#{ENV['HOME']}/.chef/credentials/ec2_keys"
+          warn "Please set 'ec2_key_dir' in your knife.rb. Will use #{dir} as a default"
+          dir
+        end
+      end
+
+    end
+  end
+end