Merge pull request #23 from CU-CloudCollab/lambda-rds

Lambda rds

Author: bharanin

README.md

@@ -48,6 +48,7 @@ Note - the cucloud library assumes that environment credentials are available to
 Utilities that use this API:
 
 * Autoscale AMI Updater: https://github.com/CU-CloudCollab/asg-ami-update
+* Collection of Handy Cloud Utilities: https://github.com/CU-CloudCollab/cucloud_utils
 
 
 ## Development

lib/cucloud.rb

@@ -13,6 +13,8 @@ module Cucloud
   require 'cucloud/config_service_utils'
   require 'cucloud/cloud_trail_utils'
   require 'cucloud/rds_utils'
+  require 'cucloud/lambda_utils'
+  require 'cucloud/cfn_utils'
 
   # This is the default region API calls are made against
   DEFAULT_REGION = 'us-east-1'.freeze

lib/cucloud/cfn_utils.rb

@@ -0,0 +1,50 @@
+module Cucloud
+  # CFNUtils - Utilities for CloudFormation
+  class CfnUtils
+    # Define some error classes
+    class UnknownServiceError < StandardError
+    end
+
+    def initialize(cfn = Aws::CloudFormation::Client.new)
+      @cfn = cfn
+    end
+
+    # Create cloud formation stack from template
+    # @param stack_name [string] name of the the cfn stack
+    # @param template_json [string] file path to cfn template json
+    # @return [String] representing the stack events from the run
+    def create_stack(stack_name, template_json)
+      manage_stack(stack_name, template_json)
+    end
+
+    # Update cloud formation stack from template
+    # @param stack_name [string] name of the the cfn stack
+    # @param template_json [string] file path to cfn template json
+    # @return [String] representing the stack events from the run
+    def update_stack(stack_name, template_json)
+      manage_stack(stack_name, template_json, :update_stack)
+    end
+
+    private
+
+    # Manage cloud formation stack from template,
+    # abstracts logic for both the create and update
+    # @param stack_name [string] name of the the cfn stack
+    # @param template_json [string] file path to cfn template json
+    # @return [String] representing the stack events from the run
+    def manage_stack(stack_name, template_json, action = :create_stack)
+      template = IO.read(template_json)
+
+      response = @cfn.send(action, stack_name: stack_name,
+                                   template_body: template,
+                                   capabilities: %w(CAPABILITY_IAM CAPABILITY_NAMED_IAM))
+
+      raise UnknownServiceError unless response.successful?
+
+      wait_event = action == :create_stack ? :stack_create_complete : :stack_update_complete
+
+      @cfn.wait_until(wait_event, stack_name: stack_name)
+      @cfn.describe_stack_events(stack_name: stack_name)
+    end
+  end
+end

lib/cucloud/elb_utils.rb

@@ -157,5 +157,16 @@ def get_active_keys_older_than_n_days(n)
         get_user_access_keys(user[:base_data].user_name).select { |k| k[:days_old] > n && k[:active] }
       end.flatten
     end
+
+    # Gets the ARN for a given certificate
+    # @param [String] cert_name The name of the certificate
+    # @param [String] The ARN for the certificate
+    # @raise [ArgumentError] If the provided certificate name is nil
+    def get_cert_arn(cert_name)
+      raise ArgumentError, '"cert_name" may not be nil' if cert_name.nil?
+
+      cert = @iam.get_server_certificate(server_certificate_name: cert_name)
+      cert.server_certificate.server_certificate_metadata.arn
+    end
   end
 end

lib/cucloud/iam_utils.rb

@@ -1,10 +1,13 @@
 module Cucloud
   # Utilities library for interacting with KMS.
   class KmsUtils
+    # Class to represent missing key error
     class MissingKmsKey < StandardError
     end
 
+    # This is used in a sttuct to denote an encrypted field
     ENCRYPTED_SUFFIX = '_encrypted'.freeze
+    # This is used in a sttuct to denote an decrypted field
     DECRYPTED_SUFFIX = '_decrypted'.freeze
 
     attr_accessor :kms_key_id

lib/cucloud/kms_utils.rb

