solutious-rudy 0.4.0 → 0.5.0

data/lib/rudy/config/objects.rb

@@ -0,0 +1,67 @@
+
+
+class Rudy::Config
+  class Machines < Caesars
+  end
+  
+  
+  class Accounts < Caesars
+    def valid?
+      (!aws.nil? && !aws.accesskey.nil? && !aws.secretkey.nil?) &&
+      (!aws.account.empty? && !aws.accesskey.empty? && !aws.secretkey.empty?) 
+    end
+  end
+
+  class Defaults < Caesars
+  end
+
+  class Networks < 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
+end

data/lib/rudy/huxtable.rb

@@ -0,0 +1,253 @@
+
+
+
+module Rudy
+  module Huxtable
+    include Rudy::AWS
+    
+    @@debug = false
+
+    attr_accessor :config
+    attr_accessor :global
+    attr_accessor :logger
+    
+     # An instance of Rye::Box for the local machine (running Rudy)
+    attr_reader :rbox
+    
+    def initialize(opts={})
+      opts = { :config => nil, :logger => STDERR, :global => OpenStruct.new }.merge(opts)
+      
+      # Set instance variables
+      opts.each_pair { |n,v| self.send("#{n}=", v) if self.respond_to?("#{n}=") }
+      
+      unless @config
+        @config = Rudy::Config.new
+        @config.look_and_load(@global.config)
+      end
+      
+      init_globals
+      
+      @rbox = Rye::Box.new('localhost')
+      
+      raise Rudy::NoConfig unless has_keys?
+      Rudy::AWS.set_access_identifiers(@global.accesskey, @global.secretkey, @logger)
+
+    end
+    
+    
+    
+    def init_globals
+      @global.verbose ||= 0
+      
+      @global.cert = File.expand_path(@global.cert || '')
+      @global.privatekey = File.expand_path(@global.privatekey || '')
+      
+      # ATROCIOUS!
+      
+      if @config.defaults
+        @global.region ||= @config.defaults.region
+        @global.zone ||= @config.defaults.zone
+        @global.environment ||= @config.defaults.environment
+        @global.role ||= @config.defaults.role 
+        @global.position ||= @config.defaults.position
+        @global.user ||= @config.defaults.user 
+        @global.nocolor = @config.defaults.nocolor
+        @global.quiet = @config.defaults.quiet
+      end
+            
+      @global.region ||= DEFAULT_REGION
+      @global.zone ||= DEFAULT_ZONE
+      @global.environment ||= DEFAULT_ENVIRONMENT
+      @global.role ||= DEFAULT_ROLE
+      @global.position ||= DEFAULT_POSITION
+      @global.user ||= DEFAULT_USER
+      @global.nocolor = false
+      @global.quiet = false
+      
+      @global.position &&= @global.position.to_s.rjust(2, '0')
+      
+      if @config.accounts && @config.accounts.aws
+        @global.accesskey ||= @config.accounts.aws.accesskey 
+        @global.secretkey ||= @config.accounts.aws.secretkey 
+        @global.account ||= @config.accounts.aws.accountnum
+        
+        @global.cert ||= @config.accounts.aws.cert
+        @global.privatekey ||= @config.accounts.aws.privatekey
+      end
+      
+      @global.accesskey ||= ENV['AWS_ACCESS_KEY']
+      @global.secretkey ||= ENV['AWS_SECRET_KEY'] || ENV['AWS_SECRET_ACCESS_KEY']
+      @global.account ||= ENV['AWS_ACCOUNT_NUMBER']
+      
+      @global.cert ||= ENV['EC2_CERT']
+      @global.privatekey ||= ENV['EC2_PRIVATE_KEY']
+      
+      @global.local_user = ENV['USER'] || :rudy
+      @global.local_hostname = Socket.gethostname || :localhost
+      
+      
+      String.disable_color if @global.nocolor
+      Rudy.enable_quiet if @global.quiet
+    end
+    
+    def debug?; @@debug && @@debug == true; end
+    
+    def check_keys
+      raise "No EC2 .pem keys provided" unless has_pem_keys?
+      raise "No SSH key provided for #{current_user}!" unless has_keypair?
+      raise "No SSH key provided for root!" unless has_keypair?(:root)
+    end
+      
+    def has_pem_keys?
+      (@global.cert       && File.exists?(@global.cert) && 
+       @global.privatekey && File.exists?(@global.privatekey))
+    end
+     
+    def has_keys?
+      (@global.accesskey && !@global.accesskey.empty? && @global.secretkey && !@global.secretkey.empty?)
+    end
+    
+    def config_dirname
+      raise "No config paths defined" unless @config.is_a?(Rudy::Config) && @config.paths.is_a?(Array)
+      base_dir = File.dirname @config.paths.first
+      raise "Config directory doesn't exist #{base_dir}" unless File.exists?(base_dir)
+      base_dir
+    end
+    
+    def has_keypair?(name=nil)
+      kp = user_keypairpath(name)
+      (!kp.nil? && File.exists?(kp))
+    end
+    
+    def user_keypairname(user)
+      kp = user_keypairpath(user)
+      return unless kp
+      KeyPairs.path_to_name(kp)
+    end
+    
+
+    
+    def user_keypairpath(name)
+      raise "No user provided" unless name
+      zon, env, rol = @global.zone, @global.environment, @global.role
+      #Caesars.enable_debug
+      kp = @config.machines.find_deferred(zon, env, rol, [:users, name, :keypair])
+      kp ||= @config.machines.find_deferred(env, rol, [:users, name, :keypair])
+      kp ||= @config.machines.find_deferred(rol, [:users, name, :keypair])
+      
+      # EC2 Keypairs that were created are intended for starting the machine instances. 
+      # 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 !kp && name.to_s == 'root'
+        path = File.join(self.config_dirname, "key-#{current_machine_group}")
+        kp = path if File.exists?(path)
+      end
+      
+      kp &&= File.expand_path(kp)
+      kp
+    end
+
+    def has_root_keypair?
+      path = user_keypairpath(:root)
+      (!path.nil? && !path.empty?)
+    end
+    
+    def current_user
+      @global.user
+    end
+    def current_user_keypairpath
+      user_keypairpath(current_user)
+    end
+    def current_machine_hostname(group=nil)
+      group ||= machine_group
+      find_machine(group)[:dns_name]
+    end
+    
+    def current_machine_group
+      [@global.environment, @global.role].join(RUDY_DELIM)
+    end
+    
+    def current_machine_image
+      zon, env, rol = @global.zone, @global.environment, @global.role
+      ami = @config.machines.find_deferred(zon, env, rol, :ami)
+      ami ||= @config.machines.find_deferred(env, rol, :ami)
+      ami ||= @config.machines.find_deferred(rol, :ami)
+      raise Rudy::NoMachineImage, current_machine_group unless ami
+      ami
+    end
+    
+    def current_machine_address
+      @config.machines.find_deferred(@global.environment, @global.role, :address)
+    end
+    
+    # TODO: fix machine_group to include zone
+    def current_machine_name
+      [@global.zone, current_machine_group, @global.position].join(RUDY_DELIM)
+    end
+
+    
+
+    # +name+ the name of the remote user to use for the remainder of the command
+    # (or until switched again). If no name is provided, the user will be revert
+    # to whatever it was before the previous switch. 
+    # TODO: deprecate
+    def switch_user(name=nil)
+      if name == nil && @switch_user_previous
+        @global.user = @switch_user_previous
+      elsif @global.user != name
+        raise "No root keypair defined for #{name}!" unless has_keypair?(name)
+        @logger.puts "Remote commands will be run as #{name} user"
+        @switch_user_previous = @global.user
+        @global.user = name
+      end
+    end
+    
+    # Returns a hash of info for the requested machine. If the requested machine
+    # is not running, it will raise an exception. 
+    def current_machine
+      find_machine(current_machine_group)
+    end
+      
+    def find_machine(group)
+      machine_list = @ec2.instances.list(group)
+      machine = machine_list.values.first  # NOTE: Only one machine per group, for now...
+      raise "There's no machine running in #{group}" unless machine
+      raise "The primary machine in #{group} is not in a running state" unless machine[:aws_state] == 'running'
+      machine
+    end
+    
+
+    
+    def group_metadata(env=@global.environment, role=@global.role)
+      query = "['environment' = '#{env}'] intersection ['role' = '#{role}']"
+      @sdb.query_with_attributes(RUDY_DOMAIN, query)
+    end
+    
+    # * +opts+
+    # :recursive => false, :preserve => false, :chunk_size => 16384
+    def scp(task, host, user, keypairpath, paths, dest, opts)
+      opts = { 
+        :recursive => false, :preserve => false, :chunk_size => 16384
+      }.merge(opts)
+      
+      Net::SCP.start(host, user, :keys => [keypairpath]) do |scp|
+        paths.each do |path| 
+          prev_path = nil
+          scp.send("#{task}!", path, dest, opts) do |ch, name, sent, total|
+            msg = ((prev_path == name) ? "\r" : "\n") # new line for new file
+            msg << "#{name}: #{sent}/#{total}"  # otherwise, update the same line
+            @logger.print msg
+            @logger.flush        # update the screen every cycle
+            prev_path = name
+          end
+          @logger.puts unless prev_path == path
+        end
+      end
+    end
+    
+    
+    
+  private 
+    
+  end
+end

