ironfan 3.2.2 → 4.0.0

data/lib/ironfan/server.rb

@@ -1,291 +0,0 @@
-module Ironfan
-
-  #
-  # A server is a specific (logical) member of a facet within a cluster.
-  #
-  # It may have extra attributes if it also exists in the Chef server,
-  # or if it exists in the real world (as revealed by Fog)
-  #
-  class Server < Ironfan::ComputeBuilder
-    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
-      @fullname    = [cluster_name, facet_name, facet_index].join('-')
-      super(@fullname)
-      @tags = { "name" => name, "cluster" => cluster_name, "facet"   => facet_name, "index" => facet_index, }
-      ui.warn("Duplicate server #{[self, facet.name, idx]} vs #{@@all[fullname]}") if @@all[fullname]
-      @@all[fullname] = self
-    end
-
-    def fullname fn=nil
-      @fullname = fn if fn
-      @fullname
-    end
-
-    def cluster_name
-      cluster.name
-    end
-
-    def facet_name
-      facet.name
-    end
-
-    def servers
-      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 in_cloud?
-      !! fog_server
-    end
-
-    def in_chef?
-      chef_node || chef_client
-    end
-
-    def has_cloud_state?(*states)
-      in_cloud? && states.flatten.include?(fog_server.state)
-    end
-
-    def exists?
-      created? || in_chef?
-    end
-
-    def created?
-      in_cloud? && (not ['terminated', 'shutting-down'].include?(fog_server.state))
-    end
-
-    def running?
-      has_cloud_state?('running')
-    end
-
-    def startable?
-      has_cloud_state?('stopped')
-    end
-
-    def launchable?
-      not created?
-    end
-
-    def sshable?
-      in_chef?
-    end
-
-    def permanent?
-      [true, :true, 'true'].include?(self.cloud.permanent)
-    end
-
-    def killable?
-      return false if permanent?
-      in_chef? || created?
-    end
-
-    def to_s
-      super[0..-3] + " chef: #{in_chef? && chef_node.name} fog: #{in_cloud? && fog_server.id}}>"
-    end
-
-    #
-    # Attributes
-    #
-
-    def tag key, value=nil
-      if value then @tags[key] = value ; end
-      @tags[key]
-    end
-
-    def public_hostname
-      give_me_a_hostname_from_one_of_these_seven_ways_you_assholes
-    end
-
-    def chef_server_url()        Chef::Config.chef_server_url        ; end
-    def validation_client_name() Chef::Config.validation_client_name ; end
-    def validation_key()         Chef::Config.validation_key         ; end
-    def organization()           Chef::Config.organization           ; end
-    #
-    # Resolve:
-    #
-    def resolve!
-      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,
-          #
-          :node_name              => fullname,
-          :organization           => organization,
-          :cluster_name           => cluster_name,
-          :facet_name             => facet_name,
-          :facet_index            => facet_index,
-          #
-          :run_list               => combined_run_list,
-        })
-      #
-      cloud.keypair(cluster_name) if cloud.keypair.nil?
-      #
-      self
-    end
-
-    #
-    # Assembles the combined runlist.
-    #
-    # * run_list :first  items -- cluster then facet then server
-    # * run_list :normal items -- cluster then facet then server
-    # * own roles: cluster_role then facet_role
-    # * run_list :last   items -- cluster then facet then server
-    #
-    #    Ironfan.cluster(:my_cluster) do
-    #      role('f',  :last)
-    #      role('c')
-    #      facet(:my_facet) do
-    #        role('d')
-    #        role('e')
-    #        role('b', :first)
-    #        role('h',  :last)
-    #      end
-    #      role('a', :first)
-    #      role('g', :last)
-    #    end
-    #
-    # produces
-    #    cluster list  [a] [c]  [cluster_role] [fg]
-    #    facet list    [b] [de] [facet_role]   [h]
-    #
-    # yielding run_list
-    #     ['a', 'b', 'c', 'd', 'e', 'cr', 'fr', 'f', 'g', 'h']
-    #
-    # Avoid duplicate conflicting declarations. If you say define things more
-    # than once, the *earliest encountered* one wins, even if it is elsewhere
-    # marked :last.
-    #
-    def combined_run_list
-      cg = @cluster.run_list_groups
-      fg = @facet.run_list_groups
-      sg = self.run_list_groups
-      [ cg[:first],  fg[:first],  sg[:first],
-        cg[:normal], fg[:normal], sg[:normal],
-        cg[:own],    fg[:own],
-        cg[:last],   fg[:last],   sg[:last], ].flatten.compact.uniq
-    end
-
-    # FIXME -- this will break on some edge case wehre a bogus node is
-    # discovered after everything is resolve!d
-    def default_availability_zone
-      cloud.default_availability_zone
-    end
-
-    #
-    # retrieval
-    #
-    def self.get(cluster_name, facet_name, facet_index)
-      cluster = Ironfan.cluster(cluster_name)
-      had_facet = cluster.has_facet?(facet_name)
-      facet = cluster.facet(facet_name)
-      facet.bogosity true unless had_facet
-      had_server = facet.has_server?( facet_index )
-      server = facet.server(facet_index)
-      server.bogosity :not_defined_in_facet unless had_server
-      return server
-    end
-
-    def self.all
-      @@all
-    end
-
-    #
-    # Actions!
-    #
-
-    def sync_to_cloud
-      step "Syncing to cloud"
-      attach_volumes
-      create_tags
-      associate_public_ip
-      ensure_placement_group
-      set_instance_attributes
-    end
-
-    def sync_to_chef
-      step "Syncing to chef server"
-      sync_chef_node
-      true
-    end
-
-    # FIXME: a lot of AWS logic in here. This probably lives in the facet.cloud
-    # but for the one or two things that come from the facet
-    def create_server
-      return nil if created? # only create a server if it does not already exist
-      fog_create_server
-    end
-
-    def create_tags
-      return unless created?
-      step("  labeling servers and volumes")
-      fog_create_tags(fog_server, self.fullname, tags)
-      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, })
-        end
-      end
-    end
-
-    def block_device_mapping
-      volumes.values.map(&:block_device_mapping).compact
-    end
-
-    # ugh. non-dry below.
-
-    def announce_as_started
-      return unless chef_node
-      announce_state('start')
-      chef_node.save
-    end
-
-    def announce_as_stopped
-      return unless chef_node
-      announce_state('stop')
-      chef_node.save
-    end
-
-  protected
-
-    def give_me_a_hostname_from_one_of_these_seven_ways_you_assholes
-      # note: there are not actually seven ways. That is the least absurd part of this situation.
-      case
-      when cloud.public_ip
-        cloud.public_ip
-      when fog_server && fog_server.respond_to?(:public_ip_address) && fog_server.public_ip_address.present?
-        fog_server.public_ip_address
-      when fog_server && fog_server.respond_to?(:ipaddress)
-        fog_server.ipaddress
-      when fog_server && fog_server.respond_to?(:dns_name)
-        fog_server.dns_name
-      else
-        nil
-      end
-    end
-
-  end
-end

