rudy 0.2

data/lib/rudy/command/base.rb

@@ -0,0 +1,275 @@
+
+module Rudy
+  class UnknownInstance < RuntimeError; end
+end
+
+module Rudy
+  module Command
+    class NoCred < RuntimeError; end;
+    
+    class Base < Drydock::Command
+      
+      attr_accessor :access_key
+      attr_accessor :secret_key
+      attr_accessor :ec2_cert
+      attr_accessor :ec2_private_key
+      attr_accessor :keypairs
+      
+      attr_reader :user
+      attr_reader :environment
+      attr_reader :role
+      attr_reader :position
+      
+      attr_reader :zone
+      attr_reader :region
+      
+      attr_reader :scm
+      
+      attr_reader :rscripts
+      
+      attr_reader :machine_images
+      
+      def init
+        @access_key = ENV['AWS_ACCESS_KEY'] unless @access_key
+        @secret_key = ENV['AWS_SECRET_KEY'] unless @secret_key
+        
+        @ec2_cert        = ENV['EC2_CERT'] unless @ec2_cert
+        @ec2_private_key = ENV['EC2_PRIVATE_KEY'] unless @ec2_private_key
+        
+        if ENV['RUDY_SVN_BASE']
+          @scm = Rudy::SCM::SVN.new(ENV['RUDY_SVN_BASE'])
+        end
+        
+        @user ||= 'rudy'
+        @environment ||= 'stage'
+        @role ||= 'app'
+        @position ||= '01'
+        
+        @zone ||= DEFAULT_ZONE
+        @region ||= DEFAULT_REGION
+        
+        @keypairs = {}
+        ENV.keys.select { |key| key.match /EC2_KEYPAIR/i }.each do |key|
+          ec2, keypair, env, role, user = key.split '_' # EC2_KEYPAIR_STAGE_APP_RUDY
+          raise "#{key} is malformed." unless env && role && user
+          new_key = "#{env}-#{role}-#{user}".downcase
+          @keypairs[new_key] = ENV[key]
+        end
+        
+        @rscripts = {}
+        ENV.keys.select { |key| key.match /RUDY_RSCRIPT/i }.each do |key|
+          rudy, rscript, env, role, user = key.split '_' # RUDY_RSCRIPT_STAGE_APP_ROOT
+          raise "#{key} is malformed." unless env && role && user
+          new_key = "#{env}-#{role}-#{user}".downcase
+          @rscripts[new_key] = ENV[key]
+        end
+        
+        @machine_images = {}
+        ENV.keys.select { |key| key.match /EC2_AMI_/i }.each do |key|
+          ec2, ami, env, role = key.split '_' # RUDY_RSCRIPT_STAGE_APP_ROOT
+          raise "#{key} is malformed." unless env && role
+          new_key = "#{env}-#{role}".downcase
+          @machine_images[new_key] = ENV[key]
+        end
+        
+        if @verbose > 1 && Drydock.debug?
+          instance_variables.each do |var|
+            puts "#{var}: #{instance_variable_get(var)}"
+          end
+        end
+        
+        @sdb = Rudy::AWS::SimpleDB.new(@access_key, @secret_key)
+        @ec2 = Rudy::AWS::EC2.new(@access_key, @secret_key)
+        #@s3 = Rudy::AWS::SimpleDB.new(@access_key, @secret_key)
+      end
+      
+      def has_pem_keys?
+        (@ec2_cert        && File.exists?(@ec2_cert) && 
+         @ec2_private_key && File.exists?(@ec2_private_key))
+      end
+       
+      def has_keys?
+        (@access_key && @secret_key)
+      end
+      
+      def has_keypair?(name)
+        (has_keypairs? && @keypairs.has_key?(name))
+      end
+      
+      def has_keypairs?
+        (!@keypairs.empty?)
+      end
+      
+      def machine_group
+        [@environment, @role].join(RUDY_DELIM)
+      end
+      
+      def machine_image
+        @machine_images[machine_group]
+      end
+      
+      def machine_name
+        [machine_group, @position].join(RUDY_DELIM)
+      end
+      
+      def keypairname
+        [machine_group, user].join(RUDY_DELIM)
+      end
+      
+      def keypairpath
+        return unless has_keypair?(keypairname)
+        @keypairs[keypairname]
+      end
+      
+      def instance_id?(id=nil)
+        (id && id[0,2] == "i-")
+      end
+      
+      def image_id?(id=nil)
+        (id && id[0,4] == "ami-")
+      end
+      
+      def volume_id?(id=nil)
+        (id && id[0,4] == "vol-")
+      end
+      
+      def snapshot_id?(id=nil)
+        (id && id[0,5] == "snap-")
+      end
+      
+      
+      def do_dirty_disk_volume_deeds(disk, machine)
+        puts "-"*30
+        puts "Disk: #{disk.name} (path: #{disk.path}, device: #{disk.device})"
+        puts 
+        
+        if @ec2.instances.attached_volume?(machine[:aws_instance_id], disk.device)
+          raise "#{disk.device} is already in use on #{machine[:aws_instance_id]}! (Try umounting it)"
+        end
+        
+        new_volume = false
+        if !disk.awsid || (disk.awsid && !@ec2.volumes.exists?(disk.awsid))
+          disk = Rudy::MetaData::Disk.update_volume(@sdb, @ec2, disk, machine)
+          new_volume = true
+        end
+        
+        raise "Unknown error creating volume! #{disk.awsid}" unless disk && disk.awsid
+        
+        puts "Attaching #{disk.awsid} to #{machine[:aws_instance_id]}"
+        @ec2.volumes.attach(machine[:aws_instance_id], disk.awsid, disk.device)
+        sleep 2
+        
+        @user = "root"
+        
+        if new_volume
+          puts "Creating the filesystem (mkfs.ext3 -F #{disk.device})"
+          capture(:stdout) do
+            ssh machine[:dns_name], keypairpath, user, "mkfs.ext3 -F #{disk.device}"
+          end
+          sleep 2
+        end
+        
+        puts "Mounting #{disk.device} to #{disk.path}"
+        capture(:stdout) do
+          ssh machine[:dns_name], keypairpath, user, "mkdir -p #{disk.path} && mount -t ext3 #{disk.device} #{disk.path}"
+        end
+        sleep 1
+        
+      end
+      
+      
+      
+      # Print a default header to the screen for every command.
+      # +cmd+ is the name of the command current running. 
+      def print_header(cmd=nil)
+        print "RUDY v#{Rudy::VERSION}"
+        print " -- #{@alias}" if @alias
+        puts
+        
+        criteria = []
+        [:zone, :environment, :role, :position].each do |n|
+          val = instance_variable_get("@#{n}")
+          criteria << "[#{n} = #{val}]"
+        end
+        puts criteria.join(" and ")
+        
+        if (@environment == "prod") 
+          puts %q(
+=======================================================
+=======================================================
+!!!!!!!!!   YOU ARE PLAYING WITH PRODUCTION   !!!!!!!!!
+=======================================================
+=======================================================
+          )
+        end
+        
+      end
+      
+      def print_footer
+        
+      end
+      
+
+      
+      def group_metadata(env=@environment, role=@role)
+        query = "['environment' = '#{env}'] intersection ['role' = '#{role}']"
+        @sdb.query_with_attributes(RUDY_DOMAIN, query)
+      end
+      
+      private 
+        # Print info about a running instance
+        # +inst+ is a hash
+        def print_instance(inst)
+          puts '-'*60
+          puts "Instance: #{inst[:aws_instance_id]} (AMI: #{inst[:aws_image_id]})"
+          [:aws_state, :dns_name, :private_dns_name, :aws_availability_zone, :aws_launch_time, :ssh_key_name].each do |key|
+             printf(" %22s: %s#{$/}", key, inst[key]) if inst[key]
+           end
+          printf(" %22s: %s#{$/}", 'aws_groups', inst[:aws_groups].join(', '))
+          puts
+        end
+        
+        def print_image(img)
+          puts '-'*60
+          puts "Image: #{img[:aws_location]}"
+          img.each_pair do |key, value|
+             printf(" %22s: %s#{$/}", key, value) if value
+           end
+          puts
+        end
+        
+        def print_disk(disk)
+          puts '-'*60
+          puts "Disk: #{disk.name}"
+          puts disk.to_s
+          puts
+        end
+        
+        # Print info about a a security group
+        # +group+ is an OpenStruct
+        def print_group(group)
+          puts '-'*60
+          puts "%12s: %s" % ['GROUP', group[:aws_group_name]]
+          puts 
+          
+          group_ip = {}
+          group[:aws_perms].each do |perm| 
+             (group_ip[ perm[:cidr_ips] ] ||= []) << "#{perm[:protocol]}/#{perm[:from_port]}-#{perm[:to_port]}"
+          end
+           
+          puts "%22s  %s" % ["source address/mask", "protocol/ports (from, to)"]
+          
+           
+          group_ip.each_pair do |ip, perms|
+            puts "%22s  %s" % [ip, perms.shift]
+            perms.each do |perm|
+              puts "%22s  %s" % ['', perm]
+            end
+            puts
+          end
+        end
+        
+      
+    end
+  end
+end