data/lib/rudy/metadata/backup.rb

@@ -4,10 +4,7 @@ require 'date'
 module Rudy
   module MetaData
     class Backup < Storable
-      include Rudy::MetaData::ObjectBase
-      extend Rudy::MetaData::ObjectBase
-        
-      @@rtype = "back"
+      include Rudy::AWS
       
       field :rtype
       field :awsid
@@ -32,15 +29,12 @@ module Rudy
         @zone = DEFAULT_ZONE
         @region = DEFAULT_REGION
         @position = "01"
-        @rtype = @@rtype
-      end
-      
-      def rtype
-        @@rtype
+        @rtype = Backup.rtype
+        time_stamp # initialize time to right now
       end
       
       def self.rtype
-        @@rtype
+        'back'
       end
       
       
@@ -50,7 +44,8 @@ module Rudy
       end
       
       def valid?
-        @zone && @environment && @role && @position && @path && @date && @time && @second
+        #puts(@zone, @environment, @role, @position, @path, @date, @time, @second)
+        (@zone && @environment && @role && @position && @path && @date && @time && @second)
       end
       
       def time_stamp
@@ -104,54 +99,34 @@ module Rudy
         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)
+        [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)
+      
+      def to_select
+        
       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
+      def save
+        @@sdb.store(RUDY_DOMAIN, name, self.to_hash, :replace) # Always returns nil
+        true
       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!
