rudy 0.2

data/lib/rudy/command/images.rb

@@ -0,0 +1,61 @@
+
+
+module Rudy
+  module Command
+    class Images < Rudy::Command::Base
+      
+
+      def print_images
+        @ec2.images.list.each do |img|
+          print_image img
+        end
+      end
+      
+      def create_image
+        
+        if @user != "root"
+          puts "This command will be run as root"
+          @user = "root" # We need to be root for this operation!
+        end
+        
+        raise "No EC2 .pem keys provided" unless has_pem_keys?
+        raise "No SSH key provided for #{keypairname}!" unless has_keypair?(keypairname)
+        raise "SSH key provided but cannot be found! (#{keypairpath})" unless File.exists?(keypairpath)
+        
+        machine_list = @ec2.instances.list(machine_group)
+        machine = machine_list.values.first  # NOTE: Only one machine per group, for now...
+
+        raise "There's no machine running in #{machine_group}" unless machine
+        raise "The primary machine in #{machine_group} is not in a running state" unless machine[:aws_state] == 'running'
+        
+        puts "The new image will be based on #{machine_group}_01"
+        
+        unless @account
+          puts "Enter your 12 digit Amazon account number:"
+          @account = gets.chomp
+        end
+        
+        unless @image_name
+          puts "Enter the image name:"
+          @image_name = gets.chomp
+        end
+        
+        unless @bucket_name
+          puts "Enter the S3 bucket that will store the image:"
+          @bucket_name = gets.chomp
+        end
+        
+        scp machine[:dns_name], keypairpath, user, @ec2_cert, "/mnt/"
+        scp machine[:dns_name], keypairpath, user, @ec2_private_key, "/mnt/"
+        
+        ssh machine[:dns_name], keypairpath, user, "ec2-bundle-vol -r i386 -p #{@image_name} -k /mnt/pk-*pem -c /mnt/cert*pem -u #{@account}"
+        ssh machine[:dns_name], keypairpath, user, "ec2-upload-bundle -b #{@bucket_name} -m /tmp/#{@image_name}.manifest.xml -a #{@access_key} -s #{@secret_key}"
+        
+        # Why did I not use the Ruby API?
+        sh "ec2-register -K #{@ec2_private_key} -C #{@ec2_cert} #{@bucket_name}/#{@image_name}.manifest.xml"
+      end
+      
+    end
+  end
+end
+

data/lib/rudy/command/instances.rb

@@ -0,0 +1,109 @@
+
+
+module Rudy
+  module Command
+    class Instances < Rudy::Command::Base
+      
+      def print_instances(filter=nil)
+        filter = machine_group if filter.nil? && !@all
+        if instance_id?(filter)
+          inst = @ec2.instances.get(filter)
+          raise "The instance #{filter} does not exist" if inst.empty?
+          list = {inst[:aws_instance_id] => inst}
+        else
+          raise "The security group #{filter} does not exist" if filter && !@ec2.groups.exists?(filter)
+          list = @ec2.instances.list(filter)
+          if list.empty? 
+            msg = "There are no instances running" 
+            msg << " in the group #{filter}" if filter
+            raise msg
+          end
+        end
+        
+        list.each_pair do |id, inst|
+          print_instance inst
+        end
+        
+      end
+      
+      def destroy_instances(filter=nil)
+        raise "No instance ID or group name provided" if filter.nil?
+        raise "I will not help you destroy production!" if @environment == "prod" || filter =~ /^prod/
+        if @ec2.groups.exists?(filter)
+          list = @ec2.instances.list(filter)
+          raise "The group #{filter} has no running instances" if list.empty?
+          instance = list.keys.first
+        else 
+          instance = filter
+        end
+        puts "Destroying #{instance}!"
+        @ec2.instances.destroy instance
+      end
+      
+      def start_instance
+        @image ||= machine_image
+        
+        @user = "root"
+        
+        rig = @ec2.instances.list(machine_group)
+        raise "There is already an instance running in #{machine_group}" unless rig.empty?
+        raise "No SSH key provided for #{keypairname}!" unless has_keypair?(keypairname)
+        raise "SSH key provided but cannot be found! (#{keypairpath})" unless File.exists?(keypairpath)
+        
+        user_data = {
+          :dbmaster => "localhost",
+          :role => @role,
+          :env => @environment
+        } 
+        
+        puts "Starting an instance in #{machine_group}"
+        instances = @ec2.instances.create(@image, machine_group.to_s, File.basename(keypairpath), user_data.to_yaml, @zone)
+        inst = instances.first
+        id, state = inst[:aws_instance_id], inst[:aws_state]
+        
+        if @address
+          puts "Associating #{@address} to #{id}"
+          @ec2.addresses.associate(id, @address)
+        end
+        
+        print "Waiting for #{id} to become available"
+        
+        while @ec2.instances.pending?(id)
+          sleep 2
+          print '.'
+          STDOUT.flush
+        end
+        
+        machine = @ec2.instances.get(id)
+        
+        puts " It's up!"
+        print "Waiting for SSH daemon at #{machine[:dns_name]}"
+        while !Rudy::Utils.service_available?(machine[:dns_name], 22)
+          print '.'
+          STDOUT.flush
+        end
+        puts " It's up!"
+        
+        print "Looking for disk metadata for #{machine[:aws_availability_zone]}... "
+        disks = Rudy::MetaData::Disk.list(@sdb, machine[:aws_availability_zone], @environment, @role, @position)
+        
+        if disks.empty?
+          puts "None"
+        else
+          puts "#{disks.size} disk(s)."
+          disks.each do |disk|
+            
+            do_dirty_disk_volume_deeds(disk, machine)
+          end
+        end
+        
+        puts
+        ssh machine[:dns_name], keypairpath, user, "df -h" # Display current mounts
+        puts 
+        puts "Done!"
+      end
+      
+    end
+  end
+end
+

