rudy 0.4.0 → 0.6.0

data/lib/rudy/cli/disks.rb

@@ -0,0 +1,35 @@
+
+
+module Rudy
+  module CLI
+    class Disks < Rudy::CLI::CommandBase
+
+      
+      def disks
+        rdisk = Rudy::Disks.new
+        rdisk.list do |d|
+          puts @@global.verbose > 0 ? d.inspect : d.dump(@@global.format)
+        end
+      end
+      
+      def disks_wash
+        rdisk = Rudy::Disks.new
+        dirt = (rdisk.list || [])#.select { |d| d.available? }
+        if dirt.empty?
+          puts "Nothing to wash in #{rdisk.current_machine_group}"
+          return
+        end
+        
+        puts "The following disk metadata will be deleted:"
+        puts dirt.collect {|d| d.name }
+        execute_check(:medium)
+
+        dirt.each do |d|
+          d.destroy(:force)
+        end
+        
+      end
+      
+    end
+  end
+end

data/lib/rudy/cli/machines.rb

@@ -0,0 +1,94 @@
+
+
+module Rudy
+  module CLI
+    class Machines < Rudy::CLI::CommandBase
+      
+      
+      def machines
+        rmach = Rudy::Machines.new
+        mlist = rmach.list || []
+        if mlist.empty?
+          puts "No machines running in #{current_machine_group}" 
+          puts "Try: #{$0} startup"
+        end
+        mlist.each do |m|
+          puts @@global.verbose > 0 ? m.inspect : m.dump(@@global.format)
+        end
+      end
+      
+      def machines_wash
+        rmach = Rudy::Machines.new
+        dirt = (rmach.list || []).select { |m| !m.running? }
+        if dirt.empty?
+          puts "Nothing to wash in #{rmach.current_machine_group}"
+          return
+        end
+        
+        puts "The following machine metadata will be deleted:"
+        puts dirt.collect {|m| m.name }
+        execute_check(:medium)
+        
+        dirt.each do |m|
+          m.destroy
+        end
+        
+      end
+      
+      
+      def ssh
+        # TODO: Give this methos a good look over
+        pkey = user_keypairpath(@@global.user)
+        unless pkey
+          puts "No private key configured for #{@@global.user} in #{current_machine_group}"
+        end
+        
+        # Options to be sent to Net::SSH
+        ssh_opts = { :user => @@global.user || Rudy.sysinfo.user, :debug => nil  }
+        if pkey 
+          raise "Cannot find file #{pkey}" unless File.exists?(pkey)
+          raise InsecureKeyPermissions, @pkey unless File.stat(pkey).mode == 33152
+          ssh_opts[:keys] = pkey 
+        end
+
+
+        # The user specified a command to run. We won't create an interactive
+        # session so we need to prepare the command and its arguments
+        if @argv.first
+          command, command_args = @argv.shift, @argv || []
+          puts "#{command} #{command_args.join(' ')}" if @@global.verbose > 1
+
+        # otherwise, we'll open an ssh session or print command
+        else
+          command, command_args = :interactive_ssh, @option.print.nil?
+        end
+
+
+        checked = false
+        rudy = Rudy::Machines.new
+        lt = rudy.list do |machine|
+          # Print header
+          if @@global.quiet
+            print "You are #{ssh_opts[:user].to_s.bright}. " if !checked # only the 1st
+          else
+            print "Connecting #{ssh_opts[:user].to_s.bright}@#{machine.dns_public} "
+            puts "#{machine.name} (#{machine.awsid})"
+          end
+
+          # Make sure we want to run this command on all instances
+          if !checked && command != :interactive_ssh 
+            execute_check(:medium) if ssh_opts[:user] == "root"
+            checked = true
+          end
+          
+          # Open the connection and run the command
+          rbox = Rye::Box.new(machine.dns_public, ssh_opts)
+          ret = rbox.send(command, command_args)
+          puts ret unless command == :interactive_ssh
+        end
+      end
+
+
+    end
+  end
+end

data/lib/rudy/cli/routines.rb

