solutious-rudy 0.5.1 → 0.6.0

data/lib/rudy/cli/backups.rb

@@ -1,175 +0,0 @@
-
-
-
-
-module Rudy
-  module CLI
-    class Backups < Rudy::CLI::Base
-      
-      
-      def backup
-        criteria = [@global.zone]
-        criteria += [@global.environment, @global.role] unless @option.all
-        
-        Rudy::MetaData::Backup.list(@sdb, *criteria).each do |backup|
-          puts "%s (%s)" % [backup.name, backup.awsid]
-        end
-      end
-      
-      # Check for backups pointing to snapshots that don't exist. 
-      def sync_backup
-        unless argv.empty?
-          puts "The disk you specified will be ignored."
-          argv.clear
-        end
-        
-        criteria = [@global.zone]
-        criteria += [@global.environment, @global.role] unless @option.all
-        
-        puts "Looking for backup metadata with delinquent snapshots..."
-        to_be_deleted = {} # snap-id => backup
-        Rudy::MetaData::Backup.list(@sdb, *criteria).each do |backup|
-          to_be_deleted[backup.awsid] = backup unless @ec2.snapshots.exists?(backup.awsid)
-        end
-        
-        if to_be_deleted.empty?
-          puts "All backups are in-sync with snapshots. Nothing to do."
-          return
-        end
-        
-        puts
-        puts "These backup metadata will be deleted:"
-        to_be_deleted.each do |snap_id, backup|
-          puts "%s: %s" % [snap_id, backup.name]
-        end
-        
-        puts
-        exit unless Annoy.are_you_sure?
-        
-        puts 
-        puts "Deleting..."
-        to_be_deleted.each do |snap_id, backup|
-          print " -> #{backup.name}... "
-          @sdb.destroy(RUDY_DOMAIN, backup.name)
-          puts "done"
-        end
-        
-        puts "Done!"
-      end
-      
-      def destroy_backup_valid?
-        raise "No backup specified" if argv.empty?
-        exit unless Annoy.are_you_sure?(:high)
-        true
-      end
-      
-      def destroy_backup
-        name = @argv.first
-        puts "Destroying #{name}"
-        begin
-          backup = Rudy::MetaData::Backup.get(@sdb, name)
-        rescue => ex
-          puts "Error deleteing backup: #{ex.message}"
-        end
-        
-        return unless backup
-        
-        begin
-          puts " -> deleting snapshot..."
-          @ec2.snapshots.destroy(backup.awsid)
-        rescue => ex
-          puts "Error deleting snapshot: #{ex.message}."
-          puts "Continuing..."
-        ensure
-          puts " -> deleting metadata..."
-          @sdb.destroy(RUDY_DOMAIN, name)
-        end
-        puts "Done."
-      end
-      
-      def create_backup
-        diskname = @argv.first
-        
-        machine = find_current_machine
-        
-        disks = Rudy::MetaData::Disk.list(@sdb, machine[:aws_availability_zone], @global.environment, @global.role, @global.position)
-        raise "The machine #{machine_name} does not have any disk metadata" if disks.empty?
-        
-        puts "Machine: #{machine_name}"
-        
-        if @option.snapshot
-          raise "You must supply a diskname when using an existing snapshot" unless diskname
-          raise "The snapshot #{@option.snapshot} does not exist" unless @ec2.snapshots.exists?(@option.snapshot)
-          disk = Rudy::MetaData::Disk.get(@sdb, diskname)
-          
-          raise "The disk #{diskname} does not exist" unless disk
-          backup = Rudy::MetaData::Backup.new
-          backup.awsid = @option.snapshot
-          backup.time_stamp
-            
-          # Populate machine infos
-          [:zone, :environment, :role, :position].each do |n|
-            backup.send("#{n}=", @global.send(n)) if @global.send(n)
-          end
-        
-          # Populate disk infos
-          [:path, :size].each do |n|
-            backup.send("#{n}=", disk.send(n)) if disk.send(n)
-          end
-          
-          
-          Rudy::MetaData::Backup.save(@sdb, backup)
-          
-          puts backup.name
-          
-        else
-          volumes = @ec2.instances.volumes(machine[:aws_instance_id])
-          raise "The machine #{machine_name} does not have any volumes attached." if volumes.empty?
-          
-          puts "#{disks.size} Disk(s) defined with #{volumes.size} Volume(s) running"
-        
-          volumes.each do |volume|
-            print "Volume #{volume[:aws_id]}... "
-            disk = Rudy::MetaData::Disk.find_from_volume(@sdb, volume[:aws_id])
-            backup = Rudy::MetaData::Backup.new
-          
-            # TODO: Look for the disk based on the machine
-            raise "No disk associated to volume #{volume[:aws_id]}" unless disk 
-          
-            backup.volume = volume[:aws_id]
-
-            # Populate machine infos
-            [:zone, :environment, :role, :position].each do |n|
-              backup.send("#{n}=", @global.send(n)) if @global.send(n)
-            end
-
-            # Populate disk infos
-            [:path, :size].each do |n|
-              backup.send("#{n}=", disk.send(n)) if disk.send(n)
-            end
-            
-            backup.time_stamp
-            
-            raise "There was a problem creating the backup metadata" unless backup.valid?
-            
-            snap = @ec2.snapshots.create(volume[:aws_id])
-          
-            if !snap || !snap.is_a?(Hash)
-              puts "There was an unknown problem creating #{backup.name}. Continuing with the next volume..."
-              next
-            end
-            
-            backup.awsid = snap[:aws_id]
-
-            Rudy::MetaData::Backup.save(@sdb, backup)
-
-            puts backup.name
-            
-          end
-        end          
-      end
-      
-      
-    end
-  end
-end

