knife-rds 0.0.1

data/lib/chef/knife/rds_create.rb

@@ -0,0 +1,23 @@
+require 'chef/knife/rds_base'
+
+class Chef
+  class Knife
+    class RdsCreate < Knife
+
+      '''
+      Create RDS instances.
+      '''
+
+      include Knife::RdsBase
+
+      banner 'knife rds create (args)'
+
+      def run
+        authenticate!
+        puts "Nothign created yet, sorry!"
+      end
+
+
+    end
+  end
+end

data/lib/chef/knife/rds_instance_delete.rb

@@ -0,0 +1,29 @@
+require 'chef/knife/rds_base'
+
+class Chef
+  class Knife
+    class RdsInstanceDelete < Knife
+
+      include Knife::RdsBase
+
+      banner 'knife rds instance delete INSTANCE_NAME'
+
+      def run
+
+        assert_name_args_at_least!(1, "Database identifier required.")
+
+        authenticate!
+
+        confirm("Are you sure you want to delete #{db_instance_id}")
+
+        rds.client.delete_db_instance({db_instance_identifier: db_instance_id, skip_final_snapshot: true})
+
+      end
+
+      def db_instance_id
+        name_args.first
+      end
+
+    end
+  end
+end

data/lib/chef/knife/rds_instance_from_data_bag.rb

@@ -0,0 +1,145 @@
+require 'chef/knife/rds_base'
+
+class Chef
+  class Knife
+    class RdsInstanceFromDataBag < Knife
+
+      include Knife::RdsBase
+      include Knife::RdsBaseDataBag
+
+      option :data_bag_name,
+        :long => '--data-bag-name DATA_BAG_NAME',
+        :description => 'Name of databag containing RDS instances',
+        :default => 'rds_instances'
+
+      require_in_data_bag :engine, :master_username, :master_user_password, :allocated_storage, :db_instance_class
+
+      define_params *[
+        :preferred_backup_window, :engine, :master_username, :master_user_password, :db_instance_class,
+        :backup_retention_period, :allocated_storage, :db_security_groups, :multi_az, :auto_minor_version_upgrade,
+        :db_parameter_group_name, :preferred_maintenance_window, :availability_zone, :iops, :port
+      ]
+
+      banner 'knife rds instance from data bag INSTANCE'
+
+      IGNORE_DIFF = [:master_user_password]
+
+      def run
+
+        assert_name_args_at_least!(1, "DB Instance identifier required")
+
+        assert_data_bag_item_valid!
+
+        authenticate!
+
+        if db_instance.nil?
+          ui.info("The instance #{db_instance_id} does not exit.")
+          confirm("Would you like to create it")
+          create_db_instance!
+          ui.info("Creating RDS instance #{db_instance_id}")
+        else
+          interrupt_unless_available!
+          ui.info("The instance #{db_instance_id} already exists")
+          confirm("Update with data bag values")
+          diff = generate_diff_with_data_bag
+          unless diff.empty?
+            confirm("Apply changes")
+            modify_db_instance!(diff)
+          else
+            ui.info("Your data bag does not contain any differences to instance.")
+          end
+        end
+
+      end
+
+      # Halt task is instance is not available
+      def interrupt_unless_available!
+        if ['creating', 'deleting'].include?(db_instance[:db_instance_status])
+          ui.warn("The instance is currently in the #{db_instance[:db_instance_status]} stage. Please wait until its finished.")
+          exit 0
+        end
+      end
+
+      def skip_parameter?(parameter)
+        IGNORE_DIFF.include?(parameter)
+      end
+      def generate_diff_with_data_bag
+        diff = {}
+        ui.info "Comparing #{data_bag_item_name} with data bag settings..."
+        defined_params.each do |k, v|
+          if skip_parameter?(k)
+            ui.info("Will not update #{k}...")
+            next
+          end
+          if k == :db_parameter_group_name
+            # DB Parameter groups returned from AWS as hash. Needs to be handled separately
+            groups = db_instance[:db_parameter_groups].map { |g| g[:db_parameter_group_name] }
+            if groups.include?(v)
+              ui.info "DB Parameter groups unchanged."
+            else
+              diff[:db_parameter_group_name] = v
+              ui.info "* #{k} differs. data bag #{v} | instance #{groups}"
+            end
+          elsif k == :db_security_groups
+            groups = db_instance[:db_security_groups].map { |g| g[:db_security_group_name] }
+            if (groups - v).empty? && (v - groups).empty?
+              ui.info "DB Security groups unchanged"
+            else
+              ui.info "* #{k} differs. data bag #{v} | instance #{groups.join(', ')}"
+              diff[:db_security_groups] = v
+            end
+          else
+            if v != db_instance[k]
+              diff[k] = v
+              ui.info "* #{k} differs. data bag: #{v} | instance: #{db_instance[k]}"
+            end
+          end
+        end
+        diff
+      end
+
+      def modify_db_instance!(diff = {})
+        params = {db_instance_identifier: db_instance_id}.merge(diff)
+        rds.client.modify_db_instance(params)
+      end
+
+      # Build API call using Data bag methods
+      def create_db_instance!
+        rds.client.create_db_instance(create_params)
+      end
+
+      def create_params
+        { db_instance_identifier: db_instance_id }
+          .merge(defined_params)
+      end
+
+      # Identifier for base data bag methods. Identifies the data bag item
+      #
+      # Returns stringbas
+      def data_bag_item_name
+        db_instance_id
+      end
+
+      # Database instance identifier
+      #
+      # Returns string
+      def db_instance_id
+        name_args.first
+      end
+
+      def db_instance
+        unless @db_instance
+          begin
+            @db_instance = rds.client.describe_db_instances(db_instance_identifier: db_instance_id)
+            @db_instance = @db_instance[:db_instances].first
+          rescue AWS::RDS::Errors::DBInstanceNotFound => e
+            @db_instance = nil
+          end
+        end
+        @db_instance
+      end
+
+
+    end
+  end
+end