data/lib/rudy/command/commit.rb

@@ -0,0 +1,10 @@
+
+
+module Rudy
+  module Command
+    class Commit < Rudy::Command::Base
+      
+    end
+  end
+end
+

data/lib/rudy/command/disks.rb

@@ -0,0 +1,61 @@
+
+
+module Rudy
+  module Command
+    class Disks < Rudy::Command::Base
+      
+      
+      def create_disk
+        disk = Rudy::MetaData::Disk.new
+        [:environment, :role, :position, :path, :device, :size].each do |n|
+          val = instance_variable_get("@#{n}")
+          disk.send("#{n}=", val) if val
+        end
+        
+        raise "Not enough info was provided to define a disk (#{disk.name})" unless disk.valid?
+        raise "The device #{disk.device} is already in use on that machine" if Rudy::MetaData::Disk.is_defined?(@sdb, disk)
+        puts "Creating disk metadata for #{disk.name}"
+        
+        Rudy::MetaData::Disk.save(@sdb, disk)
+        
+        print_disks
+      end
+
+      def print_disks
+        criteria = [@zone]
+        criteria += [@environment, @role] unless @all
+        
+        Rudy::MetaData::Disk.list(@sdb, *criteria).each do |disk|
+          print_disk disk
+        end
+
+      end
+      
+      def attach_disk(name)
+        puts "Looking for #{name}"
+        disk = Rudy::MetaData::Disk.get(@sdb, name)
+        instances = @ec2.instances.list(machine_group)
+        raise "There are no instances running in #{machine_group}" if !instances || instances.empty?
+        instance_id = instances.keys.first
+        machine = instances.values.first
+        
+        do_dirty_disk_volume_deeds(disk, machine)
+        
+        
+        puts
+        ssh machine[:dns_name], keypairpath, user, "df -h" # Display current mounts
+        puts 
+        
+        puts "Done!"
+      end
+      
+      def destroy_disk(name)
+        puts "Destroying #{name}"
+        @sdb.destroy(RUDY_DOMAIN, name)
+        puts "Done."
+      end
+
+    end
+  end
+end
+