data/lib/rudy/cli/domains.rb

@@ -1,17 +0,0 @@
-
-
-module Rudy
-  module CLI
-    class Domains < Rudy::CLI::Base
-      
-      
-      def domains
-        puts "Domains".bright, $/
-        
-        rdom = Rudy::Domains.new(:config => @config, :global => @global)
-        puts rdom.list
-      end
-      
-    end
-  end
-end

data/lib/rudy/cli/groups.rb

@@ -1,77 +0,0 @@
-
-#
-#
-module Rudy
-  module CLI
-    class Groups < Rudy::CLI::Base
-      
-      def group
-        puts "Machine Groups".bright
-        opts = {}
-        name = @option.all ? nil : @argv.name
-        rudy = Rudy::Groups.new(:config => @config, :global => @global)
-        rudy.list(name).each do |grp|
-          puts '-'*60
-          puts grp.to_s
-        end
-      end
-      
-      def destroy_group_valid?
-        @rgroup = Rudy::Groups.new(:config => @config, :global => @global)
-        raise "Group #{@rgroup.name(@argv.name)} does not exist" unless @rgroup.exists?(@argv.name)
-        true
-      end
-      
-      def destroy_group
-        puts "Destroying Machine Group".bright
-        opts = {}
-        puts "Destroying group: #{@rgroup.name(@argv.name)}"
-        exit unless Annoy.are_you_sure?(:medium)
-        
-        @rgroup.destroy(@argv.name)
-        puts "Done!"
-      end
-      
-      def create_group
-        puts "Creating Machine Group".bright
-        opts = check_options
-        exit unless Annoy.are_you_sure?(:medium)
-        rudy = Rudy::Groups.new(:config => @config, :global => @global)
-        rudy.create(@argv.name, nil, opts)
-        rudy.list(@argv.name)
-      end
-      
-      def revoke_group
-        puts "Revoke Machine Group Rule".bright
-        opts = check_options
-        exit unless Annoy.are_you_sure?(:medium)
-        rudy = Rudy::Groups.new(:config => @config, :global => @global)
-        rudy.revoke(@argv.name, opts)
-        rudy.list(@argv.name)
-      end
-      
-      def authorize_group
-        puts "Authorize Machine Group Rule".bright
-        opts = check_options
-        exit unless Annoy.are_you_sure?(:medium)
-        rudy = Rudy::Groups.new(:config => @config, :global => @global)
-        rudy.authorize(opts)
-        rudy.list(opts)
-      end
-
-      
-    private
-      
-      def check_options
-        opts = {}
-        [:addresses, :protocols, :owner, :group, :ports].each do |opt|
-          opts[opt] = @option.send(opt) if @option.respond_to?(opt)
-        end
-        opts[:ports].collect! { |port| port.split(/:/) } if opts[:ports]
-        opts
-      end
-      
-    end
-  end
-end
-