+      def destroy
+        @@sdb.destroy(RUDY_DOMAIN, name)
+        true
       end
       
-
+      def refresh
+        h = @@sdb.get(RUDY_DOMAIN, name) || {}
+        from_hash(h)
+      end
       
-      def Backup.is_defined?(sdb, backup)
-        query = backup.to_query()
-        puts query
-        !sdb.select(query).empty?
+      def Backup.get(dname)
+        h = @@sdb.get(RUDY_DOMAIN, dname) || {}
+        from_hash(h)
       end
       
     end

data/lib/rudy/metadata/disk.rb

@@ -1,14 +1,12 @@
 
 
 module Rudy
-  
   module MetaData
     class Disk < Storable
-      
-      @@rtype = 'disk'
+      include Rudy::Huxtable
       
         # This is a flag used internally to specify that a volume has been
-        # created for this disk, but not formated. 
+        # created for this disk, but not yet formated. 
       attr_accessor :raw_volume
       
       field :rtype
@@ -27,21 +25,25 @@ module Rudy
       
       def initialize
         @backups = []
-        @rtype = @@rtype.to_s
         @raw_volume = false
+        @rtype = Disk.rtype
       end
       
-      def rtype
-        @@rtype.to_s
-      end
-      
-      def rtype=(val)
+      def self.rtype
+        'disk'
       end
       
       def name
         Disk.generate_name(@zone, @environment, @role, @position, @path)
       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 valid?
         @zone && @environment && @role && @position && @path && @size && @device
       end