data/lib/ironfan/server_slice.rb

@@ -1,265 +0,0 @@
-module Ironfan
-  #
-  # A server group is a set of actual or implied servers.
-  #
-  # The idea is we want to be able to smoothly roll up settings
-  #
-  #
-  class ServerSlice < Ironfan::DslBuilderCollection
-    attr_accessor :name
-    attr_accessor :cluster
-
-    def initialize cluster, servers
-      @item_type = Ironfan::Server
-      @key_method = :name
-      super()
-      self.name    = "#{cluster.name} slice"
-      self.cluster = cluster
-      receive!(servers)
-    end
-
-    def servers
-      @clxn.values
-    end
-
-    [:select, :find_all, :reject, :detect, :find, :drop_while].each do |method|
-      define_method(method) do |*args, &block|
-        ServerSlice.new cluster, servers.send(method, *args, &block)
-      end
-    end
-    # true if slice contains a server with the given fullname (if arg is a
-    # string) or same fullname as the given server (if a Server)
-    #
-    # @overload include?(server_fullname)
-    #   @param [String] server_fullname checks for a server with that fullname
-    # @overload include?(server)
-    #   @param [Ironfan::Server] server checks for server with same fullname
-    def include?(server)
-      fullname = server.is_a?(String) ? server : server.fullname
-      @servers.any?{|svr| svr.fullname == fullname }
-    end
-
-    # Return the collection of servers that are not yet 'created'
-    def uncreated_servers
-      select{|svr| not svr.created? }
-    end
-
-    def bogus_servers
-      select(&:bogus?)
-    end
-
-    #
-    # Info!
-    #
-
-    def chef_nodes
-      servers.map(&:chef_node).compact
-    end
-
-    def fog_servers
-      servers.map(&:fog_server).compact
-    end
-
-    def security_groups
-      sg = {}
-      servers.each{|svr| sg.merge!(svr.cloud.security_groups) }
-      sg
-    end
-
-    def facets
-      servers.map(&:facet)
-    end
-
-    def chef_roles
-      [ cluster.chef_roles, facets.map(&:chef_roles) ].flatten.compact.uniq
-    end
-
-    # hack -- take the ssh_identity_file from the first server.
-    def ssh_identity_file
-      return if servers.empty?
-      servers.first.cloud.ssh_identity_file
-    end
-
-    #
-    # Actions!
-    #
-
-    def start
-      delegate_to_fog_servers( :start  )
-      delegate_to_fog_servers( :reload  )
-    end
-
-    def stop
-      delegate_to_fog_servers( :stop )
-      delegate_to_fog_servers( :reload  )
-    end
-
-    def destroy
-      delegate_to_fog_servers( :destroy )
-      delegate_to_fog_servers( :reload  )
-    end
-
-    def reload
-      delegate_to_fog_servers( :reload  )
-    end
-
-    def create_servers
-      delegate_to_servers( :create_server )
-    end
-
-    def delete_chef
-      delegate_to_servers( :delete_chef, true )
-    end
-
-    def sync_to_cloud
-      sync_keypairs
-      sync_security_groups
-      delegate_to_servers( :sync_to_cloud )
-    end
-
-    def sync_to_chef
-      sync_roles
-      delegate_to_servers( :sync_to_chef )
-    end
-
-    #
-    # Display!
-    #
-
-    # FIXME: this is a jumble. we need to pass it in some other way.
-
-    MINIMAL_HEADINGS  = ["Name", "Chef?", "State", "InstanceID", "Public IP", "Private IP", "Created At"].to_set.freeze
-    DEFAULT_HEADINGS  = (MINIMAL_HEADINGS + ['Flavor', 'AZ', 'Env']).freeze
-    EXPANDED_HEADINGS = DEFAULT_HEADINGS + ['Image', 'Volumes', 'Elastic IP', 'SSH Key']
-
-    MACHINE_STATE_COLORS  = {
-      'running'       => :green,
-      'pending'       => :yellow,
-      'stopping'      => :magenta,
-      'shutting-down' => :magenta,
-      'stopped'       => :cyan,
-      'terminated'    => :blue,
-      'not running'   => :blue,
-    }
-
-    #
-    # This is a generic display routine for cluster-like sets of nodes. If you
-    # call it with no args, you get the basic table that knife cluster show
-    # draws.  If you give it an array of strings, you can override the order and
-    # headings displayed. If you also give it a block you can add your own logic
-    # for generating content. The block is given a Ironfan::Server instance
-    # for each item in the collection and should return a hash of Name,Value
-    # pairs to merge into the minimal fields.
-    #
-    def display hh = :default
-      headings =
-        case hh
-        when :minimal  then MINIMAL_HEADINGS
-        when :default  then DEFAULT_HEADINGS
-        when :expanded then EXPANDED_HEADINGS
-        else hh.to_set end
-      headings += ["Bogus"] if servers.any?(&:bogus?)
-      # probably not necessary any more
-      # servers = servers.sort{ |a,b| (a.facet_name <=> b.facet_name) *9 + (a.facet_index.to_i <=> b.facet_index.to_i)*3 + (a.facet_index <=> b.facet_index) }
-      defined_data = servers.map do |svr|
-        hsh = {
-          "Name"   => svr.fullname,
-          "Facet"  => svr.facet_name,
-          "Index"  => svr.facet_index,
-          "Chef?"  => (svr.chef_node? ? "yes" : "[red]no[reset]"),
-          "Bogus"  => (svr.bogus? ? "[red]#{svr.bogosity}[reset]" : ''),
-          "Env"    => svr.environment,
-        }
-        # if (cs = svr.chef_server)
-        #   hsh.merge!(
-        #     "Env"    => cs.environment,
-        #     )
-        # end
-        if (fs = svr.fog_server)
-          hsh.merge!(
-              "InstanceID" => (fs.id && fs.id.length > 0) ? fs.id : "???",
-              "Flavor"     => fs.flavor_id,
-              "Image"      => fs.image_id,
-              "AZ"         => fs.availability_zone,
-              "SSH Key"    => fs.key_name,
-              "State"      => "[#{MACHINE_STATE_COLORS[fs.state] || 'white'}]#{fs.state}[reset]",
-              "Public IP"  => fs.public_ip_address,
-              "Private IP" => fs.private_ip_address,
-              "Created At" => fs.created_at.strftime("%Y%m%d-%H%M%S")
-            )
-        else
-          hsh["State"] = "not running"
-        end
-        hsh['Volumes'] = []
-        svr.volumes.each_pair do |name, vol|
-          if    vol.ephemeral_device? then next
-          elsif vol.volume_id         then hsh['Volumes'] << vol.volume_id
-          elsif vol.create_at_launch? then hsh['Volumes'] << vol.snapshot_id
-          end
-        end
-        hsh['Volumes']    = hsh['Volumes'].join(',')
-        hsh['Elastic IP'] = svr.cloud.public_ip if svr.cloud.public_ip
-        if block_given?
-          extra_info = yield(svr)
-          hsh.merge!(extra_info)
-          headings += extra_info.keys
-        end
-        hsh
-      end
-      if defined_data.empty?
-        ui.info "Nothing to report"
-      else
-        Formatador.display_compact_table(defined_data, headings.to_a)
-      end
-    end
-
-    def to_s
-      str = super
-      str[0..-2] + " #{@servers.map(&:fullname)}>"
-    end
-
-    def joined_names
-      map(&:name).join(", ").gsub(/, ([^,]*)$/, ' and \1')
-    end
-
-    # Calls block on each server in parallel, each in its own thread
-    #
-    # @example
-    #   target = Ironfan::Cluster.slice('web_server')
-    #   target.parallelize{|svr| svr.launch }
-    #
-    # @yield each server, in turn
-    #
-    # @return [Array] array (in same order as servers) of each block's result
-    def parallelize
-      servers.map do |svr|
-        sleep(0.1) # avoid hammering with simultaneous requests
-        Thread.new(svr){|svr| yield(svr) }
-      end
-    end
-
-  protected
-
-    # Helper methods for iterating through the servers to do things
-    #
-    # @param [Symbol]  method   -- method to call on each server
-    # @param [Boolean] threaded -- execute each call in own thread
-    #
-    # @return [Array] array (in same order as servers) of results for that method
-    def delegate_to_servers method, threaded = true
-      if threaded  # Call in threads
-        threads = parallelize{|svr| svr.send(method) }
-        threads.map{|t| t.join.value } # Wait, returning array of results
-      else         # Call the method for each server sequentially
-        servers.map{|svr| svr.send(method) }
-      end
-    end
-
-    def delegate_to_fog_servers method
-      fog_servers.compact.map do |fs|
-        fs.send(method)
-      end
-    end
-
-  end
-end