data/lib/rudy/cli/images.rb

@@ -1,111 +0,0 @@
-
-
-module Rudy
-  module CLI
-    class Images < Rudy::CLI::Base
-      
-
-      def images
-        @ec2.images.list.each do |img|
-          print_image img
-        end
-      end
-      
-      def create_images_valid?
-        puts "Make sure the machine is clean. I don't want archive no crud!"
-        switch_user("root")
-        
-          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)
-        true
-      end
-      
-      
-      def prepare_images
-        # TODO: Avail hooks for clean an instance
-        # Clean off Rudy specific crap. 
-      end
-      
-      
-      def create_images
-        puts "Creating image from #{machine_group}"
-        
-        # ~/.rudy, /etc/motd, history -c, /etc/hosts, /var/log/rudy*
-        
-        exit unless Annoy.are_you_sure?(:medium)
-        
-        
-        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"
-        
-        @option.account ||= @config.accounts.aws.accountnum
-        
-        unless @option.account
-          puts "Enter your 12 digit Amazon account number:"
-          @global.account = gets.chomp
-        end
-        
-        unless @option.image_name
-          puts "Enter the image name:"
-          @option.image_name = gets.chomp
-        end
-        
-        unless @option.bucket_name
-          puts "Enter the S3 bucket that will store the image:"
-          @option.bucket_name = gets.chomp
-        end
-        
-        unless @option.print
-          puts "Copying .pem keys to /mnt (they will not be included in the AMI)"
-          scp_command machine[:dns_name], keypairpath, @global.user, @global.cert, "/mnt/"
-          scp_command machine[:dns_name], keypairpath, @global.user, @global.privatekey, "/mnt/"
-        end
-        
-        ssh do |session|
-          session.exec!("touch /root/firstrun")
-        end
-        
-        puts "Starting bundling process...".bright
-        puts ssh_command(machine[:dns_name], keypairpath, @global.user, "ec2-bundle-vol -r i386 -p #{@option.image_name} -k /mnt/pk-*pem -c /mnt/cert*pem -u #{@option.account}", @option.print)
-        puts ssh_command(machine[:dns_name], keypairpath, @global.user, "ec2-upload-bundle -b #{@option.bucket_name} -m /tmp/#{@option.image_name}.manifest.xml -a #{@global.accesskey} -s #{@global.secretkey}", @option.print)
-
-        @ec2.images.register("#{@option.bucket_name}/#{@option.image_name}.manifest.xml") unless @option.print
-      end
-      
-      def deregister
-        ami = @argv.first
-        raise "You must supply an AMI ID (ami-XXXXXXX)" unless ami
-        puts "Deregistering AMI: #{ami}"
-        
-        exit unless Annoy.are_you_sure?
-        
-        if @ec2.images.deregister(ami)
-          puts "Done!"
-        else
-          puts "There was an unknown problem!"
-        end
-        
-      end
-      
-      
-      def print_image(img)
-        puts '-'*60
-        puts "Image: #{img[:aws_id].bright}"
-        img.each_pair do |key, value|
-           printf(" %22s: %s#{$/}", key, value) if value
-         end
-        puts
-      end
-      
-      
-      
-    end
-  end
-end
-

