solutious-rudy 0.4.0

data/lib/rudy/command/volumes.rb

@@ -0,0 +1,66 @@
+
+
+module Rudy
+  module Command
+    class Volumes < Rudy::Command::Base
+      
+      def destroy_volumes_valid?        
+        id = @argv.first
+        raise "No volume ID provided" unless id
+        raise "I will not help you destroy production!" if @global.environment == "prod"
+        raise "The volume #{id} doesn't exist!" unless @ec2.volumes.exists?(id)
+        exit unless are_you_sure? 4
+        true
+      end
+        
+      def destroy_volumes
+        id = @argv.first
+        disk = Rudy::MetaData::Disk.find_from_volume(@sdb, id)
+
+        begin
+          puts "Detaching #{id}"
+          @ec2.volumes.detach(id)
+          sleep 3
+        
+          puts "Destroying #{id}"
+          @ec2.volumes.destroy(id)
+          
+          if disk
+            puts "Deleteing metadata for #{disk.name}"
+            Rudy::MetaData::Disk.destroy(@sdb, disk)
+          end
+          
+        rescue => ex
+          puts "Error while detaching volume #{id}: #{ex.message}"
+        end
+        
+        
+      end
+      
+      def volumes
+        machines = {}
+        volumes = @ec2.volumes.list
+        @ec2.volumes.list.each do |volume|
+          machine = @ec2.instances.get(volume[:aws_instance_id])
+          machines[ volume[:aws_instance_id] ] ||= {
+            :machine => machine,
+            :volumes => []
+          }
+          machines[ volume[:aws_instance_id] ][:volumes] << volume
+        end
+        
+        machines.each_pair do |instance_id, hash|
+          machine = hash[:machine]
+          env = (machine[:aws_groups]) ? machine[:aws_groups] : "Not-attached"
+          puts "Environment: #{env}"
+          hash[:volumes].each do |vol|
+            disk = Rudy::MetaData::Disk.find_from_volume(@sdb, vol[:aws_id])
+            print_volume(vol, disk)
+          end
+        end
+      end
+      
+    end
+  end
+end
+

data/lib/rudy/config.rb

@@ -0,0 +1,93 @@
+
+
+module Rudy
+  require 'caesars'
+
+  class AWSInfo < Caesars
+    def valid?
+      (!account.nil? && !accesskey.nil? && !secretkey.nil?) &&
+      (!account.empty? && !accesskey.empty? && !secretkey.empty?) 
+    end
+  end
+
+  class Defaults < Caesars
+  end
+  
+  
+  class Routines < Caesars
+    
+    def create(*args, &b)
+      hash_handler(:create, *args, &b)
+    end
+    def destroy(*args, &b)
+      hash_handler(:destroy, *args, &b)
+    end
+    def restore(*args, &b)
+      hash_handler(:restore, *args, &b)
+    end
+    def mount(*args, &b)
+      hash_handler(:mount, *args, &b)
+    end
+    
+    #
+    # Force the specified keyword to always be treated as a hash. 
+    # Example:
+    #
+    #     startup do
+    #       disks do
+    #         create "/path/2"         # Available as hash: [action][disks][create][/path/2] == {}
+    #         create "/path/4" do      # Available as hash: [action][disks][create][/path/4] == {size => 14}
+    #           size 14
+    #         end
+    #       end
+    #     end
+    #
+    def hash_handler(caesars_meth, *args, &b)
+      # TODO: Move to caesars
+      return @caesars_properties[caesars_meth] if @caesars_properties.has_key?(caesars_meth) && args.empty? && b.nil?
+      return nil if args.empty? && b.nil?
+      return method_missing(caesars_meth, *args, &b) if args.empty?
+      
+      caesars_name = args.shift
+      
+      prev = @caesars_pointer
+      @caesars_pointer[caesars_meth] ||= Caesars::Hash.new
+      hash = Caesars::Hash.new
+      @caesars_pointer = hash
+      b.call if b
+      @caesars_pointer = prev
+      @caesars_pointer[caesars_meth][caesars_name] = hash 
+      @caesars_pointer = prev
+    end
+  end
+  
+  class Machines < Caesars
+  end
+  
+  class Config < Caesars::Config
+    dsl Rudy::AWSInfo::DSL
+    dsl Rudy::Defaults::DSL
+    dsl Rudy::Routines::DSL
+    dsl Rudy::Machines::DSL
+    
+    def postprocess
+      # TODO: give caesar attributes setter methods
+      self.awsinfo.cert &&= File.expand_path(self.awsinfo.cert)
+      self.awsinfo.privatekey &&= File.expand_path(self.awsinfo.privatekey)
+      
+    end
+    
+    def look_and_load
+      cwd = Dir.pwd
+      # Rudy looks for configs in all these locations
+      @paths += Dir.glob(File.join('/etc', 'rudy', '*.rb')) || []
+      @paths += Dir.glob(File.join(cwd, 'config', 'rudy', '*.rb')) || []
+      @paths += Dir.glob(File.join(cwd, '.rudy', '*.rb')) || []
+      refresh
+    end
+    
+    
+  end
+end
+
+