data/lib/rudy/command/metadata.rb

@@ -0,0 +1,57 @@
+
+
+module Rudy
+  module Command
+    class Metadata < Rudy::Command::Base
+      
+      
+      # Update Rudy's metadata for a running instance
+      def update_metadata(instances)
+        attributes = {
+          'role' => role,
+          'environment' => environment,
+          'instances' => instances
+        }
+        puts "Putting #{instances.join(', ')} into #{machine_group}"
+        
+        @sdb.store(RUDY_DOMAIN, "group_#{machine_group}", attributes)
+        
+        p group_metadata
+      end
+      
+      # Print Rudy's metadata to STDOUT
+      def print_metadata(instances=[])
+        p group_metadata
+        #query = "['instances' = '#{instances.first}'] union ['group' = '#{machine}']"
+        #
+        # p @sdb.get_attributes(RUDY_DOMAIN, "instances_#{machine}")
+        # p @sdb.query(RUDY_DOMAIN, query)
+      end
+      
+      def destroy_metadata
+        @sdb.domains.destroy(RUDY_DOMAIN)
+      end
+      
+      def setup
+        puts "Checking environment..."
+        check_environment
+        
+        puts "Creating SimpleDB domain called #{RUDY_DOMAIN}"
+        @sdb.domains.create(RUDY_DOMAIN)
+      end
+      
+      def info 
+        domains = @sdb.domains.list[:domains]
+        puts "Domains: #{domains.join(", ")}"
+      end
+    
+      def check_environment
+        raise "No Amazon keys provided!" unless has_keys?
+        raise "No SSH keypairs provided!" unless has_keypairs?
+        true
+      end
+        
+    end
+  end
+end
+

data/lib/rudy/command/release.rb

@@ -0,0 +1,43 @@
+
+
+module Rudy
+  module Command
+    class Release < Rudy::Command::Base
+      
+      
+      def create_release
+        
+        if @user != "root"
+          #puts "This command will be run as root"
+          @user = "root" # We need to be root for this operation!
+        end
+        
+        raise "No EC2 .pem keys provided" unless has_pem_keys?
+        raise "No SSH key provided for #{keypairname}!" unless has_keypair?(keypairname)
+        raise "SSH key provided but cannot be found! (#{keypairpath})" unless File.exists?(keypairpath)
+        
+        raise "The security group #{filter} does not exist" if machine_group && !@ec2.groups.exists?(machine_group)
+        list = @ec2.instances.list(machine_group)
+        raise "Please start an instance in #{machine_group} before releasing!" if list.empty?
+        puts "Creating release from: #{Dir.pwd}"
+        
+        tag = @scm.create_release 
+        
+        machine = list.values.first # NOTE: we're assuming there's only one machine
+        
+        #basename = File.basename(@rscripts[keypairname])
+        #scp machine[:dns_name], keypairpath, user, @rscripts[keypairname], "/mnt/"
+        #ssh machine[:dns_name], keypairpath, user, "chmod 755 /mnt/#{basename} && /mnt/#{basename} #{tag}" 
+        
+        @user = "rudy"
+        basename = File.basename(@rscripts[keypairname])
+        
+        scp machine[:dns_name], keypairpath, user, @rscripts[keypairname], "~/"
+        ssh machine[:dns_name], keypairpath, user, "chmod 755 ~/#{basename} && ~/#{basename} test #{@access_key} #{@secret_key} r1ll1r1ll1" 
+
+      end
+      
+    end
+  end
+end
+

data/lib/rudy/command/volumes.rb

@@ -0,0 +1,13 @@
+
+
+module Rudy
+  module Command
+    class Volumes < Rudy::Command::Base
+      
+      def print_volumes
+        y @ec2.volumes.list
+      end
+    end
+  end
+end
+

