solutious-rudy 0.4.0 → 0.5.0

data/lib/rudy/command/keypairs.rb

@@ -0,0 +1,149 @@
+
+module Rudy
+  class KeyPairs
+    include Rudy::Huxtable
+    
+    
+    def create(n=nil, opts={})
+      raise KeyPairAlreadyDefined.new(current_machine_group) if !n && has_root_keypair?
+
+      n ||= name(n)
+        
+      opts = {
+        :force => false
+      }.merge(opts)
+      
+      delete_pk(n) if opts[:force] == true && File.exists?(self.path(n))
+      raise KeyPairExists, self.path(n) if File.exists?(self.path(n))
+      
+      kp = @@ec2.keypairs.create(n)
+      raise ErrorCreatingKeyPair, n unless kp.is_a?(Rudy::AWS::EC2::KeyPair)
+      
+      Rudy.trap_known_errors do
+        @logger.puts "Writing #{self.path(n)}"
+        Rudy::Utils.write_to_file(self.path(n), kp.private_key, 'w', 0600)
+      end
+      
+      Rudy.trap_known_errors do
+        @logger.puts "Writing #{self.public_path(n)}"
+        Rudy::Utils.write_to_file(self.public_path(n), kp.public_key, 'w', 0600)
+      end
+      
+      @logger.puts "NOTE: If you move #{self.path(n)} you need to also update your Rudy machines config.".color(:blue)
+      
+      kp
+    end
+    
+    #def check_permissions(n=nil)
+    #  n ||= name(n)
+    #  raise NoPrivateKeyFile, self.path(n) unless File.exists?(self.path(n))
+    #  raise InsecureKeyPairPermissions, self.path(n) unless File::Stat....
+    #  p n
+    #end
+    
+      
+    def destroy(n=nil)
+      n ||= name(n)
+      raise "KeyPair #{n} doesn't exist" unless exists?(n)
+      @logger.puts "No private key file: #{self.path(n)}. Continuing..." unless File.exists?(self.path(n))
+      @logger.puts "Unregistering KeyPair with Amazon"
+      ret = @@ec2.keypairs.destroy(n)
+      if ret
+        ret = delete_files(n) if ret # only delete local file if remote keypair is successfully destroyed
+      else
+        @logger.puts "Keypair not destroyed successfully."
+      end
+      ret
+    end
+    
+    # Lists the keypairs registered with Amazon
+    def list(n=nil, &each_object)
+      n &&= [n].flatten.compact
+      keypairs = @@ec2.keypairs.list(n)
+      keypairs.each { |n,kp| each_object.call(kp) } if each_object
+      keypairs || []
+    end
+    
+    def get(n=nil)
+      n ||= name(n)
+      keypairs = @@ec2.keypairs.list(n) || []
+      keypairs.first
+    end
+    
+    def list_as_hash(n=nil, &each_object)
+      n &&= [n].flatten.compact
+      keypairs = @@ec2.keypairs.list_as_hash(n)
+      keypairs.each_pair { |n,kp| each_object.call(kp) } if each_object
+      keypairs || {}
+    end
+    
+    def exists?(n=nil)
+      n ||= name(n)
+      @@ec2.keypairs.exists?(n)
+    end
+    
+    def any?(n=nil)
+      n ||= name(n)
+      @@ec2.keypairs.any?    
+    end
+    
+    def name(n=nil)
+      n ||= "key-#{current_machine_group}"
+      n
+    end
+      
+    def path(n=nil)
+      n ||= name(n)
+      File.join(self.config_dirname, "#{n}")
+    end
+    
+    def public_path(n=nil)
+      n ||= name(n)
+      File.join(self.config_dirname, "#{n}.pub")
+    end
+    
+
+    # We use the base file name to determine the registered keypair name.
+    def KeyPairs.path_to_name(path)
+      return unless path
+      return path unless File.exists?(path)
+      File.basename(path)
+    end
+    
+  private
+    def delete_files(n=nil)
+      n ||= name(n)
+      @logger.puts "Deleting #{self.path(n)}"
+      #return false unless File.exists?(self.path(n))
+      ret = (File.unlink(self.path(n)) > 0)      # raise exception on error. handle?
+      
+      @logger.puts "Deleting #{self.public_path(n)}"
+      #return false unless File.exists?(self.public_path(n))
+      ret && (File.unlink(self.public_path(n)) > 0)
+    end
+
+  end
+  class Keypairs
+    def initialize(*args)
+      raise "Oops! The correct class uses a capital 'P': Rudy::KeyPairs"
+    end
+  end
+end
+
+module Rudy
+  class KeyPairs
+    class InsecureKeyPairPermissions < RuntimeError; end
+    class NoPrivateKeyFile < RuntimeError; end
+    class ErrorCreatingKeyPair < RuntimeError; end
+    class KeyPairExists < RuntimeError; end
+    class KeyPairAlreadyDefined < RuntimeError
+      attr_reader :group
+      def initialize(group)
+        @group = group
+      end
+      def message
+        "A keypair is defined for #{group}. Check your Rudy config."
+      end
+    end
+  end
+end

data/lib/rudy/command/manager.rb