data/lib/rudy/metadata.rb

@@ -0,0 +1,26 @@
+
+require 'aws_sdb'
+
+module Rudy
+  module MetaData
+    attr_accessor :sdb
+    attr_accessor :ec2
+    
+    def initalize(sdb, ec2)
+      @sdb = sdb
+      @ec2 = ec2
+    end
+    
+  end
+  
+  module MetaData
+    
+    module ObjectBase
+      extend self
+      
+
+      
+    end
+    
+  end
+end

data/lib/rudy/metadata/backup.rb

@@ -0,0 +1,160 @@
+
+require 'date'
+
+module Rudy
+  module MetaData
+    class Backup < Storable
+      include Rudy::MetaData::ObjectBase
+      extend Rudy::MetaData::ObjectBase
+        
+      @@rtype = "back"
+      
+      field :rtype
+      field :awsid
+      
+      field :region
+      field :zone
+      field :environment
+      field :role
+      field :position
+      field :path
+      
+      field :date
+      field :time
+      field :second
+      
+      field :unixtime => Integer
+      
+      field :size
+      field :volume
+      
+      def initialize
+        @zone = DEFAULT_ZONE
+        @region = DEFAULT_REGION
+        @position = "01"
+        @rtype = @@rtype
+      end
+      
+      def rtype
+        @@rtype
+      end
+      
+      def self.rtype
+        @@rtype
+      end
+      
+      
+      def name
+        time = Time.at(@unixtime)
+        Backup.generate_name(@zone, @environment, @role, @position, @path, time)
+      end
+      
+      def valid?
+        @zone && @environment && @role && @position && @path && @date && @time && @second
+      end
+      
+      def time_stamp
+        #return [@date, @time] if @date && @time
+        now = Time.now.utc
+        datetime = Backup.format_timestamp(now).split(RUDY_DELIM)
+        @unixtime = now.to_i
+        @date, @time, @second = datetime
+      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_query(more=[], remove=[])
+        criteria = [:rtype, :zone, :environment, :role, :position, :path, :date, :time, :second, *more]
+        criteria -= [*remove].flatten
+        query = "select * from #{RUDY_DOMAIN} where unixtime > '0' "
+        criteria.each do |n|
+          query << "and #{n} = '#{self.send(n.to_sym)}'"
+        end
+        query << " order by unixtime desc"
+      end
+      
+      def to_s
+        str = ""
+        field_names.each do |key|
+          str << sprintf(" %22s: %s#{$/}", key, self.send(key.to_sym))
+        end
+        str
+       end
+      
+      def disk
+        Disk.generate_name(@zone, @environment, @role, @position, @path)
+      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
+      
+      # Times are converted to UTC
+      # back-us-east-1b-stage-app-01-rilli-app-20090224-1813-36
+      def Backup.generate_name(zon, env, rol, pos, pat, dat, sep=File::SEPARATOR)
+        raise "The date you provided is not a Time object" unless dat.is_a?(Time)
+        pos = pos.to_s.rjust 2, '0'
+        dirs = pat.split sep if pat
+        dirs.shift while dirs && (dirs[0].nil? || dirs[0].empty?)
+        timestamp = Backup.format_timestamp(dat.utc)
+        [@@rtype, zon, env, rol, pos, dirs, timestamp].flatten.join(RUDY_DELIM)
+      end
+      
+
+      def Backup.for_disk(sdb, disk, max=50)
+        list = Backup.list(sdb, disk.zone, disk.environment, disk.role, disk.position, disk.path) || []
+        list[0..(max-1)]
+      end
+      
+      def Backup.get(sdb, name)
+        object = sdb.get_attributes(RUDY_DOMAIN, name)
+        raise "Object #{name} does not exist!" unless object.has_key?(:attributes) && !object[:attributes].empty?
+        self.from_hash(object[:attributes])
+      end
+      
+      def Backup.save(sdb, obj, replace = :replace)
+        sdb.store(RUDY_DOMAIN, obj.name, obj.to_hash, replace)
+      end
+      
+      def Backup.list(sdb, zon, env=nil, rol=nil, pos=nil, path=nil, date=nil)
+        query = "select * from #{RUDY_DOMAIN} where "
+        query << "rtype = '#{rtype}' "
+        query << " and zone = '#{zon}'" if zon
+        query << " and environment = '#{env}'" if env
+        query << " and role = '#{rol}'" if rol
+        query << " and position = '#{pos}'" if pos
+        query << " and path = '#{path}'" if path
+        query << " and date = '#{date}'" if date
+        query << " and unixtime != '0' order by unixtime desc"
+        list = []
+        sdb.select(query).each do |obj|
+          list << self.from_hash(obj)
+        end
+        list
+      end
+      
+      def Backup.destroy(sdb, name)
+        back = Backup.get(sdb, name) # get raises an exception if the disk doesn't exist
+        sdb.destroy(RUDY_DOMAIN, name)
+        true # wtf: RightAws::SimpleDB doesn't tell us whether it succeeds. We'll assume!
+      end
+      
+
+      
+      def Backup.is_defined?(sdb, backup)
+        query = backup.to_query()
+        puts query
+        !sdb.select(query).empty?
+      end
+      
+    end
+  end
+end
+