@@ -0,0 +1,45 @@
+module Cucloud
+  # LambdaUtils - Utilities for woking with Lambda functions
+  class LambdaUtils
+    require 'open-uri'
+
+    # Constructor for LambdaUtils class
+    # @param lambda_client [Aws::Lambda::Client] AWS Lambda SDK Client
+    def initialize(lambda_client = Aws::Lambda::Client.new)
+      @lambda = lambda_client
+    end
+
+    # Download the source pacakge for a given lambda function
+    # @param function_name [String] Name of the lambda function
+    # @param path [String] Local path to write the source pacakge to, defaults to /tmp
+    # @param version [String] Version of the function to download, defaults to $LATEST
+    # @return [String] Local path to the file
+    def download_source_for_function(function_name, path = '/tmp', version = '$LATEST')
+      lambda_function = @lambda.get_function(function_name: function_name,
+                                             qualifier: version)
+
+      file_path = path + '/' + function_name + version + '.zip'
+      File.open(file_path, 'wb') do |saved_file|
+        open(lambda_function[:code][:location], 'rb') do |read_file|
+          saved_file.write(read_file.read)
+        end
+      end
+      file_path
+    end
+
+    # Return all versions of a lambda function
+    # @param function_name [String] Name of the lambda function
+    # @return [Array] Array of strings representing the versions of the lambda function
+    def get_all_versions_for_function(function_name)
+      version_response = @lambda.list_versions_by_function(function_name: function_name)
+      version_response.versions.map { |x| x[:version] }
+    end
+
+    # Return all funtion names for an account
+    # @return [Array] Array of strings representing the function names
+    def get_all_function_names_for_account_region
+      funtions_response = @lambda.list_functions
+      funtions_response.functions.map { |x| x[:function_name] }
+    end
+  end
+end

lib/cucloud/lambda_utils.rb

@@ -1,6 +1,11 @@
 module Cucloud
   # RdsUtils class - for interacting with the AWS relational database service
   class RdsUtils
+    # RDSInstanceAlreadyExist Class - capture erros when creating or restoring
+    # an RDS instance which already exist
+    class RDSInstanceAlreadyExist < StandardError
+    end
+
     def initialize(rds_client = Aws::RDS::Client.new)
       @rds = rds_client
     end
@@ -13,6 +18,69 @@ def get_instance(db_instance_identifier)
       resource.db_instance(db_instance_identifier)
     end
 
+    # Determine if a givne db instance exist
+    # @param db_instance_identifier [String] RDS instance identifier
+    # @return [boolean]
+    def does_db_exist?(db_instance_identifier)
+      get_instance(db_instance_identifier).instance_create_time
+      true
+    rescue Aws::RDS::Errors::DBInstanceNotFound
+      false
+    end
+
+    # Delete a givne db instance
+    # @param db_instance_identifier [String] RDS instance identifier
+    # @param db_snapshot_identifier [String] Name for final snapshot, default is nil
+    def delete_db_instance(db_instance_identifier, db_snapshot_identifier = nil)
+      if does_db_exist?(db_instance_identifier)
+        if db_snapshot_identifier.nil?
+          @rds.delete_db_instance(db_instance_identifier: db_instance_identifier, skip_final_snapshot: true)
+        else
+          @rds.delete_db_instance(db_instance_identifier: db_instance_identifier,
+                                  final_db_snapshot_identifier: db_snapshot_identifier)
+        end
+
+        @rds.wait_until(:db_instance_deleted, db_instance_identifier: db_instance_identifier)
+      else
+        raise Aws::RDS::Errors::DBInstanceNotFound.new(db_instance_identifier, '')
+      end
+    end
+
+    # Restore DB from a snapshot
+    # @param db_instance_identifier [String] RDS instance identifier
+    # @param db_snapshot_identifier [String] Name for final snapshot, default is nil
+    def restore_db(db_instance_identifier, restore_from, options = {})
+      raise RDSInstanceAlreadyExist if does_db_exist?(db_instance_identifier)
+
+      db_snapshot_identifier =
+        options[:db_snapshot_identifier].nil? ? find_latest_snapshot(restore_from) : options[:db_snapshot_identifier]
+      options[:db_instance_identifier] = db_instance_identifier
+      options[:db_snapshot_identifier] = db_snapshot_identifier
+      @rds.restore_db_instance_from_db_snapshot(options)
+    end
+
+    # Delete a givne db instance
+    # @param db_instance_identifier [String] RDS instance identifier
+    # @return [String] Most recent snapshot ID for given RDS instance
+    def find_latest_snapshot(db_instance_identifier, snapshot_type = 'manual')
+      latest_snapshot_time = Time.new(2002)
+      latest_snap_shot = nil
+      snapshots_info = @rds.describe_db_snapshots(
+        db_instance_identifier: db_instance_identifier, snapshot_type: snapshot_type
+      )[:db_snapshots]
+
+      snapshots_info.each do |snapshot_info|
+        next if snapshot_info[:status] != 'available'
+
+        if latest_snapshot_time.to_i < snapshot_info[:snapshot_create_time].to_i
+          latest_snapshot_time = snapshot_info[:snapshot_create_time].to_i
+          latest_snap_shot = snapshot_info
+        end
+      end
+
+      latest_snap_shot.nil? ? nil : latest_snap_shot[:db_snapshot_identifier]
+    end
+
     # Begins the creation of a snapshot of the given RDS instance.
     # This is a non-blocking call so it will return before the snapshot
     # is created and available.