data/lib/chef/knife/rds_instance_list.rb

@@ -0,0 +1,49 @@
+require 'chef/knife/rds_base'
+
+class Chef
+  class Knife
+    class RdsInstanceList < Knife
+
+      '''
+      List RDS instances.
+      '''
+
+      # Key = attribute of DBInstance. Value = label to display
+
+      INSTANCE_INFO = {
+        id: 'ID',
+        status: 'Status',
+        db_name: 'DB Name',
+        engine: 'Engine',
+        engine_version: 'Engine Version',
+        iops: 'IOPS',
+        master_username: 'Master Username',
+        multi_az: 'Multi-AZ?',
+        endpoint_address: 'Endpoint',
+        created_at: 'Created At',
+        size: 'Size (GB)',
+        availability_zone_name: 'AZ',
+        db_instance_class: 'Instance Type',
+
+      }
+
+      include Knife::RdsBase
+
+      banner 'knife rds instance list (args)'
+
+      def run
+        authenticate!
+        rds.db_instances.each { |instance| present_instance(instance) }
+      end
+
+      def present_instance(instance)
+        ui.info "-----"
+        INSTANCE_INFO.each do |k, v|
+          ui.info("#{v} - #{instance.send(k) || 'n/a'}")
+        end
+        ui.info '-----'
+      end
+
+    end
+  end
+end

data/lib/chef/knife/rds_instance_restore_from_data_bag.rb

