pretty_aws 0.0.2

data/bin/rds-instances

@@ -0,0 +1,159 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/pretty_aws'
+require 'thor'
+require 'highline/import'
+
+module PrettyAws
+  
+  class RdsInstancesController < Thor
+    
+    default_task :show
+    
+    desc "classes", "show available instance class sizes"
+    def classes
+      puts RdsInstance::INSTANCE_CLASSES.join(', ')
+    end
+    
+    desc "update <name>", "update instance"
+    method_options :groups => :string, :storage => :string, :class => :string, :delayed => false
+    def update(name)
+      params = {}
+      
+      params[:security_groups]=options[:groups] if options[:groups]
+      params[:allocated_storage]=options[:storage] if options[:storage]
+      params[:instance_class]=options[:class] if options[:class]
+      params[:apply_immediately] = (!options[:delayed])
+      
+      puts "updating #{name} with params:"
+      puts YAML.dump(params)
+      
+      Base.rds.modify_db_instance(name,params)
+      
+    end
+    
+    desc "copy <source> <target> --class=<class>", 'copy database from lastest restore time'
+    method_option :class, :type => :string, :required => true
+    def copy(source, target)
+      params={}
+      params[:use_latest_restorable_time] = true
+      params[:instance_class] = options[:class]
+      params[:availability_zone] = 'us-east-1a'
+      puts "Copying #{source} as #{target} with class #{options[:class]}"
+      Base.rds.restore_db_instance_to_point_in_time(source,target,params)
+    end
+    
+    desc "create", "create instances"
+    def create(arg=nil)
+      name = ask("What is the database named? (a-z only) ")
+      instance_class = choose do |menu|
+        menu.prompt = "Select a DB Size:"
+        RdsInstance::INSTANCE_CLASSES.each do |class_name|
+          menu.choice(class_name)
+        end
+      end
+      storage = ask("How much storage? (gb) ", Integer) { |q| q.in 5..500 }
+      username = ask("Username? ")
+      password = ask("Password? ") { |q| q.echo = "x" }
+      
+      puts "creating database with params:"
+      p '', 'name', name
+      p '', 'class', instance_class
+      p '', 'storage', storage
+      p '', 'username', username
+      p '', 'password', password
+      
+      RdsInstance.create(
+        :name => name, 
+        :instance_class => instance_class,
+        :storage => storage,
+        :username => username,
+        :password => password
+      )
+      
+
+    end
+    
+    desc "delete <name>", "delete named db"
+    def delete(name)
+      say("You are about to delete the database: #{name}")
+      yes = ask("Are you sure? (yes) ")
+      if yes=='yes'
+        RdsInstance.delete(name)
+        puts "delete!"
+      else
+        puts "abort"
+      end
+    end
+    
+    desc "console [name]", 'log into mysql console'
+    def console(name)
+      item = RdsInstance.find(name)
+      exec "mysql -u #{item.username} -h #{item.address} -p"
+    end
+    
+    desc "show [name]", 'show instances'
+    method_options :verbose => false
+    def show(name=nil)
+      if name.nil?
+        items = RdsInstance.all
+      else
+        items = [RdsInstance.find(name)]
+      end
+      if options[:verbose]
+        puts YAML.dump(items.map(&:params))
+      end
+      puts "\n\n"
+      items.each do |item|
+        p('----->', item.name)
+        puts ""
+        p('', 'status', item.status)
+        p('', 'address', item.address)
+        p('', 'cpu size', item.cpu_size)
+        p('', 'storage', "#{item.storage}G")
+        p('', 'zone', item.zone)
+        p('', 'username', item.username)
+        p '', 'engine', item.engine
+        p '', 'created at', item.created_at  
+        p '', 'restorable at', item.restorable_at
+        p '', 'backup period', item.backup_period
+        p '', 'backup window', item.backup_window
+        p '', 'mod window', item.mod_window
+
+        puts "\n\n"
+      end
+      
+      
+    end
+    
+    no_tasks do
+      
+      def print_header
+        # show the account
+        
+      end
+      
+      def p(gutter,col1='',col2='',col3='')
+        $stdout.printf("%-8s %-20s %-20s %-20s\n",gutter,col1,col2,col3)
+      end
+      def row(*cols)
+        prepend = cols.find { |c| c.is_a?(Hash) and c.has_key?(:prepend) }
+        if prepend.nil?
+          prepend = ''
+        else
+          cols.delete(prepend)
+          prepend = prepend[:prepend]
+        end
+        output = [ sprintf("%-8s",prepend) ]
+        cols.each do |col|
+          output << sprintf("%-20s", col)
+        end
+        output = output.join(" ") + "\n"
+        $stdout.print(output)
+      end
+    end
+  end
+  
+end
+
+PrettyAws::RdsInstancesController.start

