rudy 0.8.5 → 0.9.0

data/lib/rudy/machines.rb

@@ -1,293 +1,71 @@
-  
 
 
 module Rudy
-  class Machine < Storable 
-    include Rudy::MetaData::ObjectBase
   
-    field :rtype
-    field :awsid
-
-    field :region
-    field :zone
-    field :environment
-    field :role
-    field :position
-    
-    field :created => Time
-    field :started => Time
-    
-    field :dns_public
-    field :dns_private
-    field :state
-    
-    field :os
-    
-    attr_reader :instance
-    
-    def init
-      #@created = 
-      @rtype = 'm'
-      @region = @@global.region
-      @zone = @@global.zone
-      @environment = @@global.environment
-      @role = @@global.role
-      @position = find_next_position || '01'
-      @state = 'no-instance'
-      @os = 'unknown'
-    end
+  module Machines
+    RTYPE = 'm'.freeze
     
-    def liner_note
-      update #if !dns_public? && @awsid
-      info = !@dns_public.nil? && !@dns_public.empty? ? @dns_public : "#{@awsid}:#{@state}"
-      "%s  %s" % [self.name.bright, info]
-    end
+    extend self
+    extend Rudy::Metadata::ClassMethods 
+    extend Rudy::Huxtable
     
-    def to_s(with_title=false)
-      lines = []
-      lines << liner_note
-      #if self.running?
-      #  k, g = @keyname || 'no-keypair', self.groups.join(', ')
-      #  lines << @@sformat % %w{zone size ami keyname groups} if with_title
-      #  lines << @@sformat % [@zone, @size, @ami, k, g]
-      #end
-      lines.join($/)
+    def get(position)
+      tmp = Rudy::Machine.new position
+      record = Rudy::Metadata.get tmp.name
+      return nil unless record.is_a?(Hash)
+      tmp.from_hash record
     end
     
-    def inspect
-      update #if !dns_public? && @awsid
-      lines = []
-      lines << liner_note
-      field_names.each do |key|
-        next unless self.respond_to?(key)
-        val = self.send(key)
-        lines << sprintf(" %22s: %s", key, (val.is_a?(Array) ? val.join(', ') : val))
-      end
-      lines.join($/)
-    end
-      
     def find_next_position
-      list = @sdb.select(self.to_select(nil, [:position])) || []
+      raise "reimplement by looking at position values"
+      list = Rudy::Machines.list({}, [:position]) || []
       pos = list.size + 1
       pos.to_s.rjust(2, '0')
     end
     
-    def name
-      Machine.generate_name(@zone, @environment, @role, @position)
-    end
-
-    def Machine.generate_name(zon, env, rol, pos)
-      pos = pos.to_s.rjust 2, '0'
-      ["m", zon, env, rol, pos].join(Rudy::DELIM)
+    # Returns true if any machine metadata exists for this group
+    def exists?(pos=nil)
+      machines = pos.nil? ? list : get(pos)
+      !machines.nil?
     end
     
-    def get_instance
-      @ec2inst.get(@awsid) rescue nil
+    # Returns true if all machines in the group are running instances
+    def running?(pos=nil)
+      group = pos.nil? ? list : [get(pos)].compact
+      return false if group.nil? || group.empty?
+      group.collect! { |m| m.instance_running? }
+      !group.member?(false)
     end
     