data/lib/ironfan/volume.rb

@@ -1,146 +0,0 @@
-module Ironfan
-  #
-  # Internal or external storage
-  #
-  class Volume < Ironfan::DslBuilder
-    field :parent, String
-    attr_accessor :fog_volume
-
-    # mountable volume attributes
-    magic :device, String
-    magic :mount_point, String
-    magic :mount_options, String, :default => 'defaults,nouuid,noatime'
-    magic :fstype, String, :default => 'xfs'
-    magic :mount_dump, String
-    magic :mount_pass, String
-    magic :mountable, Whatever, :default => true
-    magic :formattable, Whatever, :default => false
-    magic :resizable, Whatever, :default => false
-    magic :in_raid, Whatever, :default => false
-    # cloud volume attributes
-    magic :attachable, Whatever, :default => :ebs
-    magic :create_at_launch, Whatever, :default => false
-    magic :volume_id, String
-    magic :snapshot_id, String
-    magic :size, String
-    magic :keep, Whatever, :default => true
-    magic :availability_zone, String
-    # arbitrary tags
-    magic :tags, Hash, :default => {}
-
-    # Snapshot for snapshot_name method.
-    # Set your own by adding
-    #
-    #     VOLUME_IDS = Mash.new unless defined?(VOLUME_IDS)
-    #     VOLUME_IDS.merge!({ :your_id => 'snap-whatever' })
-    #
-    # to your organization's knife.rb
-    #
-    VOLUME_IDS = Mash.new unless defined?(VOLUME_IDS)
-    VOLUME_IDS.merge!({
-      :blank_xfs       => 'snap-d9c1edb1',
-    })
-
-    # Describes a volume
-    #
-    # @example
-    #   Ironfan::Volume.new( :name => 'redis',
-    #     :device => '/dev/sdp', :mount_point => '/data/redis', :fstype => 'xfs', :mount_options => 'defaults,nouuid,noatime'
-    #     :size => 1024, :snapshot_id => 'snap-66494a08', :volume_id => 'vol-12312',
-    #     :tags => {}, :keep => true )
-    #
-    def initialize attrs={}
-      parent = attrs.delete(:owner)
-      super(attrs)
-    end
-
-    # human-readable description for logging messages and such
-    def desc
-      container = parent.name rescue nil
-      "#{name} on #{container} (#{volume_id} @ #{device})"
-    end
-
-    def ephemeral_device?
-      volume_id =~ /^ephemeral/
-    end
-
-    # Named snapshots, as defined in Ironfan::Volume::VOLUME_IDS
-    def snapshot_name(name)
-      snap_id = VOLUME_IDS[name.to_sym]
-      raise "Unknown snapshot name #{name} - is it defined in Ironfan::Volume::VOLUME_IDS?" unless snap_id
-      self.snapshot_id(snap_id)
-    end
-
-    # With snapshot specified but volume missing, have it auto-created at launch
-    #
-    # Be careful with this -- you can end up with multiple volumes claiming to
-    # be the same thing.
-    #
-    def create_at_launch?
-      volume_id.blank? && self.create_at_launch
-    end
-
-    def in_cloud?
-      !! fog_volume
-    end
-
-    def has_server?
-      in_cloud? && fog_volume.server_id.present?
-    end
-
-#     def reverse_merge!(other_hsh)
-#       super(other_hsh)
-#       self.tags.reverse_merge!(other_hsh.tags) if other_hsh.respond_to?(:tags) && other_hsh.tags.present?
-#       self
-#     end
-
-    # An array of hashes with dorky-looking keys, just like Fog wants it.
-    def block_device_mapping
-      hsh = { 'DeviceName' => device }
-      if ephemeral_device?
-        hsh['VirtualName'] = volume_id
-      elsif create_at_launch?
-        raise "Must specify a size or a snapshot ID for #{self}" if snapshot_id.blank? && size.blank?
-        hsh['Ebs.SnapshotId'] = snapshot_id if snapshot_id.present?
-        hsh['Ebs.VolumeSize'] = size.to_s   if size.present?
-        hsh['Ebs.DeleteOnTermination'] = (! keep).to_s
-      else
-        return
-      end
-      hsh
-    end
-
-  end
-
-
-  #
-  # Consider raising the chunk size to 256 and setting read_ahead 65536 if you are raid'ing EBS volumes
-  #
-  # * http://victortrac.com/EC2_Ephemeral_Disks_vs_EBS_Volumes
-  # * http://orion.heroku.com/past/2009/7/29/io_performance_on_ebs/
-  # * http://tech.blog.greplin.com/aws-best-practices-and-benchmarks
-  # * http://stu.mp/2009/12/disk-io-and-throughput-benchmarks-on-amazons-ec2.html
-  #
-  class RaidGroup < Volume
-    # volumes that comprise this raid group
-    magic :sub_volumes, Array, :default => []
-    # RAID level (http://en.wikipedia.org/wiki/RAID#Standard_levels)
-    magic :level, String
-    # Raid chunk size (https://raid.wiki.kernel.org/articles/r/a/i/RAID_setup_cbb2.html)
-    magic :chunk, String
-    # read-ahead buffer
-    magic :read_ahead, String
-
-    # Overrides of Volume field defaults
-    magic :attachable, Whatever, :default => false
-    magic :formattable, Whatever, :default => true
-    magic :mount_options, String, :default => 'defaults,nobootwait,noatime,nouuid,comment=ironfan'
-
-    def desc
-      "#{name} on #{parent.fullname} (#{volume_id} @ #{device} from #{sub_volumes.join(',')})"
-    end
-
-#     attr_reader   :parent
-    attr_accessor :fog_volume
-  end
-end