data/bin/rds-security-groups

@@ -0,0 +1,117 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/pretty_aws'
+require 'thor'
+# require 'highline/import'
+
+module PrettyAws
+  
+  class RdsSecurityGroupsController < Thor
+    
+    default_task :list
+    
+    desc "create <name> --description", "create security group"
+    method_option :description, :type=>:string, :required=>true
+    def create(group_name)
+      Base.rds.create_db_security_group(group_name,options[:description])
+      puts "\n\n"
+      row group_name, 'created!'
+      puts "\n\n"
+    end
+    
+    desc "delete <name>", "delete security group"
+    def delete(group_name)
+      Base.rds.delete_db_security_group(group_name)
+      puts "\n\n"
+      row group_name, 'deleted!'
+      puts "\n\n"
+    end
+    
+    desc "revoke <group_name>", "revoke ingress for group"
+    method_options :ip => :string, :name => :string, :owner => :string
+    def revoke(group_name)
+      if ip_range=options[:ip]
+        Base.rds.revoke_db_security_group_ingress_overwrite(group_name,:cidrip=>ip_range)
+        puts "\n\n"
+        row group_name, 'revoke ip', ip_range
+        puts "\n\n"
+      end
+      if (name=options[:name]) and (owner=options[:owner])
+        Base.rds.revoke_db_security_group_ingress(group_name,:ec2_group_name=>name,:ec2_group_owner_id=>owner)
+        puts "\n\n"
+        row group_name, 'revoke ec2', name, owner
+        puts "\n\n"
+      end
+    end
+    
+    desc "authorize <group_name> [--ip=ip range] [--name=ec2 group name] [--owner=ec2 owner]", "authorize ingress for group"
+    method_options :ip => :string, :name => :string, :owner => :string
+    def authorize(group_name)
+      if ip_range=options[:ip]
+        Base.rds.authorize_db_security_group_ingress(group_name,:cidrip=>ip_range)
+        puts "\n\n"
+        row group_name, 'authorize ip', ip_range
+        puts "\n\n"
+      end
+      if (name=options[:name]) and (owner=options[:owner])
+        Base.rds.authorize_db_security_group_ingress(group_name,:ec2_group_name=>name,:ec2_group_owner_id=>owner)
+        puts "\n\n"
+        row group_name, 'authorize ec2', name, owner
+        puts "\n\n"
+      end
+    end
+    
+    desc "list [name]", 'show security groups'
+    method_options :verbose => :boolean
+    def list
+      
+      items = Base.rds.describe_db_security_groups
+      
+      if options[:verbose]
+        puts YAML.dump(items)
+      end
+      
+      puts "\n\n\n\n"
+      
+      items.each do |item|
+        row item[:db_security_group_name], :prepend => '~~~~~>'
+        row ""
+        row 'owner', item[:owner_id]
+        row 'description', item[:db_security_group_description]
+        row ''
+        row 'ec2 groups', 'Name', 'Owner', 'Status'
+        item[:ec2_security_groups].each do |group|
+          row '', group[:ec2_security_group_name], group[:ec2_security_group_owner_id], group[:status]
+        end
+        row ''
+        row 'ip ranges', 'Range', 'Status'
+        item[:ip_ranges].each do |ip_range|
+          row '', ip_range[:cidrip], ip_range[:status]
+        end
+        puts "\n\n"
+      end
+      
+    end
+    
+    no_tasks do
+      def row(*cols)
+        prepend = cols.find { |c| c.is_a?(Hash) and c.has_key?(:prepend) }
+        if prepend.nil?
+          prepend = ''
+        else
+          cols.delete(prepend)
+          prepend = prepend[:prepend]
+        end
+        output = [ sprintf("%-8s",prepend) ]
+        cols.each do |col|
+          output << sprintf("%-20s", col)
+        end
+        output = output.join(" ") + "\n"
+        $stdout.print(output)
+      end
+    end
+  end
+  
+end
+
+PrettyAws::RdsSecurityGroupsController.start