-    def update
-      return false unless @awsid
-      @instance = get_instance
-      if @instance.is_a?(Rudy::AWS::EC2::Instance)
-        @dns_public = @instance.dns_public
-        @dns_private = @instance.dns_private
-        @state = @instance.state
-        save
-      elsif @instance.nil?
-        @awsid = @dns_public = @dns_private = nil
-        @state = 'rogue'
-        # Don't save it b/c it's possible the EC2 server is just down. 
-      end
-    end
-    
-    def dns_public?
-      !@dns_public.nil? && !@dns_public.empty?
-    end
-    def dns_private?
-      !@dns_private.nil? && !@dns_private.empty?
-    end
-    
-    def start(opts={})
-      raise "#{name} is already running" if running?
-      
-      opts = {
-        :min  => 1,
-        :size => current_machine_size,
-        :ami => current_machine_image,
-        :group => current_group_name,
-        :keypair => root_keypairname, 
-        :zone => @@global.zone.to_s,
-        :machine_data => Machine.generate_machine_data.to_yaml
-      }.merge(opts)
-      
-      @os = current_machine_os
-      
-      @ec2inst.create(opts) do |inst|
-        @awsid = inst.awsid
-        @created = @starts = Time.now
-        @state = inst.state
-        # We need to be safe when creating machines because if an exception is
-        # raised, instances will have been creating but the calling class won't know. 
-        begin
-          address = current_machine_address(@position)
-          # Assign IP address only if we have one for that position
-          if address
-            # Make sure the address is associated to the current account
-            if @radd.exists?(address)
-              puts "Associating #{address} to #{inst.awsid}"
-              @radd.associate(address, inst.awsid)
-            else
-              STDERR.puts "Unknown address: #{address}"
-            end
-          end
-        rescue => ex
-          STDERR.puts "Error: #{ex.message}"
-          STDERR.puts ex.backtrace if Rudy.debug?
+    # Returns an Array of newly created Rudy::Machine objects
+    def create(size=nil)
+      if Rudy::Huxtable.global.position.nil?
+        size ||= current_machine_count.to_i || 1
+        group = Array.new(size) do |i|
+          m = Rudy::Machine.new(i + 1)
+          m.create
+          m
         end
-      end
-      
-      self.save
-      
-      self
-    end
-    
-    def destroy
-      @ec2inst.destroy(@awsid) if running?
-      super
-    end
-    
-    def restart
-      @ec2inst.restart(@awsid) if running?
-    end
-    
-    def Machine.generate_machine_data
-      data = {      # Give the machine an identity
-        :region => @@global.region.to_s,
-        :zone => @@global.zone.to_s,
-        :environment => @@global.environment.to_s,
-        :role => @@global.role.to_s,
-        :position => @@global.position.to_s,
-        :hosts => { # Add hosts to the /etc/hosts file 
-          :dbmaster => "127.0.0.1",
-        }
-      } 
-      data
-    end
-    
-    def running?
-      return false if @awsid.nil? || @awsid.empty?
-      @ec2inst.running?(@awsid) rescue nil
-    end
-      
-  end
-
-  
-  class Machines
-    include Rudy::MetaData
-        
-    def create(&each_mach)
-      raise MachineGroupAlreadyRunning, current_machine_group if running?
-      raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
-      
-      unless (1..MAX_INSTANCES).member?(current_machine_count)
-        raise "Instance count must be more than 0, less than #{MAX_INSTANCES}"
-      end
-      
-      unless @rgrp.exists?(current_group_name)
-        puts "Creating group: #{current_group_name}"
-        @rgrp.create(current_group_name)
-      end
-      
-      unless @rkey.exists?(root_keypairname)
-        kp_file = File.join(Rudy::CONFIG_DIR, root_keypairname)
-        raise PrivateKeyFileExists, kp_file if File.exists?(kp_file)
-        puts "Creating keypair: #{root_keypairname}"
-        kp = @rkey.create(root_keypairname)
-        puts "Saving #{kp_file}"
-        Rudy::Utils.write_to_file(kp_file, kp.private_key, 'w', 0600)
       else
-        kp_file = root_keypairpath
-        # This means no keypair file can be found
-        raise PrivateKeyNotFound, root_keypairname if kp_file.nil?
-        # This means we found a keypair in the config but we cannot find the private key file. 
-        raise PrivateKeyNotFound, kp_file if !File.exists?(kp_file)
-      end
-      
-      machines = []
-      current_machine_count.times do  |i|
-        machine = Rudy::Machine.new
-        
-        #puts "Starting %s" % machine.name
-        
-        machine.start
-        machines << machine
+        m = Rudy::Machine.new(Rudy::Huxtable.global.position)
+        m.create
+        [m]
       end
-      machines.each { |m| each_mach.call(m) } if each_mach
-      machines
     end
     
