solutious-rudy 0.7.3 → 0.7.4

data/lib/rudy/config.rb

@@ -85,27 +85,24 @@ module Rudy
       unless File.exists?(Rudy::CONFIG_FILE)
         puts "Creating #{Rudy::CONFIG_FILE}"
         rudy_config = Rudy::Utils.without_indent %Q{
-          # Amazon Web Services 
-          # Account access indentifiers.
-          accounts do
-            aws do
+          accounts do                           # Account Access Indentifiers
+            aws do                              # amazon web services 
               name "Rudy Default"
               accountnum ""
               accesskey ""
               secretkey ""
-              privatekey "~/path/2/pk-xxxx.pem"
+              privatekey "~/path/2/pk-xxxx.pem" 
               cert "~/path/2/cert-xxxx.pem"
             end
           end
           
-          # Global Defaults
-          defaults do
+          defaults do                          # Global Defaults
             region :"us-east-1" 
             zone :"us-east-1b"
             environment :stage
             role :app
-            position "01"
-            user ENV['USER'].to_sym
+            user Rudy.sysinfo.user.to_sym
+            color false                        # set to true for terminal colors
           end
         }
         Rudy::Utils.write_to_file(Rudy::CONFIG_FILE, rudy_config, 'w', 0600)

data/lib/rudy/config/objects.rb

@@ -117,7 +117,11 @@ class Rudy::Config
     forced_hash :create
     forced_hash :destroy
     forced_hash :restore
+    forced_hash :umount
+    forced_hash :unmount
     forced_hash :mount
+    forced_hash :snapshot
+    forced_hash :restore
     
     # Script blocks
     forced_hash :before        

data/lib/rudy/global.rb

@@ -85,23 +85,22 @@ module Rudy
       postprocess
     end
     
-    
+    def to_s(*args)
+      super()
+    end
+      
   private 
     
     
     def postprocess
       apply_environment_variables
       apply_system_defaults
-      
       @nocolor = !@color unless @color.nil?
       @cert &&= File.expand_path(@cert)
       @privatekey &&= File.expand_path(@privatekey)
       @position &&= @position.to_s.rjust(2, '0')  
       @format &&= @format.to_sym rescue nil
-      
-      @nocolor ? String.disable_color : String.enable_color
       @quiet ? Rudy.enable_quiet : Rudy.disable_quiet
-      @yes ? Annoy.enable_skip : Annoy.disable_skip
     end
     
     def apply_environment_variables

data/lib/rudy/huxtable.rb

@@ -12,7 +12,9 @@ module Rudy
   #       include Rudy::Huxtable
   #
   #       def print_config
-  #         p self.config.defaults
+  #         p @@config.defaults  # {:nocolor => true, ...}
+  #         p @@global.verbose   # => 1
+  #         p @@logger.class     # => StringIO
   #       end
   #
   #     end
@@ -105,15 +107,15 @@ module Rudy
     # If there's a private key path in the config this will return
     # the basename (it's assumed the Amazon KeyPair has the same
     # name as the file). Otherwise this returns the Rudy style
-    # name: <tt>key-ENV-ROLE-USER</tt>. Or if this the user is 
-    # root: <tt>key-ENV-ROLE</tt>
+    # name: <tt>key-ZONE-ENV-ROLE-USER</tt>. Or if this the user is 
+    # root: <tt>key-ZONE-ENV-ROLE</tt>
     def user_keypairname(user)
       kp = user_keypairpath(user)
       if kp
         kp = Huxtable.keypair_path_to_name(kp)
       else
         n = (user.to_s == 'root') ? '' : "-#{user}"
-        "key-%s%s" % [current_machine_group, n]
+        "key-%s-%s%s" % [@@global.zone, current_machine_group, n]
       end    
     end
     def root_keypairname
@@ -136,7 +138,7 @@ module Rudy
       # These are used as the root SSH keys. If we can find a user defined key, we'll 
       # check the config path for a generated one. 
       if !path && name.to_s == 'root'