data/lib/rudy/metadata/disk.rb

@@ -0,0 +1,142 @@
+
+
+module Rudy
+  class MetaData
+    attr_accessor :sdb
+    
+    def initalize(sdb)
+      @sdb = sdb
+    end
+    
+  end
+  class MetaData
+    class Disk < Storable
+      
+      field :awsid
+      
+      field :environment
+      field :role
+      field :path
+      field :position
+      
+      field :zone
+      field :region
+      field :device
+      field :backups => Array
+      field :size
+      
+      def initialize
+        @device = "/dev/sdh"
+        @zone = DEFAULT_ZONE
+        @region = DEFAULT_REGION
+        @backups = []
+        
+      end
+      
+      def name
+        Disk.generate_name(@zone, @environment, @role, @position, @path)
+      end
+      
+      def valid?
+        @zone && @environment && @role && @position && @path 
+      end
+      
+      def to_query(more=[], remove=[])
+        criteria = [: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)
+        raise "Disk #{name} does not exist!" unless disk && disk.has_key?(:attributes)
+        Rudy::MetaData::Disk.from_hash(disk[:attributes])
+      end
+      
+      def Disk.destroy(sdb, name)
+        disk = Disk.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 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.update_volume(sdb, ec2, disk, machine)
+        
+        disk = Disk.get(sdb, disk) if disk.is_a?(String)
+        raise "You must provide a disk name or obect" unless disk.is_a?(Rudy::MetaData::Disk)
+        
+        
+        # Make sure the volume is still running
+        disk.awsid = nil if disk.awsid && !ec2.volumes.exists?(disk.awsid)
+        
+        
+        # Otherwise we need to start one
+        unless disk.awsid
+          puts "No active EBS volume found for #{disk.name}"
+          
+          backup = disk.backups.last
+          if backup
+            puts "We'll use the most recent backup..."
+            volume = ec2.volumes.create(disk.zone, disk.size, backup)
+            puts "Attaching #{disk.awsid} to #{id} (#{disk.device})"
+            ec2.volumes.attach(machine[:aws_instance_id], disk.awsid, disk.device)
+          else
+            puts "We'll create one from scratch..."
+            volume = ec2.volumes.create(disk.zone, disk.size, nil)
+            disk.awsid = volume[:aws_id]
+            puts "Saving disk metadata"
+            Disk.save(sdb, disk)
+          end
+          puts ""
+        end
+        
+        disk
+      end
+      
+      def Disk.list(sdb, zon, env=nil, rol=nil, pos=nil)
+        query = ''
+        query << "['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|
+          list << Rudy::MetaData::Disk.from_hash(hash)
+        end
+        list
+      end
+    end
+    
+  end
+
+end

data/lib/rudy/scm/svn.rb

@@ -0,0 +1,57 @@
+
+require 'date'
+
+module Rudy
+  module SCM
+    class SVN
+      attr_accessor :base_uri
+      
+      def initialize(uri)
+        @base_uri = uri
+      end
+      
+      def create_release
+        raise "There are local changes. Please revert or check them in!" unless everything_checked_in?
+        raise "Invalid base URI (#{@base_uri}). Check RUDY_SVN_BASE." unless valid_uri?(@base_uri)
+        raise "You must run this command from SVN you want to release from!" unless svn_dir?(Dir.pwd)
+        
+        re = `svn info`.match /^URL:\s+(.+)$/
+        release = re[1] if re
+        
+        release_tag = "#{@base_uri}/#{generate_release_tag}"
+        
+        puts "Creating tag: #{release_tag}"
+        cmd = "svn copy -m 'Another Release by Rudy!' #{release} #{release_tag}"
+        
+        `#{cmd}`
+        
+        release_tag
+      end
+      
+      def generate_release_tag
+        now = Time.now
+        mon = now.mon.to_s.rjust(2, '0')
+        day = now.day.to_s.rjust(2, '0')
+        rev = "r01"
+        criteria = ['rudy', now.year, mon, day, rev]
+        tag = criteria.join(RUDY_DELIM)
+        # Keep incrementing the revision number until we find the next one. 
+        tag.succ! while (valid_uri?("#{@base_uri}/#{tag}")) 
+        tag
+      end
+      
+      def svn_dir?(path)
+        (File.exists?(File.join(path, '.svn')))
+      end
+      
+      def valid_uri?(uri)
+        ret = `svn info #{uri} 2>1&` || '' # Valid SVN URIs will return some info
+        (ret =~ /Repository UUID/) ? true : false
+      end
+      
+      def everything_checked_in?
+        `svn diff . 2>1&` == '' # svn diff should return nothing
+      end
+    end
+  end
+end