data/bin/rds-snapshots

@@ -0,0 +1,89 @@
+#!/usr/bin/env ruby
+
+require File.dirname(__FILE__) + '/../lib/pretty_aws'
+require 'thor'
+require 'highline/import'
+
+module PrettyAws
+  
+  class RdsSnapshotsController < Thor
+    
+    default_task :list
+    
+    desc "list", 'list all snapshots'
+    def list
+      groups = RdsSnapshot.find_all_and_group
+      
+      puts "\n\n"
+      groups.each do |name, items|
+        row(name, :prepend => '~~~~>')
+        puts ''
+        row('name', 'status','size','created_at')
+        items.each do |item|
+          row(item.id, item.status, item.storage+"G", item.created_at)
+        end
+        puts "\n\n"
+      end
+    end
+    
+    desc "restore <snapshot id> <new db id>", "create new database from snapshot"
+    method_option :class, :type => :string, :required => true
+    def restore(id, db_id)
+      puts "\n\n"
+      puts "Restoring #{id} as #{db_id} with class #{options[:class]}"
+      puts "\n\n"
+      Base.rds.restore_db_instance_from_db_snapshot(id,db_id,options[:class])
+    end
+    
+    desc "create <db id> <snapshot id>", 'take snapshot of db'
+    def create(db_id, id)
+      puts "\n\n"
+      puts "Taking snapshot of #{db_id} as #{id}"
+      puts "\n\n"
+      Base.rds.create_db_snapshot(db_id,id)
+    end
+    
+    desc "delete <snapshot id>", 'delete snapshot'
+    def delete(id)
+      puts "\n\n"
+      say("You are about to delete the snapshot: #{id}")
+      yes = ask("Are you sure? (yes) ")
+      if yes=='yes'
+        Base.rds.delete_db_snapshot(id)
+        puts "delete!"
+      else
+        puts "abort"
+      end
+    end
+    
+    no_tasks do
+      
+      def print_header
+        # show the account
+        
+      end
+      
+      def p(gutter,col1='',col2='',col3='')
+        $stdout.printf("%-8s %-20s %-20s %-20s\n",gutter,col1,col2,col3)
+      end
+      def row(*cols)
+        prepend = cols.find { |c| c.is_a?(Hash) and c.has_key?(:prepend) }
+        if prepend.nil?
+          prepend = ''
+        else
+          cols.delete(prepend)
+          prepend = prepend[:prepend]
+        end
+        output = [ sprintf("%-8s",prepend) ]
+        cols.each do |col|
+          output << sprintf("%-20s", col)
+        end
+        output = output.join(" ") + "\n"
+        $stdout.print(output)
+      end
+    end
+  end
+  
+end
+
+PrettyAws::RdsSnapshotsController.start

data/lib/pretty_aws/ext.rb