-        path = File.join(self.config_dirname, "key-#{current_machine_group}")
+        path = File.join(self.config_dirname, "key-#{@@global.zone}-#{current_machine_group}")
       end
       path = File.expand_path(path) if path && File.exists?(path)
       path
@@ -257,8 +259,8 @@ module Rudy
     # Return a hash:
     #
     #      :after: 
-    #      - :root: pwd
-    #      - :rudy: pwd
+    #      - :root: !ruby/object:Proc {}
+    #      - :rudy: !ruby/object:Proc {}
     #      :disks: 
     #        :create: 
     #          /rudy/example1: 
@@ -268,12 +270,18 @@ module Rudy
     #            :device: /dev/sdm
     #            :size: 1
     #      
+    # NOTE: dashes in +action+ are converted to underscores. We do this
+    # because routine names are defined by method names and valid
+    # method names don't use dashes. This way, we can use a dash on the
+    # command-line which looks nicer (underscore still works of course). 
     def fetch_routine_config(action)
       raise "No action specified" unless action
       raise NoConfig unless @@config
       raise NoRoutinesConfig unless @@config.routines
       raise NoGlobal unless @@global
       
+      action = action.to_s.tr('-', '_')
+      
       zon, env, rol = @@global.zone, @@global.environment, @@global.role
       
       disk_defs = fetch_machine_param(:disks) || {}
@@ -288,7 +296,10 @@ module Rudy
       return routine unless routine.has_key?(:disks)
       
       routine.disks.each_pair do |raction,disks|
-
+        unless disks.kind_of?(Hash)
+          @@logger.puts "#{raction} is not defined. Check your #{action} routines config.".color(:red)
+          next
+        end
         disks.each_pair do |path, props|
           unless disk_defs.has_key?(path)
             @@logger.puts "#{path} is not defined. Check your #{action} machines config.".color(:red)
@@ -304,6 +315,10 @@ module Rudy
       routine
     end
     
+    # Is +action+ a valid routine for the current machine group?
+    def valid_routine?(action)
+      !fetch_routine_config(action).nil?
+    end
     
     def fetch_machine_param(parameter)
       raise "No parameter specified" unless parameter

data/lib/rudy/machines.rb

@@ -168,8 +168,7 @@ module Rudy
     end
       
   end
-  
-  
+
   
   class Machines
     include Rudy::MetaData
@@ -267,8 +266,16 @@ module Rudy
       # 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,92 +1,4 @@
 