-    
-    def destroy(&each_mach)
-      raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
-      raise MachineGroupNotRunning, current_machine_group unless running?
-      list.each { |m| each_mach.call(m); } if each_mach
-      list do |mach|
-        #puts "Destroying #{mach.name}"
-        mach.destroy
-      end
-    end
-    
-    
-    def restart(&each_mach)
-      raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
-      raise MachineGroupNotRunning, current_machine_group unless running?
-      machines = list
-      machines.each do |mach|
-        each_mach.call(mach) if each_mach
-        puts "Restarting #{mach.name}"
-        mach.restart
-      end
-      machines
-    end
-    
-    def list(more=[], less=[], &each_mach)
-      machines = list_as_hash(more, less, &each_mach)
-      machines &&= machines.values
-      machines
-    end
-    
-    def list_as_hash(more=[], less=[], &each_mach)
-      query = to_select([:rtype, 'm'], less)
-      list = @sdb.select(query) || {}
-      machines = {}
-      list.each_pair do |n,m|
-        machines[n] = Rudy::Machine.from_hash(m)
+    def restart
+      group = list 
+      raise MachineGroupNotRunning, current_group_name if group.nil?
+      group.each do |inst|
+        inst.restart
       end
-      machines.each_pair { |n,mach| each_mach.call(mach) } if each_mach
-      machines = nil if machines.empty?
-      machines
+      group
     end
     
-    def get(rname=nil)
-      Rudy::Machine.from_hash(@sdb.get(Rudy::DOMAIN, rname)) # Returns nil if empty
+    def from_hash(h)
+      Rudy::Machine.from_hash h
     end
     
-    
-    def running?
-      !list.nil?
-      # TODO: add logic that checks whether the instances are running.
-    end
-    
-  end
-  
-  
-  class Machines::Offline
-    def list(more=[], less=[], &each_mach)
-      m = Rudy::Machine.new
-      m.dns_public = 'localhost'
-      each_mach.call(m) if each_mach
-      [m]
-    end
   end
   
 end

data/lib/rudy/metadata.rb

@@ -1,62 +1,236 @@
 
+
 module Rudy
-  module MetaData
+  module Metadata
     include Rudy::Huxtable
     
-    attr_reader :sdb_domain
+    COMMON_FIELDS = [:region, :zone, :environment, :role].freeze
+    
+    @@rsdb   = nil
+    @@domain = Rudy::DOMAIN
     
-    def initialize(*args)
-      a, s, r = @@global.accesskey, @@global.secretkey, @@global.region
-      @sdb = Rudy::AWS::SDB.new(a, s, r)
-      @radd = Rudy::AWS::EC2::Addresses.new(a, s, r)
-      @rinst = Rudy::AWS::EC2::Instances.new(a, s, r)
-      @rgrp = Rudy::AWS::EC2::Groups.new(a, s, r)
-      @rkey = Rudy::AWS::EC2::KeyPairs.new(a, s, r)
-      @sdb_domain = Rudy::DOMAIN
-      init(*args)
+    #
+    def self.get_rclass(rtype)
+      case rtype
+      when Rudy::Machines::RTYPE
+        Rudy::Machines
+      when Rudy::Disks::RTYPE
+        Rudy::Disks
+      when Rudy::Backups::RTYPE
+        Rudy::Backups
+      else
+        raise UnknownRecordType, rtype
+      end
     end
     
-    def init(*args)
+    # Creates instances of the following and stores to class variables:
+    # * Rudy::AWS::SDB
+    # * Rudy::AWS::EC2::Volumes
+    def self.connect(accesskey, secretkey, region, reconnect=false)
+      return @@rsdb unless reconnect || @@rsdb.nil?
+      @@rsdb  = Rudy::AWS::SDB.new accesskey, secretkey, region
+      true
+    end
+    def self.domain(name=nil)
+      return @@domain if name.nil?
+      @@domain = name
+    end
+    # An alias for Rudy::Metadata.domain
+    def self.domain=(*args)
+      domain *args
     end
     