data/lib/rudy/command/environment.rb

@@ -0,0 +1,95 @@
+
+
+
+
+
+# :role:
+# :env:
+# :access_key:
+# :secret_key:
+# :dbmachine:
+
+
+module Rudy
+  module Command
+    class Environment < Rudy::Command::Base
+
+      def connect
+        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'
+        cmd = "ssh -i #{keypairpath} #{user}@#{machine[:dns_name]}"
+        puts cmd
+        system(cmd) unless @print
+      end
+      
+      # Start EC2 instances to run the stage. 
+      # Returns a hash in the same format as +instances+
+      def build_stage
+        
+        rig = running_instance_groups(@app_group)
+        raise "You already have a stage: #{rig.join(', ')}" unless rig.empty?
+        
+        root_keypair_name = File.basename(@app_root_keypair)
+        
+        # This is read by the Rudy start up script /etc/init.d/rudy-ec2-startup
+        user_data = {
+          :dbmaster => "localhost",
+          :role => "FE",
+          :env => "stage"
+        }
+        
+        ret = @ec2.run_instances(@app_ami, 1, 1, [@app_group], root_keypair_name, user_data.to_yaml, 'public')
+        puts "The instance has started. Please wait while it boots..."
+        puts "Check '#{$0} state' for aws_state 'running'."
+        puts "Then run '#{$0} stage --start"
+        associate_address
+        ret
+      end
+      
+      
+      # Start (rake bootstrap, etc...) the rails app on the stage
+      def start_stage
+        
+        rig = running_instance_groups(@app_group)
+        raise "There is no stage start!" if rig.empty?
+        cmds =[]
+        cmds.each do |cmd|
+          puts cmd
+          `#{cmd}`
+        end
+        
+      end
+      
+      # Shutdown all instances in the stage security group
+      def destroy_stage
+         
+        rig = running_instance_groups(@app_group)
+        raise "There is no stage to destroy!" if rig.empty?
+        stopped = []
+        rig.each do |inst|
+          stopped << inst[:aws_instance_id]
+        end
+        destroy_instances(stopped)
+      end
+
+      #def svn_tag_exists?(rtag, prefix)
+      #  return false if rtag.empty?
+      #  `svn info tag/`
+      #end
+      
+      def tag_release
+        
+      end
+      
+    end
+  end
+end
+
+__END__
+
+