-
-module Rudy
-  module MetaData
-    module ObjectBase
-      include Rudy::Huxtable
-      
-      def initialize(*args)
-        a, s, r = @@global.accesskey, @@global.secretkey, @@global.region
-        @sdb = Rudy::AWS::SDB.new(a, s, r)
-        @ec2inst = Rudy::AWS::EC2::Instances.new(a, s, r)
-        @rvol = Rudy::AWS::EC2::Volumes.new(a, s, r)
-        @radd = Rudy::AWS::EC2::Addresses.new(a, s, r)
-        init(*args)
-      end
-      
-      def init(*args); raise "Must override init"; end
-      
-      def valid?; raise "#{self.class} must override 'valid?'"; end
-      
-      def to_query(more=[], less=[])
-        Rudy::AWS::SDB.generate_query build_criteria(more, less)
-      end
-    
-      def to_select(more=[], less=[])
-        Rudy::AWS::SDB.generate_select ['*'], Rudy::DOMAIN, build_criteria(more, less)
-      end
-      
-      def name(identifier, zon, env, rol, pos, *other)
-        pos = pos.to_s.rjust 2, '0'
-        [identifier, zon, env, rol, pos, *other].flatten.compact.join(Rudy::DELIM)
-      end
-      
-      def save(replace=true)
-        replace = true if replace.nil?
-        @sdb ||= Rudy::AWS::SDB.new(@@global.accesskey, @@global.secretkey, @@global.region)
-        @sdb.put(Rudy::DOMAIN, name, self.to_hash, replace) # Always returns nil
-        true
-      end
-    
-      def destroy
-        @sdb ||= Rudy::AWS::SDB.new(@@global.accesskey, @@global.secretkey, @@global.region)
-        @sdb.destroy(Rudy::DOMAIN, name)
-        true
-      end
-    
-      def refresh
-        @sdb ||= Rudy::AWS::SDB.new(@@global.accesskey, @@global.secretkey, @@global.region)
-        h = @sdb.get(Rudy::DOMAIN, name) || {}
-        from_hash(h)
-      end
-      
-      def ==(other)
-        return false unless other.is_a?(self.class)
-        self.name == other.name
-      end
-      
-      def to_s
-        str = ""
-        field_names.each do |key|
-          str << sprintf(" %22s: %s#{$/}", key, self.send(key.to_sym))
-        end
-        str
-      end
-
-      
-    protected
-    
-      # Builds a zipped Array from a list of criteria.
-      # The list of criteria is made up of metadata object attributes. 
-      # The list is constructed by taking the adding +more+, and
-      # subtracting +less+ from <tt>:rtype, :region, :zone, :environment, :role, :position</tt>
-      # 
-      # Returns [[:rtype, value], [:zone, value], ...]
-      def build_criteria(more=[], less=[])
-        criteria = [:rtype, :region, :zone, :environment, :role, :position, *more].compact
-        criteria -= [*less].flatten.uniq.compact
-        values = criteria.collect do |n|
-          self.send(n.to_sym)
-        end
-        criteria.zip(values)
-      end
-      
-    end
-  end
-end
-
-
-
 module Rudy
   module MetaData
     include Rudy::Huxtable
@@ -113,25 +25,27 @@ module Rudy
   
     # Returns a generic zipped Array of metadata
     # (There is region, zone, environment, role, but no rtype)
-    def build_criteria(more=[], less=[])
+    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|
-        @@global.send(n.to_sym)
+        local[n.to_sym] || @@global.send(n.to_sym)
       end
       names.zip(values) + more
     end
     
-    def to_query(more=[], less=[])
-      Rudy::AWS::SDB.generate_query build_criteria(more, less)
+    def to_query(more=[], less=[], local={})
+      Rudy::AWS::SDB.generate_query build_criteria(more, less, local)
     end
   
-    def to_select(more=[], less=[])
-      Rudy::AWS::SDB.generate_select ['*'], Rudy::DOMAIN, build_criteria(more, less)
+    def to_select(more=[], less=[], local={})
+      Rudy::AWS::SDB.generate_select ['*'], Rudy::DOMAIN, build_criteria(more, less, local)
     end
     
   end
 end
 
+Rudy::Utils.require_glob(RUDY_LIB, 'rudy', 'metadata', 'objectbase.rb')
+Rudy::Utils.require_glob(RUDY_LIB, 'rudy', 'metadata', '*.rb')

data/lib/rudy/metadata/backup.rb