-    # 20090224-1813-36
-    def format_timestamp(dat)
-      mon, day, hour, min, sec = [dat.mon, dat.day, dat.hour, dat.min, dat.sec].collect { |v| v.to_s.rjust(2, "0") }
-      [dat.year, mon, day, Rudy::DELIM, hour, min, Rudy::DELIM, sec].join
+    # Creates a SimpleDB domain named +n+ and updates +@@domain+ if successful
+    def self.create_domain(n)
+      @@domain = n if @@rsdb.create_domain n
     end
     
-    def destroy
-      @sdb.destroy(@sdb_domain, name)
+    # Destroys a SimpleDB domain named +n+ and sets +@@domain+ to Rudy::DOMAIN
+    def self.destroy_domain(n)
+      Rudy::Huxtable.ld "DESTROY: #{n}" if Rudy.debug?
+      @@rsdb.destroy_domain n
+      @@domain = Rudy::DOMAIN
       true
     end
     
-  private
-  
-    # Returns a generic zipped Array of metadata
-    # (There is region, zone, environment, role, but no rtype)
-    # NOTE: I've encoded some mega bullshit in here. more is actually an Array
-    # of name values [n1, v1, n2, v2] (wtf!) which makes local unnecessary.
-    def build_criteria(more=[], less=[], local={})
-      # TODO: This build_criteria treats "more" differently than the
-      # ObjectBase one. Sort it out! (This way is better)
-      names = [:region, :zone, :environment, :role].compact
-      names -= [*less].flatten.uniq.compact
-      values = names.collect do |n|
-        local[n.to_sym] || @@global.send(n.to_sym)
+    # Get a record from SimpleDB with the key +n+
+    def self.get(n)
+      Rudy::Huxtable.ld "GET: #{n}" if Rudy.debug?
+      @@rsdb.get @@domain, n
+    end
+    
+    def self.exists?(n)
+      !get(n).nil?
+    end
+    
+    def self.put(n, o, replace=false)
+      Rudy::Huxtable.ld "PUT: #{n}" if Rudy.debug?
+      @@rsdb.put @@domain, n, o, replace
+    end
+    
+    def self.destroy(n)
+      Rudy::Huxtable.ld "DESTROY: #{n}" if Rudy.debug?
+      @@rsdb.destroy @@domain, n
+    end
+    
+    # Generates and executes a SimpleDB select query based on
+    # the specified +fields+ Hash. See self.build_criteria.
+    #
+    # Returns a Hash. keys are SimpleDB object IDs and values
+    # are the object attributes. 
+    def self.select(fields={})
+      squery = Rudy::AWS::SDB.generate_select @@domain, fields
+      Rudy::Huxtable.ld "SELECT: #{squery}" if Rudy.debug?
+      @@rsdb.select squery
+    end
+
+    
+    # Generates a default criteria for all metadata based on
+    # region, zone, environment, and role. If a position has
+    # been specified in the globals it will also be included.
+    # * +rtype+ is the record type. One of: m, disk, or back.
+    # * +fields+ replaces and adds values to this criteria
+    # * +less+ removes keys from the default criteria. 
+    #
+    # Returns a Hash. 
+    def self.build_criteria(rtype, fields={}, less=[])
+      fields ||= {}
+      fields[:rtype] = rtype
+      fields[:position] = @@global.position unless @@global.position.nil?
+      names = Rudy::Metadata::COMMON_FIELDS
+      values = names.collect { |n| @@global.send(n.to_sym) }
+      mixer = names.zip(values).flatten
+      criteria = Hash[*mixer].merge(fields)
+      criteria.reject! { |n,v| less.member?(n) }
+      Rudy::Huxtable.ld "CRITERIA: #{criteria.inspect}"
+      criteria
+    end
+    
+    module ClassMethods
+      extend self
+      extend Rudy::Huxtable
+      
+      # TODO: MOVE TO Rudy:Disks etc...
+      def list(fields={}, less=[], &block)
+        fields = Rudy::Metadata.build_criteria self::RTYPE, fields, less
+        records_raw, records = Rudy::Metadata.select(fields), []
+        return nil if records_raw.nil? || records_raw.empty?
+        records_raw.each_pair do |p, r|
+          obj = self.from_hash r
+          records << obj
+        end
+        records.sort { |a,b| a.name <=> b.name }
+      end
+
+      def list_as_hash(fields={}, less=[], &block)
+        fields = Rudy::Metadata.build_criteria self::RTYPE, fields, less
+        records_raw, records = Rudy::Metadata.select(fields), {}
+        return nil if records_raw.nil? || records_raw.empty?
+        records_raw.each_pair do |p, r|
+          obj = self.from_hash r
+          records[p] = obj
+        end
+        records
       end