@@ -51,86 +53,95 @@ module Rudy
         criteria -= [*remove].flatten
         query = []
         criteria.each do |n|
-          query << "['#{n}' = '#{self.send(n.to_sym)}'] "
+          val = self.send(n.to_sym)
+          query << "['#{n}' = '#{self.send(n.to_sym)}'] " if val # Only add attributes with values
         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)
+      def to_select
+        
       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])
+      def save
+        @@sdb.store(RUDY_DOMAIN, name, self.to_hash, :replace) # Always returns nil
+        true
       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!
+      def destroy
+        @@sdb.destroy(RUDY_DOMAIN, name)
+        true
       end
       
-      def Disk.save(sdb, disk)
-        sdb.store(RUDY_DOMAIN, disk.name, disk.to_hash, :replace)
+      def refresh
+        h = @@sdb.get(RUDY_DOMAIN, name) || {}
+        from_hash(h)
       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?
+      def Disk.get(dname)
+        h = @@sdb.get(RUDY_DOMAIN, dname) || {}
+        from_hash(h)
       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
+      def is_mounted?
+        
       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)
+      def format(instance)
+        raise "No instance supplied" unless instance
+        raise "Disk not valid" unless self.valid?
+
+        begin
+          puts "Creating the filesystem (mkfs.ext3 -F #{disk.device})".bright
+          ssh_command instance.dns_name_public, current_user_keypairpath, @global.user, "mkfs.ext3 -F #{disk.device}"
+          sleep 1
+        rescue => ex
+          @logger.puts ex.backtrace if debug?
+          raise "Error formatting #{disk.path}: #{ex.message}"
+        end
+        true
+      end
+      def mount(instance)
+        raise "No instance supplied" unless instance
+        disk = find_disk(opts[:disk] || opts[:path])
+        raise "Disk #{opts[:disk] || opts[:path]} cannot be found" unless disk
+        switch_user(:root)
+        begin
+          puts "Mounting #{disk.device} to #{disk.path}".bright
+          ssh_command instance.dns_name_public, current_user_keypairpath, @global.user, "mkdir -p #{disk.path} && mount -t ext3 #{disk.device} #{disk.path}"
+        rescue => ex
+          @logger.puts ex.backtrace if debug?
+          raise "Error mounting #{disk.path}: #{ex.message}"
         end
+        true
+      end
+
+      def unmount(instance)
+        raise "No instance supplied" unless instance
+        disk = find_disk(opts[:disk] || opts[:path])
+        raise "Disk #{opts[:disk] || opts[:path]} cannot be found" unless disk
+        switch_user(:root)
+        begin
+          puts "Unmounting #{disk.path}...".bright
+          ssh_command instance.dns_name_public, current_user_keypairpath, global.user, "umount #{disk.path}"
+          sleep 1
+        rescue => ex
+          @logger.puts ex.backtrace if debug?
+          raise "Error unmounting #{disk.path}: #{ex.message}"
+        end
+        true
       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)
+      def to_s
+        str = ""
+        field_names.each do |key|
+          str << sprintf(" %22s: %s#{$/}", key, self.send(key.to_sym))
         end
-        list
+        str
       end
+       
+      
     end
     
   end