@@ -0,0 +1,96 @@
+module PrettyAws
+  module ExtendRds
+    
+    def restore_db_instance_to_point_in_time(source,target,opts={})
+      params={}
+      params['SourceDBInstanceIdentifier'] = source
+      params['TargetDBInstanceIdentifier'] = target
+      params['UseLatestRestorableTime']=opts[:use_latest_restorable_time] if opts[:use_latest_restorable_time]
+      params['DBInstanceClass']=opts[:instance_class] if opts[:instance_class]
+      params['AvailabilityZone']=opts[:availability_zone] if opts[:availability_zone]
+      link = do_request("RestoreDBInstanceToPointInTime", params)
+    rescue Exception
+      on_exception
+    end
+    
+    def restore_db_instance_from_db_snapshot(snapshot_id, db_id, instance_class)
+      params={}
+      params['DBSnapshotIdentifier']=snapshot_id
+      params['DBInstanceIdentifier']=db_id
+      params['DBInstanceClass']=instance_class
+      params['AvailabilityZone']='us-east-1a'
+      link = do_request("RestoreDBInstanceFromDBSnapshot", params)
+    rescue Exception
+      on_exception
+    end
+    
+    def describe_db_snapshots
+      link = do_request('DescribeDBSnapshots',{},:pull_out_array=>[:describe_db_snapshots_result, :db_snapshots, :db_snapshot])
+    rescue Exception
+      on_exception
+    end
+    
+    def create_db_snapshot( db_id, snapshot_id )
+
+      params = {}
+      params['DBSnapshotIdentifier'] = snapshot_id
+      params['DBInstanceIdentifier'] = db_id
+      link = do_request("CreateDBSnapshot", params)
+    rescue Exception
+      on_exception
+    end
+    
+    def delete_db_snapshot(id)
+      params = {}
+      params['DBSnapshotIdentifier'] = id
+      link=do_request('DeleteDBSnapshot',params)
+    rescue Exception
+      on_exception
+    end
+    
+    def modify_db_instance(identifier, options={})
+      params = {}
+      params['DBInstanceIdentifier']=identifier
+      params['DBSecurityGroups']=options[:security_groups] if options[:security_groups]
+      params['AllocatedStorage']=options[:allocated_storage] if options[:allocated_storage]
+      params['DBInstanceClass']=options[:instance_class] if options[:instance_class]
+      params['ApplyImmediately']=options[:apply_immediately]
+      link = do_request("ModifyDBInstance",params)
+    rescue Exception
+      on_exception
+    end
+    
+    def revoke_db_security_group_ingress_overwrite(group_name, options={})
+        params = {}
+        params['DBSecurityGroupName'] = group_name
+        if options[:ec2_group_name]
+          params['EC2SecurityGroupName'] = options[:ec2_group_name]
+          params['EC2SecurityGroupOwnerId'] = options[:ec2_group_owner_id]
+        end
+        if options[:cidrip]
+          params['CIDRIP'] = options[:cidrip]
+        end
+        link = do_request("RevokeDBSecurityGroupIngress", params)
+    rescue Exception
+        on_exception
+    end
+    def authorize_db_security_group_ingress(group_name, options={})
+        params = {}
+        params['DBSecurityGroupName'] = group_name
+        if options[:ec2_group_name]
+          params['EC2SecurityGroupName'] = options[:ec2_group_name]
+          params['EC2SecurityGroupOwnerId'] = options[:ec2_group_owner_id]
+        end
+        if options[:cidrip]
+          params['CIDRIP'] = options[:cidrip]
+        end
+        link = do_request("AuthorizeDBSecurityGroupIngress", params)
+    rescue Exception
+        on_exception
+    end
+  end
+end
+
+Aws::Rds.class_eval do
+  include PrettyAws::ExtendRds
+end

data/lib/pretty_aws/rds_instance.rb