@@ -0,0 +1,113 @@
+module Rudy::MetaData
+    class Backup < Storable
+    include Rudy::MetaData::ObjectBase
+    
+    field :rtype
+    field :awsid
+    
+    field :region
+    field :zone
+    field :environment
+    field :role
+    field :position
+    field :path
+    
+    field :date
+    field :time
+    field :second
+    
+    field :created => Integer
+    
+    field :size
+    field :fstype
+    field :volume
+    
+    require 'date'
+
+    
+    def init(volume=nil, path=nil, position=nil)
+      # NOTE: Arguments must be optional or Storable will raise an exception!
+      @volume= volume
+      @path = path
+      @rtype = 'back'
+      @region = @@global.region
+      @zone = @@global.zone
+      @environment = @@global.environment
+      @role = @@global.role
+      @position = position || @@global.position
+      
+      
+      now = Time.now.utc
+      datetime = Backup.format_timestamp(now).split(Rudy::DELIM)
+      @created = now.to_i
+      @date, @time, @second = datetime
+      
+      postprocess
+    end
+    
+
+    def name
+      sep=File::SEPARATOR
+      dirs = @path.split sep if @path && !@path.empty?
+      dirs.shift while dirs && (dirs[0].nil? || dirs[0].empty?)
+      args = [dirs, @date, @time, @second].flatten
+      super("back", @zone, @environment, @role, @position, *args)
+    end
+    
+    def nice_time
+      return "" unless @date && @time
+      t = @date.scan(/(\d\d\d\d)(\d\d)(\d\d)/).join('-')
+      t << " " << @time.scan(/(\d\d)(\d\d)/).join(':')
+      t
+    end
+    
+    def to_s(*args)
+      str = ""
+      field_names.each do |key|
+        str << sprintf(" %22s: %s#{$/}", key, self.send(key.to_sym))
+      end
+      str
+     end
+    
+    def disk
+      rdisk = Rudy::Disks.new
+      disk = Rudy::MetaData::Disk.new(@path, nil, nil, @position)
+      disk.region, disk.zone = @region, @zone
+      disk.environment, disk.role, disk.position = @environment, @role, @position
+      diskobj = rdisk.get(disk.name)
+      diskobj || disk 
+    end
+    
+    def create(volume=nil)
+      volume ||= @volume
+      vol = @rsnap.create(volume) 
+      @awsid = vol.awsid
+      self.save
+      self
+    end
+    
+    # 20090224-1813-36
+    def Backup.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
+    end
+    
+    def to_query(more=[], less=[])
+      query = super([:path, :date, :time, :second, *more], less)
+    end
+
+    def to_select(more=[], less=[])
+      query = super([:path, :date, :time, :second, *more], less) 
+    end
+
+    # Does this disk have enough info to be saved or used?
+    # The test is based on the same criteria for building
+    # SimpleDB queries. 
+    def valid?
+      criteria = build_criteria([:path]).flatten
+      criteria.size == criteria.compact.size
+    end
+    
+  end
+end
+

data/lib/rudy/metadata/backups.rb

@@ -0,0 +1,65 @@
+
+
+module Rudy
+class Backups
+  include Rudy::MetaData
+  
+  def init
+    now = Time.now.utc
+    datetime = Rudy::MetaData::Backup.format_timestamp(now).split(Rudy::DELIM)
+    @created = now.to_i
+    @date, @time, @second = datetime
+  end
+  
+  #def create(&each_mach)
+    
+  #end
+
+
+  def destroy(&each_mach)
+    list do |backup|
+      puts "Destroying #{backup.name}"
+      backup.destroy
+    end
+  end
+
+  def list(more=[], less=[], local={}, &each_backup)
+    backups = list_as_hash(more, less, local, &each_backup)
+    backups &&= backups.values
+    backups
+  end
+
+  def list_as_hash(more=[], less=[], local={}, &each_backup)
+    query = to_select([:rtype, 'back'], less, local)
+    list = @sdb.select(query) || {}
+    backups = {}
+    list.each_pair do |n,d|
+      backups[n] = Rudy::MetaData::Backup.from_hash(d)
+    end
+    backups.each_pair { |n,backup| each_backup.call(backup) } if each_backup
+    backups = nil if backups.empty?
+    backups
+  end
+
+  def get(rname=nil)
+    dhash = @sdb.get(Rudy::DOMAIN, rname)
+    return nil if dhash.nil? || dhash.empty?
+    d = Rudy::MetaData::Backup.from_hash(dhash)
+    d.update if d
+    d
+  end
+
+
+  def running?
+    !list.nil?
+    # TODO: add logic that checks whether the instances are running.
+  end
+
+  def to_select(*args)
+    query = super(*args)
+    query << " and created != '0' order by created desc"
+  end
+  
+end
+end
+