@@ -0,0 +1,65 @@
+
+
+module Rudy
+  class Manager
+    include Rudy::Huxtable
+    
+
+  end
+end
+
+
+__END__
+
+
+def create_domain(name=nil)
+  name ||= Rudy::RUDY_DOMAIN
+  @@sdb.domains.create(name)
+end
+
+def domains
+  (@@sdb.domains.list || []).flatten
+end
+
+
+
+def update_valid?
+  raise "No EC2 .pem keys provided" unless has_pem_keys?
+  raise "No SSH key provided for #{@global.user}!" unless has_keypair?
+  raise "No SSH key provided for root!" unless has_keypair?(:root)
+  
+  @option.group ||= machine_group
+  
+  @scripts = %w[rudy-ec2-startup update-ec2-ami-tools randomize-root-password]
+  @scripts.collect! {|script| File.join(RUDY_HOME, 'support', script) }
+  @scripts.each do |script| 
+    raise "Cannot find #{script}" unless File.exists?(script)
+  end
+  
+  true
+end
+
+def update
+  puts "Updating Rudy on machines in #{@option.group}"
+  switch_user("root")
+  
+  exit unless Annoy.are_you_sure?
+  scp do |scp|
+    @scripts.each do |script|
+      puts "Uploading #{File.basename(script)}"
+      scp.upload!(script, "/etc/init.d/")
+    end
+  end
+  
+  ssh do |session|
+    @scripts.each do |script|
+      session.exec!("chmod 700 /etc/init.d/#{File.basename(script)}")
+    end
+    
+    puts "Installing Rudy (#{Rudy::VERSION})"
+    session.exec!("mkdir -p /etc/ec2")
+    session.exec!("gem sources -a http://gems.github.com")
+    puts session.exec!("gem install --no-ri --no-rdoc rudy -v #{Rudy::VERSION}")
+  end
+end
+

data/lib/rudy/command/volumes.rb

@@ -1,66 +1,127 @@
 
-
 module Rudy
-  module Command
-    class Volumes < Rudy::Command::Base
+  class Volumes
+    include Rudy::Huxtable
+    
+
+    def create(size, zone=nil, snapshot=nil)
+      raise "No size supplied" unless size
+      zone ||= @global.zone
       
-      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
+      @logger.puts "Creating Volume "
+      vol = @@ec2.volumes.create(size, zone, snapshot)
+      Rudy.waiter(1, 30, @logger) do
+        vol = get(vol.awsid) # update the volume until it says it's available
+        (vol && vol.status == "available")
       end
+      
+      vol
+    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
+    def attach(volume, instance, device="/dev/sdh")
+      volume = get(volume)
+      instance = instance.is_a?(Rudy::AWS::EC2::Instance) ? instance.awsid : instance
+      raise "Volume #{volume.awsid} already attached" if volume.attached?
+      raise "No instance supplied" unless instance
+      raise "No device supplied" unless device
+      
+      ret = false
+      begin
+        @logger.puts "Attaching Volume... "
+        ret = @@ec2.volumes.attach(instance, volume.awsid, device)
+        raise "Unknown error" unless ret 
         
-          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}"
+        Rudy.waiter(1, 30, @logger) do
+          ret = attached?(volume.awsid)
         end
         
+      rescue => ex
+        @logger.puts ex.backtrace if debug?
+        raise "Error attaching #{volume.awsid} to #{instance}: #{ex.message}"
+      end
+      
+      ret
+    end
+    
+    def destroy(volume)
+      volume = get(volume)
+      
+      
+      ret = false
+      begin
+        
+        detach(volume) if volume.attached?
+        raise "Volume is still attached. Cannot destroy." unless available?(volume.awsid)
+        
+        ret = @@ec2.volumes.destroy(volume.awsid)
         
+      rescue => ex
+        puts ex.backtrace if debug?
+        raise "Error destroying volume #{volume.awsid}: #{ex.message}"
       end
+      ret
+    end
+     
+    def detach(volume)
+      volume = get(volume)
+      raise "#{volume.awsid} is not attached" unless attached?(volume.awsid)
       
-      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
+      ret = false
+      begin
+        @logger.puts "Dettaching #{volume.awsid} "
+        @@ec2.volumes.detach(volume.awsid)
+        Rudy.waiter(1, 30) do
+          ret = @@ec2.volumes.available?(volume.awsid)
         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
+      rescue => ex
+        puts ex.backtrace if debug?
+        raise "Error detaching volume #{volume.awsid}: #{ex.message}"
       end
       
+      ret
     end
-  end
-end
+    
+    
+    def attached?(volume)
+      @@ec2.volumes.attached?(volume)
+    end
+    
+    def deleting?(volume)
+      @@ec2.volumes.deleting?(volume)
+    end
+    
+    def available?(volume)
+      @@ec2.volumes.available?(volume)
+    end
+    
+    def in_use?(volume)
+      @@ec2.volumes.in_use?(volume)
+    end
+    
+    
+    def list(state=nil, vol_id=[])
+      @@ec2.volumes.list(state, vol_id)
+    end
+    
+    def list_as_hash(state=nil, vol_id=[])
+      @@ec2.volumes.list_as_hash(state, vol_id)
+    end
+    
+    def any?(state=nil, vol_id=[])
+      @@ec2.volumes.any?(state, vol_id)
+    end
+    
+    def exists?(vol_id)
+      @@ec2.volumes.exists?(vol_id)
+    end
+    
+    # * +volopt* is a volume ID or an Rudy::AWS::EC2::Volume object
+    def get(volopt)
+      return volopt if volopt.is_a?(Rudy::AWS::EC2::Volume)
+      @@ec2.volumes.get(volopt)
+    end
+    
 
+  end
+end

data/lib/rudy/config.rb

@@ -1,92 +1,112 @@
 
-
 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
+      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('/etc', 'rudy', '*.rb')) || []
+      @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 &&= @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
+
+          # Machine Configuration
+          # Specify your private keys here. These can be defined globally
+          # or by environment and role like in machines.rb.
+          machines do
+            users do
+              #root :keypair => "path/2/root-private-key"
+            end
+            zone :"us-east-1b" do
+              ami 'ami-235fba4a'    # Amazon Getting Started AMI (US)
+            end
+            zone :"eu-west-1b" do
+              ami 'ami-e40f2790'    # Amazon Getting Started AMI (EU)
+            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