data/lib/rudy/command/groups.rb

@@ -0,0 +1,59 @@
+
+
+
+module Rudy
+  module Command
+    class Groups < Rudy::Command::Base
+      
+      def print_groups(name=nil)
+        name = machine_group if name.nil? && !@all
+        @ec2.groups.list(name).each do |grp|
+          print_group grp
+        end
+      end
+      
+      def create_group(name=nil)
+        name = machine_group if name.nil?
+        raise "The group #{name} already exists" if @ec2.groups.exists?(name)
+
+        puts "Creating group #{name}"
+        @ec2.groups.create(name)
+        
+        modify_group name
+      end
+      
+      def modify_group(name=nil)
+        name = machine_group if name.nil?
+        raise "The group #{name} does not exist" unless @ec2.groups.exists?(name)
+        
+        @addresses = [Rudy::Utils::external_ip_address] if @addresses.nil?
+        @ports = [22,80,443] if @ports.nil?
+        @protocols = ["tcp"] if @protocols.nil?
+        
+        # Make sure the IP addresses have ranges
+        @addresses.collect! { |ip| (ip.match /\/\d+/) ? ip : "#{ip}/32"  }
+        
+        @protocols.each do |protocol|
+          puts "Adding ports #{@ports.join(',')} (#{protocol}) for #{@addresses.join(', ')}"
+          @addresses.each do |address|
+            @ports.each do |port|
+              @ec2.groups.modify(name, port, port, protocol, address)
+            end
+          end
+        end
+        
+        print_groups name
+      end
+      
+      def destroy_group(name=nil)
+        name = machine_group if name.nil?
+        raise "The group #{name} does not exist" unless @ec2.groups.exists?(name)
+        
+        puts "Destroying group #{name}"
+        @ec2.groups.destroy(name)
+        
+      end
+    end
+  end
+end
+