data/lib/rudy/cli/instances.rb

@@ -1,142 +0,0 @@
-
-
-module Rudy::CLI
-  class Instances < Rudy::CLI::Base
-    
-    def connect
-      puts "Rudy Connect".bright
-
-      if @argv.cmd
-        @argv.cmd = [@argv.cmd].flatten.join(' ')
-        if @global.user.to_s == "root"
-          exit unless Annoy.are_you_sure?(:medium)
-        end
-      end
-      
-      rudy = Rudy::Instances.new(:config => @config, :global => @global)
-      rudy.connect(@option.group, @argv.cmd, @option.awsid, @option.print)
-    end
-
-    def copy_valid?
-      raise "You must supply a source and a target. See rudy #{@alias} -h" unless @argv.size >= 2
-      raise "You cannot download and upload at the same time" if @option.download && @alias == 'upload'
-      true
-    end
-    def copy
-      puts "Rudy Copy".bright
-      opts = {}
-      opts[:group] = @option.group if @option.group
-      opts[:id] = @option.awsid if @option.awsid
-      opts[:id] &&= [opts[:id]].flatten
-      
-      # Is this more clear?
-      @option.recursive && opts[:recursive] = true
-      @option.preserve  && opts[:preserve]  = true
-      @option.print     && opts[:print]     = true
-      
-      
-      opts[:paths] = @argv
-      opts[:dest] = opts[:paths].pop
-      
-      opts[:task] = :download if @alias == 'download' || @option.download
-      opts[:task] = :upload if @alias == 'upload'
-      opts[:task] ||= :upload
-      
-      #exit unless @option.print || Annoy.are_you_sure?(:low)
-      
-      rudy = Rudy::Instances.new(:config => @config, :global => @global)
-      rudy.copy(opts[:group], opts[:id], opts)
-    end
-
-
-    def status
-      puts "Instance Status".bright
-      opts = {}
-      opts[:group] = @option.group if @option.group
-      opts[:state] = @option.state if @option.state
-      
-      # A nil value forces the @ec2.instances.list to return all instances
-      if @option.all
-        opts[:state] = :any
-        opts[:group] = :any
-      end
-      
-      opts[:id] = @argv.awsid if @argv.awsid
-      opts[:id] &&= [opts[:id]].flatten
-      rudy = Rudy::Instances.new(:config => @config, :global => @global)
-      
-      lt = rudy.list(opts[:state], opts[:group], opts[:id]) do |inst|
-        puts '-'*60
-        puts "Instance: #{inst.awsid.bright} (AMI: #{inst.ami})"
-        puts inst.to_s
-      end
-      puts "No instances running" if !lt || lt.empty?
-    end
-    alias :instance :status
-    
-    def console_valid?
-      
-      @rmach = Rudy::Instances.new(:config => @config, :global => @global)
-    end
-    
-    def console
-      puts "Instance Console".bright
-      opts = {}
-      opts[:group] = @option.group if @option.group
-      opts[:id] = @argv.awsid if @argv.awsid
-      opts[:id] &&= [opts[:id]].flatten
-      
-      unless @rmach.any?
-        puts "No instances running"
-        return
-      end
-      
-      console = @rmach.console(opts[:group], opts[:id])
-      
-      if console
-        puts console
-      else
-        puts "Console output is not available"
-      end
-      
-    end
-    
-    
-    def instance_create
-      puts "Create Instance".bright
-      opts = {}
-      [:group, :ami, :address, :itype, :keypair].each do |n|
-        opts[n] = @option.send(n) if @option.send(n)
-      end
-
-      rmach = Rudy::Instances.new(:config => @config, :global => @global)
-      # TODO: Print number of instances running. If more than 0, use Annoy.are_you_sure?
-      rmach.create(opts) do |inst| # Rudy::AWS::EC2::Instance objects
-        puts '-'*60
-        puts "Instance: #{inst.awsid.bright} (AMI: #{inst.ami})"
-        puts inst.to_s
-      end
-    
-    end
-    
-    
-    def instance_destroy
-      puts "Destroy Instances".bright
-      opts = {}
-      opts[:group] = @option.group if @option.group
-      opts[:id] = @argv.awsid if @argv.awsid
-      opts[:id] &&= [opts[:id]].flatten
-      
-      rmach = Rudy::Instances.new(:config => @config, :global => @global)
-      instances = rmach.list(:running, opts[:group], opts[:id])
-      raise "No instances running" if instances.nil? || instances.empty?
-      puts "Destroying #{instances.size} instances in #{instances.first.groups.first}"
-      exit unless Annoy.are_you_sure?(:low)
-      rmach.destroy(opts[:group], opts[:id])
-      puts "Done!"
-    end
-    
-  end
-end
-
-