lib/cucloud/rds_utils.rb

@@ -1,5 +1,5 @@
 module Cucloud
   # Disable mutable constant warning - freezing this oddly breaks bundler
   # rubocop:disable Style/MutableConstant
-  VERSION = '0.7.1'
+  VERSION = '0.7.2'
 end

lib/cucloud/version.rb

@@ -0,0 +1,83 @@
+require 'spec_helper'
+
+describe Cucloud::CfnUtils do
+  let(:cfn_client) do
+    Aws::CloudFormation::Client.new(stub_responses: true)
+  end
+
+  let(:cfn_util) do
+    Cucloud::CfnUtils.new cfn_client
+  end
+
+  let(:template_json) { StringIO.new('some template') }
+
+  context 'while create_stack returns an error' do
+    before do
+      cfn_client.stub_responses(
+        :create_stack,
+        Aws::CloudFormation::Errors::ServiceError.new('', 'test')
+      )
+      cfn_client.stub_responses(
+        :update_stack,
+        Aws::CloudFormation::Errors::ServiceError.new('', 'test')
+      )
+      cfn_client.stub_responses(
+        :describe_stack_events,
+        stack_events: [
+          stack_id: 'stack_id',
+          event_id: 'event_id',
+          stack_name: 'teststack',
+          timestamp: Time.new
+        ]
+      )
+    end
+
+    describe '#create_stack' do
+      it 'raises an error' do
+        allow(IO).to receive(:read).with('file').and_return('some_data')
+        expect { cfn_util.create_stack('teststack', 'file') }.to raise_error Aws::CloudFormation::Errors::ServiceError
+      end
+    end
+
+    describe '#update_stack' do
+      it 'raises an error' do
+        allow(IO).to receive(:read).with('file').and_return('some_data')
+        expect { cfn_util.update_stack('teststack', 'file') }.to raise_error Aws::CloudFormation::Errors::ServiceError
+      end
+    end
+  end
+
+  context 'while create_stack is stubbed out' do
+    before do
+      cfn_client.stub_responses(
+        :create_stack,
+        stack_id: 'stack_id'
+      )
+      cfn_client.stub_responses(
+        :describe_stacks,
+        stacks: [
+          stack_id: 'stack_id',
+          stack_name: 'teststack',
+          creation_time: Time.new,
+          stack_status: 'CREATE_COMPLETE'
+        ]
+      )
+      cfn_client.stub_responses(
+        :describe_stack_events,
+        stack_events: [
+          stack_id: 'stack_id',
+          event_id: 'event_id',
+          stack_name: 'teststack',
+          timestamp: Time.new
+        ]
+      )
+    end
+
+    describe '#create_stack' do
+      it 'does not raise an error' do
+        allow(IO).to receive(:read).with('file').and_return('some_data')
+        expect { cfn_util.create_stack('teststack', 'file') }.not_to raise_error
+      end
+    end
+  end
+end