@@ -0,0 +1,57 @@
+
+
+module Rudy; module CLI;
+  class Routines < Rudy::CLI::CommandBase
+  
+    def startup
+      rr = Rudy::Routines::Startup.new
+      rr.execute
+      
+      puts $/, "The following machines are now available:"
+      rmach = Rudy::Machines.new
+      rmach.list do |machine|
+        puts machine.to_s
+      end
+      
+      if @@global.environment == @@config.default.environment && 
+         @@global.role == @@config.default.role
+         puts
+         puts "Try: #{$0} -u root ssh"
+      end
+      
+    end
+    
+    def release
+      rr = Rudy::Routines::Release.new
+      rmach = Rudy::Machines.new
+      startup unless rmach.running?
+      rr.execute
+    end
+    
+    def shutdown
+      rr = Rudy::Routines::Shutdown.new
+      routine = fetch_routine_config(:shutdown)
+
+      puts "All machines in #{current_machine_group} will be shutdown and"
+      if routine && routine.disks
+        if routine.disks.destroy
+          puts "the following filesystems will be destroyed:".color(:red)
+          puts routine.disks.destroy.keys.join($/).bright
+        end
+      end
+      
+      execute_check :medium
+      
+      rr.execute
+      
+      rinst = Rudy::AWS::EC2::Instances.new(@@global.accesskey, @@global.secretkey, @@global.region)
+      lt = rinst.list_group(current_machine_group, :any) do |inst|
+        puts @@global.verbose > 0 ? inst.inspect : inst.dump(@@global.format)
+      end
+      puts "No instances running" if !lt || lt.empty?
+    end
+    
+
+  end
+end; end
+

data/lib/rudy/config.rb

@@ -1,92 +1,97 @@
 
-
 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
+  class Config < Caesars::Config
+    require 'rudy/config/objects'
     
-    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
+    dsl Rudy::Config::Accounts::DSL
+    dsl Rudy::Config::Defaults::DSL
+    dsl Rudy::Config::Routines::DSL
+    dsl Rudy::Config::Machines::DSL
+    dsl Rudy::Config::Networks::DSL
     
-    #
-    # 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
+    # TODO: auto-generate in caesars
+    def accounts?; self.respond_to?(:accounts) && !self[:accounts].nil?; end
+    def defaults?; self.respond_to?(:defaults) && !self[:defaults].nil?; end
+    def machines?; self.respond_to?(:machines) && !self[:machines].nil?; end
+    def routines?; self.respond_to?(:routines) && !self[:routines].nil?; end
+    def networks?; self.respond_to?(:networks) && !self[:networks].nil?; end
     
     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)
+      #raise "There is no AWS info configured" if self.accounts.nil?
       
+      # These don't work anymore. Caesars bug?
+      #if accounts? && !self.accounts.aws.nil?
+      #  self.accounts.aws.cert &&= File.expand_path(self.accounts.aws.cert) 
+      #  self.accounts.aws.privatekey &&= File.expand_path(self.accounts.aws.privatekey)
+      #end
     end
     
-    def look_and_load
+    def look_and_load(adhoc_path=nil)
       cwd = Dir.pwd
-      # Rudy looks for configs in all these locations
-      @paths += Dir.glob(File.join('/etc', 'rudy', '*.rb')) || []
+      cwd_path = File.join(cwd, '.rudy', 'config')
+      
+      # Attempt to load the core configuration file first.
+      # The "core" config file can have any or all configuration
+      # but it should generally only contain the access identifiers
+      # and defaults. That's why we only load one of them. 
+      core_config_paths = [adhoc_path, cwd_path, Rudy::CONFIG_FILE]
+      core_config_paths.each do |path|
+        next unless path && File.exists?(path)
+        @paths << path
+        break
+      end
+      
+      # Rudy then looks for the rest of the config in these locations
+      @paths += Dir.glob(File.join(cwd, 'Rudyfile')) || []
       @paths += Dir.glob(File.join(cwd, 'config', 'rudy', '*.rb')) || []
       @paths += Dir.glob(File.join(cwd, '.rudy', '*.rb')) || []
+      @paths += Dir.glob(File.join('/etc', 'rudy', '*.rb')) || []
+      @paths &&= @paths.uniq
+      
       refresh
     end
+
     
-    
+    def self.init_config_dir
+      
+      unless File.exists?(Rudy::CONFIG_DIR)
+        puts "Creating #{Rudy::CONFIG_DIR}"
+        Dir.mkdir(Rudy::CONFIG_DIR, 0700)
+      end
+
+      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
+              name "Rudy Default"
+              accountnum ""
+              accesskey ""
+              secretkey ""
+              privatekey "~/path/2/pk-xxxx.pem"
+              cert "~/path/2/cert-xxxx.pem"
+            end
+          end
+          
+          # Global Defaults 
+          # Define the values to use unless otherwise specified on the command-line. 
+          defaults do
+            region :"us-east-1" 
+            zone :"us-east-1b"
+            environment :stage
+            role :app
+            position "01"
+            user ENV['USER'].to_sym
+          end
+        }
+        Rudy::Utils.write_to_file(Rudy::CONFIG_FILE, rudy_config, 'w', 0600)
+      end
+    end
+
   end
 end
 

data/lib/rudy/config/objects.rb

@@ -0,0 +1,29 @@
+
+
+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
+    
+    forced_hash :create
+    forced_hash :destroy
+    forced_hash :restore
+    forced_hash :mount
+
+  end
+end

data/lib/rudy/disks.rb