@@ -0,0 +1,80 @@
+require 'chef/knife/rds_base'
+
+class Chef
+  class Knife
+    class RdsInstanceRestoreFromDataBag < Knife
+
+      include Knife::RdsBase
+      include Knife::RdsBaseDataBag
+
+      option :data_bag_name,
+        :long => '--data-bag-name DATA_BAG_NAME',
+        :description => 'Name of databag containing RDS instances',
+        :default => 'rds_instances'
+
+      banner 'knife rds instance restore from data bag DB_INSTANCE_ID DB_SNAPSHOT_ID'
+
+      define_params *[
+        :port, :availability_zone, :multi_az, :auto_minor_version_upgrade,
+        :db_name, :license_model, :iops, :engine, :option_group_name, :parameter_group_name
+      ]
+
+      def run
+
+        assert_name_args_at_least!(2)
+
+        assert_data_bag_item_valid!
+
+        authenticate!
+
+        ui.info("You are trying to restore snapshot #{db_snapshot_id} into instance #{db_instance_id}")
+
+        unless db_instance.nil?
+          ui.info("Instance #{db_instance_id} already exists!")
+          exit 1
+        end
+
+        confirm("Restore Instance #{db_instance_id} from #{db_snapshot_id}")
+
+        restore_instance!
+
+        ui.info("Restore #{db_instance_id} from #{db_snapshot_id}")
+
+      end
+
+      def restore_instance!
+        rds.client.restore_db_instance_from_db_snapshot(restore_params)
+      end
+
+      def restore_params
+        { db_instance_identifier: db_instance_id, db_snapshot_identifier: db_snapshot_id }
+          .merge(defined_params)
+      end
+
+      def data_bag_item_name
+        db_instance_id
+      end
+
+      def db_instance_id
+        name_args.first
+      end
+
+      def db_snapshot_id
+        name_args.last
+      end
+
+      def db_instance
+        unless @db_instance
+          begin
+            @db_instance = rds.client.describe_db_instances(db_instance_identifier: db_instance_id)
+            @db_instance = @db_instance[:db_instances].first
+          rescue AWS::RDS::Errors::DBInstanceNotFound => e
+            @db_instance = nil
+          end
+        end
+        @db_instance
+      end
+
+    end
+  end
+end

data/lib/chef/knife/rds_pg_from_data_bag.rb