@@ -0,0 +1,138 @@
+module PrettyAws
+  
+  class NotFound < StandardError; end
+  class RdsInstance
+    
+    INSTANCE_CLASSES = [ 'db.m1.small', 'db.m1.large', 'db.m1.xlarge', 'db.m2.2xlarge', 'db.m2.4xlarge' ]
+    
+    def self.find(name)
+      params = Base.rds.describe_db_instances.detect { |params| params[:db_instance_identifier]==name }
+      if params.nil?
+        raise PrettyAws::NotFound
+      end
+      new(params)
+    end
+    
+    def self.all
+      Base.rds.describe_db_instances.collect { |params| new(params) }
+    end
+    
+    def self.wait_until(name, state)
+      $stdout.printf("%-8s %-25s", "-----|"," waiting for #{name} to be #{state} ")
+      while true
+        begin
+          item = find(name)
+        rescue
+          item = {:db_instance_status => nil}
+        end
+        if item[:db_instance_status]==state
+          $stdout.puts("done")
+          $stdout.flush
+          return true
+        else
+          $stdout.print('.')
+          $stdout.flush
+          sleep(3)
+        end
+      end
+    end
+    
+    def self.create(params={})
+      required_params = [ :name, :instance_class, :storage, :username, :password ]
+      required_params.each { |key| raise "#{key} required" unless params.has_key?(key) }
+      Base.rds.create_db_instance(
+        params[:name], 
+        params[:instance_class], 
+        params[:storage], 
+        params[:username],
+        params[:password],
+        :availability_zone => 'us-east-1a'
+      )
+      RdsInstance.wait_until(params[:name], 'available')
+    end
+    
+    def self.delete(name)
+      Base.rds.delete_db_instance(name)
+    end
+    
+    attr_reader :params
+    
+    def initialize(params)
+      @params=params
+    end
+    
+    def name
+      @params[:db_instance_identifier]
+    end
+    
+    def status
+      @params[:db_instance_status]
+    end
+    
+    def address
+      if @params.has_key?(:endpoint) and @params[:endpoint].is_a?(Hash) and @params[:endpoint].has_key?(:address)
+        @address = @params[:endpoint][:address]
+      else
+        @address = nil
+      end
+      @address
+    end
+    
+    def cpu_size
+      @params[:db_instance_class]
+    end
+    
+    def storage
+      @params[:allocated_storage]
+    end
+    
+    def zone
+      @params[:availability_zone]
+    end
+    
+    def username
+      @params[:master_username]
+    end
+    
+    def engine
+      @params[:engine]
+    end
+    
+    def security_groups
+      security_groups = [ ]
+      item[:db_security_groups].each do |group|
+        p('', '', group[:db_security_group_name], group[:status])
+      end
+    end
+    
+    def created_at
+      @params[:instance_create_time]
+    end
+    
+    def restorable_at
+      @params[:latest_restorable_time]
+    end
+    
+    def backup_period
+      @params[:backup_retention_period]
+    end
+    
+    def backup_window
+      @params[:preferred_backup_window]
+    end
+    
+    def mod_window
+      @params[:preferred_maintenance_window]
+    end
+    
+    def [](name)
+      @params[name]
+    end
+    
+    def has_key?(name)
+      @params.has_key?(name)
+    end
+    
+  end
+  
+end

data/lib/pretty_aws/rds_snapshot.rb

@@ -0,0 +1,61 @@
+module PrettyAws
+  class RdsSnapshot
+    
+    attr_reader :params
+    
+    def self.find_all_and_group
+      group_by_db(all)
+    end
+    
+    def self.all
+      Base.rds.describe_db_snapshots.collect { |params| new(params) }
+    end
+    
+    def self.group_by_db(items)
+      if items.nil?
+        return {}
+      end
+      grouped = { }
+      items.each do |item|
+        grouped[item.db_id] ||= [ ]
+        grouped[item.db_id] << item
+      end
+      grouped
+    end
+    
+    def initialize(params)
+      @params=params
+    end
+    
+    def id
+      @params[:db_snapshot_identifier]
+    end
+    
+    def storage
+      @params[:allocated_storage]
+    end
+    
+    def db_id
+      @params[:db_instance_identifier]
+    end
+    
+    def created_at
+      @params[:instance_create_time]
+    end
+    
+    def status
+      @params[:status]
+    end
+     
+  end
+end
+
+# {:status=>"creating",
+#  :availability_zone=>"us-east-1a",
+#  :db_snapshot_identifier=>"fidupsnapshot",
+#  :engine=>"mysql5.1",
+#  :instance_create_time=>"2010-04-26T03:59:18.967Z",
+#  :port=>"3306",
+#  :allocated_storage=>"30",
+#  :db_instance_identifier=>"fidup",
+#  :master_username=>"fi"}