@@ -0,0 +1,248 @@
+
+
+module Rudy
+class Disk < Storable
+  include Rudy::MetaData::ObjectBase
+  
+  field :rtype
+  field :awsid
+  field :status
+  field :instid
+  
+  field :region
+  field :zone
+  field :environment
+  field :role
+  field :position
+  field :path
+  
+  field :device
+  field :size
+  #field :backups => Array
+  
+  field :mounted
+  
+  def init(path=nil, size=nil, device=nil, position=nil)
+    @path, @size, @device = path, size, device
+    @rtype = 'disk'
+    @region = @@global.region
+    @zone = @@global.zone
+    @environment = @@global.environment
+    @role = @@global.role
+    @position = position || @@global.position
+    @mounted = false
+    postprocess
+  end
+  
+  def postprocess
+    @size &&= @size.to_i
+    @mounted = true if @mounted == "true"
+  end
+  
+  def liner_note
+    info = @awsid && !@awsid.empty? ? @awsid : 'no volume'
+    "%s  %s" % [self.name.bright, info]
+  end
+  
+  def to_s(with_titles=true)
+    update
+    mtd = @mounted ? "mounted" : @status
+    "%s; %3sGB; %s; %s" % [liner_note, @size, @device, mtd]
+  end
+  
+  def inspect
+    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 name
+    sep=File::SEPARATOR
+    dirs = @path.split sep if @path && !@path.empty?
+    dirs.shift while dirs && (dirs[0].nil? || dirs[0].empty?)
+    super("disk", @zone, @environment, @role, @position, *dirs)
+  end
+  
+
+  
+  def create(snapshot=nil)
+    raise "#{name} is already running" if exists?
+    vol = @rvol.create(@size, @zone, snapshot) 
+    @awsid = vol.awsid
+    self.save
+    self
+  end
+  
+  def attach(instid)
+    raise "No volume id" unless exists?
+    vol = @rvol.attach(@awsid, instid, @device)
+  end
+  
+  def detach
+    raise "No volume id" unless exists?
+    vol = @rvol.detach(@awsid)
+  end
+  
+  def destroy(force=false)
+    if @awsid && !deleting?
+      if !force
+        raise Rudy::AWS::EC2::VolumeNotAvailable, @awsid if attached?
+      else
+        detach if exists? && attached?
+        sleep 0.1
+      end
+      raise Rudy::AWS::EC2::VolumeNotAvailable, @awsid if in_use?
+      @rvol.destroy(@awsid) if exists? && available?
+    end
+    super() # quotes, otherwise Ruby will send this method's args
+  end
+  
+  def update
+    return false unless @awsid
+    @volume = @rvol.get(@awsid) 
+    if @volume.is_a?(Rudy::AWS::EC2::Volume)
+      @status = @volume.status
+      @instid = @volume.instid
+      save
+    end
+  end
+  
+  def to_query(more=[], less=[])
+    super([:path, *more], less)  # Add path to the default fields
+  end
+  
+  def to_select(more=[], less=[])
+    super([:path, *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
+  
+  def mounted?
+    @mounted && @mounted == true
+  end
+  
+  
+  %w[exists? deleting? available? attached? in_use?].each do |state|
+    define_method(state) do
+      return false if @awsid.nil? || @awsid.empty?
+      @rvol.send(state, @awsid) rescue false # deleting?, available?, etc...
+    end
+  end
+end
+
+class Disks
+  include Rudy::MetaData
+  
+    
+  def create(&each_mach)
+    
+  end
+
+
+  def destroy(&each_mach)
+    #raise MachineGroupNotRunning, current_machine_group unless running?
+    #raise MachineGroupNotDefined, current_machine_group unless known_machine_group?
+    list do |disk|
+      puts "Destroying #{disk.name}"
+      disk.destroy
+    end
+  end
+
+  def list(more=[], less=[], &each_disk)
+    disks = list_as_hash(&each_disk)
+    disks &&= disks.values
+    disks
+  end
+
+  def list_as_hash(more=[], less=[], &each_disk)
+    query = to_select([:rtype, 'disk'], less)
+    list = @sdb.select(query) || {}
+    disks = {}
+    list.each_pair do |n,d|
+      disks[n] = Rudy::Disk.from_hash(d)
+    end
+    disks.each_pair { |n,disk| each_disk.call(disk) } if each_disk
+    disks = nil if disks.empty?
+    disks
+  end
+
+  def get(rname=nil)
+    dhash = @sdb.get(Rudy::DOMAIN, rname)
+    return nil if dhash.nil? || dhash.empty?
+    d = Rudy::Disk.from_hash(dhash)
+    d.update if d
+    d
+  end
+
+
+  def running?
+    !list.nil?
+    # TODO: add logic that checks whether the instances are running.
+  end
+
+
+    
+  
+end
+end
+
+
+
+
+__END__
+
+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_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_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_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