@@ -0,0 +1,159 @@
+require 'chef/knife/rds_base'
+
+class Chef
+  class Knife
+    class RdsPgFromDataBag < Knife
+
+      '''
+      Create or update a parameter group from data bag configuration.
+      The parameter group you are creating MUST have a data bag entry on your Chef server.
+      The parameter group will be updated if it exists, or created if it does not.
+      '''
+
+      include Knife::RdsBase
+      include Knife::RdsBaseDataBag
+
+      option :data_bag_name,
+        :long => '--data-bag-name DATA_BAG_NAME',
+        :description => 'Name of databag containing RDS instances',
+        :default => 'rds_parameter_groups'
+
+      option :apply_method,
+        :long => '--apply-method METHOD',
+        :description => 'Type of apply method (immediate or pending-reboot)',
+        :default => 'pending-reboot'
+
+      require_in_data_bag :id, :description, :db_parameter_group_family, :parameters
+
+      banner 'knife rds pg from data_bag PG_NAME (args)'
+
+      def run
+
+        assert_name_args_at_least!(1, "Parameter group name is required!")
+
+        assert_data_bag_item_valid!
+
+        assert_valid_apply_method!
+
+        authenticate!
+
+        # Check if exists parameter groups exists. If not, ask to create, and assign parameters
+        if db_parameter_group.nil?
+          ui.info("The parameter group #{db_parameter_group_name} does not exist.")
+          confirm("Would you like to create it")
+          create_db_parameter_group!
+          apply_method = 'immediate'
+        else
+          ui.info("The parameter group #{db_parameter_group_name} exists.")
+          confirm("Would you like to update #{db_parameter_group_name} with apply method #{config[:apply_method]}")
+          apply_method = config[:apply_method]
+        end
+
+        # Reset user parameters no longer present in data bag
+        # Values will be rolled back to default
+        reset_parameters_from_db_parameter_group!(apply_method)
+        # Assign the parameters to the parameter group
+        assign_parameters_to_db_parameter_group!(apply_method)
+
+        # Success
+        ui.info("Assigned parameters to #{db_parameter_group_name}")
+        exit 0
+
+      end
+
+      # Revoke custom db parameters from this group that are not present in data bag
+      # Check the parameters with soure = 'user' that exist on parameter group. If they are NOT in data bag, use reset API call
+      # to roll back to defaults
+      def reset_parameters_from_db_parameter_group!(apply_method)
+        # Params to reset
+        reset_params = []
+        # Get user sources
+        user_params = rds.client.describe_db_parameters(db_parameter_group_name: db_parameter_group_name, source: 'user')
+        user_params[:parameters].each do |p|
+          param_name = p[:parameter_name]
+          unless data_bag_item['parameters'].keys.include?(param_name)
+            ui.info "Revoking #{param_name}"
+            reset_params << { parameter_name: param_name, apply_method: apply_method }
+            if reset_params.length == 20
+              reset_parameters_with_params!(reset_params)
+              reset_params = []
+            end
+          else
+            ui.info "Keeping #{param_name}"
+          end
+        end
+        reset_parameters_with_params!(reset_params) unless reset_params.empty?
+      end
+
+      # Reset specified parameters in parameter group back to defaults
+      #
+      # params - Array of hashes of format {method: APPLY_METHOD, name: PARAMETER_NAME}
+      def reset_parameters_with_params!(params = [])
+        rds.client.reset_db_parameter_group(db_parameter_group_name: db_parameter_group_name, parameters: params)
+      end
+
+      # Assigns all of data bag parameters to the parameter group
+      # AWS API support a maximum of 20 parameters updated in one call
+      def assign_parameters_to_db_parameter_group!(apply_method = 'pending-reboot')
+        params = []
+        data_bag_item['parameters'].each do |k, v|
+          ui.info("Assigning #{k} with value #{v}")
+          params << {parameter_name: k, parameter_value: v.to_s, apply_method: apply_method}
+          if params.length == 20
+            modify_db_parameter_group_with_params!(params)
+            params = []
+          end
+        end
+        modify_db_parameter_group_with_params!(params) unless params.empty?
+      end
+
+      # Modify the parameters of an existing RDS Parameter Group
+      def modify_db_parameter_group_with_params!(params = [])
+        begin
+          rds.client.modify_db_parameter_group(db_parameter_group_name: db_parameter_group_name, parameters: params)
+        rescue AWS::RDS::Errors::InvalidParameterValue => e
+          ui.error "Unable to update this batch parameter values. Please check that your parameters are correct."
+          ui.error "#{params.collect { |p| p[:parameter_name] }.join(', ') } not updated."
+          ui.error "#{e.message}"
+        end
+      end
+
+      # Create a new RDS Parameter group using the provideda data bag
+      def create_db_parameter_group!
+        rds.client.create_db_parameter_group(
+          db_parameter_group_name: db_parameter_group_name,
+          db_parameter_group_family: data_bag_item['db_parameter_group_family'],
+          description: data_bag_item['description']
+        )
+      end
+
+      # The name of the database parameter group, extracted from name arguments
+      #
+      # Returns string
+      def db_parameter_group_name
+        name_args.first
+      end
+
+      # For use with base data bag module.
+      def data_bag_item_name
+        db_parameter_group_name
+      end
+
+      # Load the DB Parameter Group resource from AWS using the API
+      #
+      # Returns AWS::RDS::DBParameterGroup or nil
+      def db_parameter_group
+        unless @db_parameter_group
+          begin
+            @db_parameter_group = rds.client.describe_db_parameter_groups(db_parameter_group_name: db_parameter_group_name)
+          rescue AWS::RDS::Errors::DBParameterGroupNotFound
+            @db_parameter_group = nil
+          end
+          @db_parameter_group
+        end
+      end
+
+
+    end
+  end
+end