data/lib/pretty_aws.rb

@@ -0,0 +1,27 @@
+
+require 'rubygems'
+require 'aws'
+require 'yaml'
+require 'pp'
+require 'pathname'
+require 'fileutils'
+
+require File.dirname(__FILE__) + '/pretty_aws/rds_instance'
+require File.dirname(__FILE__) + '/pretty_aws/rds_snapshot'
+require File.dirname(__FILE__) + '/pretty_aws/ext'
+
+module PrettyAws
+  class Base
+    class << self
+      def root
+        @root ||= Pathname.new(File.expand_path('~/.pretty_aws'))
+      end
+      def config
+        @config ||= YAML.load(File.read(root.join('pretty_aws.yml')))
+      end
+      def rds
+        @rds ||= Aws::Rds.new(config['aws_access_key'],config['aws_secret_key'])
+      end
+    end
+  end
+end

metadata

@@ -0,0 +1,106 @@
+--- !ruby/object:Gem::Specification 
+name: pretty_aws
+version: !ruby/object:Gem::Version 
+  hash: 27
+  prerelease: false
+  segments: 
+  - 0
+  - 0
+  - 2
+  version: 0.0.2
+platform: ruby
+authors: 
+- David Crockett
+autorequire: 
+bindir: bin
+cert_chain: []
+
+date: 2010-03-11 00:00:00 -08:00
+default_executable: 
+dependencies: 
+- !ruby/object:Gem::Dependency 
+  name: aws
+  prerelease: false
+  requirement: &id001 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 11
+        segments: 
+        - 2
+        - 2
+        - 6
+        version: 2.2.6
+  type: :runtime
+  version_requirements: *id001
+- !ruby/object:Gem::Dependency 
+  name: thor
+  prerelease: false
+  requirement: &id002 !ruby/object:Gem::Requirement 
+    none: false
+    requirements: 
+    - - "="
+      - !ruby/object:Gem::Version 
+        hash: 35
+        segments: 
+        - 0
+        - 13
+        - 4
+        version: 0.13.4
+  type: :runtime
+  version_requirements: *id002
+description: Pretty AWS
+email: davy@davcro.com
+executables: 
+- rds-instances
+- rds-security-groups
+- rds-snapshots
+extensions: []
+
+extra_rdoc_files: []
+
+files: 
+- lib/pretty_aws/ext.rb
+- lib/pretty_aws/rds_instance.rb
+- lib/pretty_aws/rds_snapshot.rb
+- lib/pretty_aws.rb
+- bin/rds-instances
+- bin/rds-security-groups
+- bin/rds-snapshots
+has_rdoc: true
+homepage: 
+licenses: []
+
+post_install_message: 
+rdoc_options: []
+
+require_paths: 
+- lib
+required_ruby_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+required_rubygems_version: !ruby/object:Gem::Requirement 
+  none: false
+  requirements: 
+  - - ">="
+    - !ruby/object:Gem::Version 
+      hash: 3
+      segments: 
+      - 0
+      version: "0"
+requirements: []
+
+rubyforge_project: 
+rubygems_version: 1.3.7
+signing_key: 
+specification_version: 3
+summary: Davcro AWS
+test_files: []
+