data/lib/rudy/cli/keypairs.rb

@@ -1,47 +0,0 @@
-
-
-module Rudy
-  module CLI
-    class KeyPairs < Rudy::CLI::Base
-      
-      def create_keypair
-        puts "Create KeyPairs".bright
-        rkey = Rudy::KeyPairs.new(:config => @config, :global => @global)
-        name = @argv.kpname
-        
-        rkey.create(@argv.kpname, :force => false)
-        rkey.list.each do |kp|
-          puts kp.to_s
-        end
-      end
-      
-      
-      def destroy_keypair
-        puts "Destroy KeyPairs".bright
-        rkey = Rudy::KeyPairs.new(:config => @config, :global => @global)
-        raise "KeyPair #{rkey.name(@argv.kpname)} does not exist" unless rkey.exists?(@argv.kpname)
-        kp = rkey.get(@argv.kpname)
-        puts "Destroying keypair: #{kp.name}"
-        puts "NOTE: the private key file will also be deleted and you will not be able to".color(:blue)
-        puts "connect to instances started with this keypair.".color(:blue)
-        exit unless Annoy.are_you_sure?(:low)
-        ret = rkey.destroy(@argv.kpname)
-        puts ret ? "Success" : "Failed"
-      end
-      
-      def keypair
-        puts "KeyPairs".bright
-        rkey = Rudy::KeyPairs.new(:config => @config, :global => @global)
-        
-        rkey.list.each do |kp|
-          puts kp.to_s
-        end
-        
-        puts "No keypairs" unless rkey.any?
-        
-      end
-      
-      
-    end
-  end
-end

data/lib/rudy/cli/manager.rb

@@ -1,51 +0,0 @@
-
-
-module Rudy
-  module CLI
-    class Manager < Rudy::CLI::Base
-      
-      
-      # Print Rudy's metadata to STDOUT
-      def metadata
-        group_metadata.each_pair do |n,h|
-          puts n.bright
-          puts h.inspect, ""
-        end
-      end
-      
-      def destroy_metadata_valid?
-        false
-      end
-      
-      def destroy_metadata
-        @sdb.domains.destroy(RUDY_DOMAIN)
-      end
-      
-      # TODO: WHERE TO CREATE DOMAIN???????????????????????????
-      
-      def create_domain
-        puts "Creating SimpleDB Domain called #{RUDY_DOMAIN}".bright
-        rmanager = Rudy::Manager.new(:config => @config, :global => @global)
-        rmanager.create_domain(RUDY_DOMAIN)
-        doms = rmanager.domains || []
-        puts "Domains: #{doms.join(", ")}"
-      end
-      
-      def info
-        puts "Rudy Manager".bright
-        rmanager = Rudy::Manager.new(:config => @config, :global => @global)
-        doms = rmanager.domains
-        puts "Domains: #{doms.join(", ")}"
-      end
-      
-    private
-      def check_environment
-        raise "No Amazon keys provided!" unless has_keys?
-        raise "No SSH keypairs provided!" unless has_keypair?
-        true
-      end
-      
-    end
-  end
-end
-