-      names.zip(values) + more
+      
+      def any?(fields={}, less=[])
+        !list(fields, less).nil?
+      end
+      
     end
     
-    def to_query(more=[], less=[], local={})
-      Rudy::AWS::SDB.generate_query build_criteria(more, less, local)
+    # All classes which include Rudy::Metadata must reimplement
+    # the method stubs in this module. These methods only raise
+    # exceptions. 
+    module InstanceMethods
+      class << self
+        def valid?; raise "implement valid?"; end
+        def name; raise "implement name"; end
+        def postprocess; raise "implement postprocess"; end
+      end 
     end
-  
-    def to_select(more=[], less=[], local={})
-      Rudy::AWS::SDB.generate_select ['*'], @sdb_domain, build_criteria(more, less, local)
+    
+    def self.included(obj)
+      obj.send :include, Rudy::Metadata::InstanceMethods
+      
+      # Add common storable fields. 
+      [COMMON_FIELDS, :position].flatten.each do |n|
+        obj.field n
+      end
+      
+    end
+    
+    def initialize(rtype, opts={})
+      @rtype = rtype
+      @position = position || @@global.position || '01'
+      
+      COMMON_FIELDS.each { |n|
+        ld "SETTING: #{n}: #{@@global.send(n)}" if @@global.verbose > 3
+        instance_variable_set("@#{n}", @@global.send(n))
+      }
+      
+      opts.each_pair do |n,v|
+        raise "Unknown attribute for #{self.class}: #{n}" if !self.has_field? n
+        next if v.nil?
+        ld "RESETTING: #{n}: #{v}" if @@global.verbose > 3
+        self.send("#{n}=", v)
+      end
+      
+    end
+    
+    def name(*other)
+      parts = [@rtype, @zone, @environment, @role, @position, *other].flatten
+      parts.join Rudy::DELIM
+    end
+    
+    def save(replace=false)
+      raise DuplicateRecord, self.name unless replace || !self.exists?
+      Rudy::Metadata.put self.name, self.to_hash, replace
+      true
+    end
+    
+    def destroy(force=false)
+      raise UnknownObject, self.name unless self.exists?
+      Rudy::Metadata.destroy self.name
+      true
+    end
+    
+    def descriptors(*additional)
+      criteria = {
+        :region => @region,  :zone => @zone,
+        :environment => @environment, :role => @role
+      }
+      additional.each do |att|
+        criteria[att] = self.send(att)
+      end
+      ld "DESCRIPTORS: #{criteria.inspect} (#{additional})"
+      criteria
+    end
+    
+    # Refresh the metadata object from SimpleDB. If the record doesn't 
+    # exist it will raise an UnknownObject error 
+    def refresh!
+      raise UnknownObject, self.name unless self.exists?
+      h = Rudy::Metadata.get self.name
+      return false if h.nil? || h.empty?
+      obj = self.from_hash(h)
+      obj.postprocess
+      obj
+    end
+    
+    # Compares the names between two Rudy::Metadata objects. 
+    def ==(other)
+      return false unless other === self.class
+      self.name == other.name
+    end
+    
+    # Is there an object in SimpleDB where the key == self.name
+    def exists?
+      !Rudy::Metadata.get(self.name).nil?
     end
     
   end
 end
 
-Rudy::Utils.require_glob(RUDY_LIB, 'rudy', 'metadata', 'objectbase.rb')
 Rudy::Utils.require_glob(RUDY_LIB, 'rudy', 'metadata', '*.rb')
+