data/lib/rudy/metadata/disk.rb

@@ -0,0 +1,138 @@
+
+
+module Rudy
+  
+  module MetaData
+    class Disk < Storable
+      
+      @@rtype = 'disk'
+      
+        # This is a flag used internally to specify that a volume has been
+        # created for this disk, but not formated. 
+      attr_accessor :raw_volume
+      
+      field :rtype
+      field :awsid
+      
+      field :environment
+      field :role
+      field :path
+      field :position
+      
+      field :zone
+      field :region
+      field :device
+      #field :backups => Array
+      field :size
+      
+      def initialize
+        @backups = []
+        @rtype = @@rtype.to_s
+        @raw_volume = false
+      end
+      
+      def rtype
+        @@rtype.to_s
+      end
+      
+      def rtype=(val)
+      end
+      
+      def name
+        Disk.generate_name(@zone, @environment, @role, @position, @path)
+      end
+      
+      def valid?
+        @zone && @environment && @role && @position && @path && @size && @device
+      end
+      
+      def to_query(more=[], remove=[])
+        criteria = [:rtype, :zone, :environment, :role, :position, :path, *more]
+        criteria -= [*remove].flatten
+        query = []
+        criteria.each do |n|
+          query << "['#{n}' = '#{self.send(n.to_sym)}'] "
+        end
+        query.join(" intersection ")
+      end
+      
+      def to_s
+        str = ""
+        field_names.each do |key|
+          str << sprintf(" %22s: %s#{$/}", key, self.send(key.to_sym))
+        end
+        str
+       end
+       
+      def Disk.generate_name(zon, env, rol, pos, pat, sep=File::SEPARATOR)
+        pos = pos.to_s.rjust 2, '0'
+        dirs = pat.split sep if pat
+        dirs.shift while dirs && (dirs[0].nil? || dirs[0].empty?)
+        ["disk", zon, env, rol, pos, *dirs].join(RUDY_DELIM)
+      end
+      
+      def Disk.get(sdb, name)
+        disk = sdb.get_attributes(RUDY_DOMAIN, name)
+        return nil unless disk && disk.has_key?(:attributes) && !disk[:attributes].empty?
+#        raise "Disk #{name} does not exist!" unless 
+        Rudy::MetaData::Disk.from_hash(disk[:attributes])
+      end
+      
+      def Disk.destroy(sdb, disk)
+        disk = Disk.get(sdb, disk) if disk.is_a?(String) # get raises an exception if the disk doesn't exist
+        sdb.destroy(RUDY_DOMAIN, disk.name)
+        true # wtf: RightAws::SimpleDB doesn't tell us whether it succeeds. We'll assume!
+      end
+      
+      def Disk.save(sdb, disk)
+        sdb.store(RUDY_DOMAIN, disk.name, disk.to_hash, :replace)
+      end
+      
+      def Disk.is_defined?(sdb, disk)
+        # We don't care about the path, but we do care about the device
+        # which is not part of the disk's name. 
+        query = disk.to_query(:device, :path)
+        !sdb.query_with_attributes(RUDY_DOMAIN, query).empty?
+      end
+      
+      def Disk.find_from_volume(sdb, vol_id)
+        query = "['awsid' = '#{vol_id}']"
+        res = sdb.query_with_attributes(RUDY_DOMAIN, query)
+        if res.empty?
+          nil
+        else
+          disk = Rudy::MetaData::Disk.from_hash(res.values.first)
+        end
+      end
+      
+      
+      def Disk.find_from_path(sdb, path)
+        query = "['path' = '#{path}']"
+        res = sdb.query_with_attributes(RUDY_DOMAIN, query)
+        if res.empty?
+          nil
+        else
+          disk = Rudy::MetaData::Disk.from_hash(res.values.first)
+        end
+      end
+      
+      def Disk.list(sdb, zon, env=nil, rol=nil, pos=nil)
+        query = ''
+        query << "['rtype' = '#{@@rtype}']" if zon
+        query << " intersection ['zone' = '#{zon}']" if zon
+        query << " intersection ['environment' = '#{env}']" if env
+        query << " intersection ['role' = '#{rol}']" if rol
+        query << " intersection ['position' = '#{pos}']" if pos
+        
+        list = []
+        sdb.query_with_attributes(RUDY_DOMAIN, query).each_pair do |name, hash|
+          #puts "DISK: #{hash.to_yaml}"
+          list << Rudy::MetaData::Disk.from_hash(hash)
+        end
+        list
+      end
+    end
+    
+  end
+
+end