lambda_wrap 0.27.0 → 1.0.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA1:
-  metadata.gz: b47d747dee8ec24d3afbf8b18ebf6fdc2359afd4
-  data.tar.gz: 7ca7e1859e904c2e1f92da462dc427a1d1bb4168
+  metadata.gz: cd87dbdb65df35c7a42c352ee4b619ee1f2c263a
+  data.tar.gz: 7bddaa1b451694fbf78f85a85a1ea35aa69a51cc
 SHA512:
-  metadata.gz: 128c10bf9c107c209810a3d24b107d5a1881f826caa968b9ec3c950591a197f5f65055a2305f2ecaac9ceee380f1c1bb1e617e6e7646be72e75a1da67ea9c668
-  data.tar.gz: 94edd6cc371f977713b949d2f5c59ac4c837a63f3276bb9e346b516543633523f47dbc130ce250be22dffbc07758dd89c32733e63e84f1db798879b1a59c2da1
+  metadata.gz: 2ddde3fd339e8d3cd88dc8a4ba8508e246d895ffacd56477857530f9335d9226859759ff66337602ca83fdb1bd6cb5f0b774f4e41ccb4cd607f64a0cebaef1cc
+  data.tar.gz: 68c827f0dedea73cd533e6bb4d63d529544d337889c7db8e60147905405d9a738c6cf251ed31a32428fc6152f27b7ba4b0ca3bb10f1fdf856cb002f4369ea186

data/lib/lambda_wrap/api_gateway_manager.rb

@@ -1,203 +1,153 @@
-require 'aws-sdk'
-
 module LambdaWrap
-  # The ApiGatewayManager simplifies downloading the aws-apigateway-importer binary,
-  # importing a {swagger configuration}[http://swagger.io], and managing API Gateway stages.
-  # Added functionality to create APIGateway deom Swagger file. Thsi API is useful for gateway's having
-  # custom authorization.
-
-  # Note: The concept of an environment of the LambdaWrap gem matches a stage in AWS ApiGateway terms.
-  class ApiGatewayManager
+  # The ApiGateway class simplifies creation, deployment, and management of API Gateway objects.
+  # The specification for the API MUST be detailed in a provided Open API Formatted file (fka Swagger).
+  #
+  # @!attribute [r] specification
+  #   @return [Hash] The Swagger spec parsed into a Hash
+  #
+  # @since 1.0
+  class ApiGateway < AwsService
+    attr_reader :specification
+
+    # Initializes the APIGateway Manager Object. A significant majority of the configuration of your
+    # API should be configured through your Swagger File (e.g. Integrations, API Name, Version).
     #
-    # The constructor does some basic setup
-    # * Validating basic AWS configuration
-    # * Creating the underlying client to interact with the AWS SDK.
-    # * Defining the temporary path of the api-gateway-importer jar file
-    def initialize
-      # AWS api gateway client
-      @client = Aws::APIGateway::Client.new
-      # path to apigateway-importer jar
-      @jarpath = File.join(Dir.tmpdir, 'aws-apigateway-importer-1.0.3-SNAPSHOT-jar-with-dependencies.jar')
-      @versionpath = File.join(Dir.tmpdir, 'aws-apigateway-importer-1.0.3-SNAPSHOT-jar-with-dependencies.s3version')
+    # @param [Hash] options The Options initialize the API Gateway Manager with.
+    # @option options [String] :path_to_swagger_file File path the Swagger File to load and parse.
+    # @option options [String] :import_mode (overwrite) How the API Gateway Object will handle updates.
+    #  Accepts <tt>overwrite</tt> and <tt>merge</tt>.
+    def initialize(options)
+      options_with_defaults = options.reverse_merge(import_mode: 'overwrite')
+      @path_to_swagger_file = options_with_defaults[:path_to_swagger_file]
+      @specification = extract_specification(@path_to_swagger_file)
+      @api_name = @specification['info']['title']
+      @api_version = @specification['info']['version']
+      @import_mode = options_with_defaults[:import_mode]
     end
 
-    ##
-    # Downloads the aws-apigateway-importer jar from an S3 bucket.
-    # This is a workaround since aws-apigateway-importer does not provide a binary.
-    # Once a binary is available on the public internet, we'll start using this instead
-    # of requiring users of this gem to upload their custom binary to an S3 bucket.
+    # Deploys the API Gateway Object to a specified environment
     #
-    # *Arguments*
-    # [s3_bucket]  An S3 bucket from where the aws-apigateway-importer binary can be downloaded.
-    # [s3_key]  The path (key) to the aws-apigateay-importer binary on the s3 bucket.
-    def download_apigateway_importer(s3_bucket, s3_key)
-      s3 = Aws::S3::Client.new
-
-      # current version
-      current_s3_version = File.open(@versionpath, 'rb').read if File.exist?(@versionpath)
-
-      # online s3 version
-      desired_s3_version = s3.head_object(bucket: s3_bucket, key: s3_key).version_id
-
-      # compare local with remote version
-      if current_s3_version != desired_s3_version || !File.exist?(@jarpath)
-        puts "Downloading aws-apigateway-importer jar with S3 version #{desired_s3_version}"
-        s3.get_object(response_target: @jarpath, bucket: s3_bucket, key: s3_key)
-        File.write(@versionpath, desired_s3_version)
+    # @param environment_options [LambdaWrap::Environment] The environment to deploy
+    # @param client [Aws::APIGateway::Client] Client to use with SDK. Should be passed in by the API class.
+    # @param region [String] AWS Region string. Should be passed in by the API class.
+    def deploy(environment_options, client, region = 'AWS_REGION')
+      super
+      puts "Deploying API: #{@api_name} to Environment: #{environment_options.name}"
+      @stage_variables = environment_options.variables || {}
+      @stage_variables.store('environment', environment_options.name)
+
+      api_id = get_id_for_api(@api_name)
+      service_response =
+        if api_id
+          @client.put_rest_api(
+            fail_on_warnings: false, mode: @import_mode, rest_api_id:
+            api_id, body: File.open(@path_to_swagger_file, 'rb').read
+          )
+        else
+          @client.import_rest_api(
+            fail_on_warnings: false,
+            body: File.open(@path_to_swagger_file, 'rb').read
+          )
+        end
+
+      if service_response.nil? || service_response.id.nil?
+        raise "Failed to create API gateway with name #{@api_name}"
       end
-    end
 
-    ##
-    # Sets up the API gateway by searching whether the API Gateway already exists
-    # and updates it with the latest information from the swagger file.
-    #
-    # *Arguments*
-    # [api_name]  The name of the API to which the swagger file should be applied to.
-    # [env]  The environment where it should be published (which is matching an API gateway stage)
-    # [swagger_file]  A handle to a swagger file that should be used by aws-apigateway-importer
-    # [api_description]  The description of the API to be displayed.
-    # [stage_variables]  A Hash of stage variables to be deployed with the stage. Adds an 'environment' by default.
-    # [region]  A string representing the region to deploy the API. Defaults to what is set as an environment variable.
-    def setup_apigateway(api_name, env, swagger_file, api_description = 'Deployed with LambdaWrap',
-                         stage_variables = {}, region = ENV['AWS_REGION'])
-      # ensure API is created
-      api_id = get_existing_rest_api(api_name)
-      api_id = setup_apigateway_create_rest_api(api_name, api_description) unless api_id
-
-      # create resources
-      setup_apigateway_create_resources(api_id, swagger_file, region)
-
-      # create stages
-      stage_variables.store('environment', env)
-      create_stages(api_id, env, stage_variables)
-
-      # return URI of created stage
-      "https://#{api_id}.execute-api.#{region}.amazonaws.com/#{env}/"
-    end
+      if api_id
+        "Created API Gateway Object: #{@api_name} having id #{service_response.id}"
+      else
+        "Updated API Gateway Object: #{@api_name} having id #{service_response.id}"
+      end
 
-    ##
-    # Shuts down an environment from the API Gateway. This basically deletes the stage
-    # from the API Gateway, but does not delete the API Gateway itself.
-    #
-    # *Argument*
-    # [api_name]  The name of the API where the environment should be shut down.
-    # [env]  The environment (matching an API Gateway stage) to shutdown.
-    def shutdown_apigateway(api_name, env)
-      api_id = get_existing_rest_api(api_name)
-      delete_stage(api_id, env)
-    end
+      create_stage(service_response.id, environment_options)
 
-    ##
-    # Gets the ID of an existing API Gateway api, or nil if it doesn't exist
-    #
-    # *Arguments*
-    # [api_name]  The name of the API to be checked for existance
-    def get_existing_rest_api(api_name)
-      apis = @client.get_rest_apis(limit: 500).data
-      api = apis.items.select { |a| a.name == api_name }.first
-
-      return api.id if api
-      # nil is returned otherwise
+      service_uri = "https://#{service_response.id}.execute-api.#{@region}.amazonaws.com/#{environment_options.name}/"
+
+      puts "API: #{@api_name} deployed at #{service_uri}"
+
+      service_uri
     end
 
-    ##
-    # Creates the API with a given name using the SDK and returns the id
+    # Tearsdown environment for API Gateway. Deletes stage.
     #
-    # *Arguments*
-    # [api_name]  A String representing the name of the API Gateway Object to be created
-    # [api_description]  A String representing the description of the API
-    def setup_apigateway_create_rest_api(api_name, api_description)
-      puts 'Creating API with name ' + api_name
-      api = @client.create_rest_api(name: api_name, description: api_description)
-      api.id
+    # @param environment_options [LambdaWrap::Environment] The environment to teardown.
+    # @param client [Aws::APIGateway::Client] Client to use with SDK. Should be passed in by the API class.
+    # @param region [String] AWS Region string. Should be passed in by the API class.
+    def teardown(environment_options, client, region = 'AWS_REGION')
+      super
+      api_id = get_id_for_api(@api_name)
+      if api_id
+        delete_stage(api_id, environment_options.name)
+      else
+        puts "API Gateway Object #{@api_name} not found. No environment to tear down."
+      end
+      true
     end
 
-    ##
-    # Invokes the aws-apigateway-importer jar with the required parameter
-    #
-    # *Arguments*
-    # [api_id]  The AWS ApiGateway id where the swagger file should be applied to.
-    # [swagger_file]  The handle to a swagger definition file that should be imported into API Gateway
-    # [region]  A string representing the target region to deploy the API
-    def setup_apigateway_create_resources(api_id, swagger_file, region)
-      raise 'API ID not provided' unless api_id
-
-      cmd = "java -jar #{@jarpath} --update #{api_id} --region #{region} #{swagger_file}"
-      raise 'API gateway not created' unless system(cmd)
+    # Deletes all stages and API Gateway object.
+    # @param client [Aws::APIGateway::Client] Client to use with SDK. Should be passed in by the API class.
+    # @param region [String] AWS Region string. Should be passed in by the API class.
+    def delete(client, region = 'AWS_REGION')
+      super
+      api_id = get_id_for_api(@api_name)
+      if api_id
+        @client.delete_rest_api(rest_api_id: api_id)
+        puts "Deleted API: #{@api_name} ID:#{api_id}"
+      else
+        puts "API Gateway Object #{@api_name} not found. Nothing to delete."
+      end
+      true
     end
 
-    ##
-    # Creates a stage of the currently set resources
-    #
-    # *Arguments*
-    # [api_id]  The AWS ApiGateway id where the stage should be created at.
-    # [env]  The environment (which matches the stage in API Gateway) to create.
-    # [stage_variables]  A Hash of stage variables to deploy with the stage
-    def create_stages(api_id, env, stage_variables)
-      deployment_description = 'Deployment of service to ' + env
-      deployment = @client.create_deployment(
-        rest_api_id: api_id, stage_name: env, cache_cluster_enabled: false, description: deployment_description,
-        variables: stage_variables
-      ).data
-      puts deployment
+    def to_s
+      return @api_name if @api_name && @api_name.is_a?(String)
+      super
     end
 
-    ##
-    # Deletes a stage of the API Gateway
-    #
-    # *Arguments*
-    # [api_id]  The AWS ApiGateway id from which the stage should be deleted from.
-    # [env]The environment (which matches the stage in API Gateway) to delete.
+    private
+
     def delete_stage(api_id, env)
       @client.delete_stage(rest_api_id: api_id, stage_name: env)
       puts 'Deleted API gateway stage ' + env
     rescue Aws::APIGateway::Errors::NotFoundException
-      puts 'API Gateway stage ' + env + ' does not exist. Nothing to delete.'
+      puts "API Gateway stage #{env} does not exist. Nothing to delete."
     end
 
-    ##
-    # Generate or Update the API Gateway by using the swagger file and the SDK importer
-    #
-    # *Arguments*
-    # [api_name] API Gateway name
-    # [local_swagger_file] Path of the local swagger file
-    # [env] Environment identifier
-    # [stage_variables] hash of stage variables
-    def setup_apigateway_by_swagger_file(api_name, local_swagger_file, env, stage_variables = {})
-      # If API gateway with the name is already present then update it else create a new one
-      api_id = get_existing_rest_api(api_name)
-      swagger_file_content = File.read(local_swagger_file)
-
-      gateway_response = nil
-      if api_id.nil?
-        # Create a new APIGateway
-        gateway_response =  @client.import_rest_api(fail_on_warnings: false, body: swagger_file_content)
-      else
-        # Update the exsiting APIgateway. By Merge the exsisting gateway will be merged with the new
-        # one supplied in the Swagger file.
-        gateway_response =  @client.put_rest_api(rest_api_id: api_id, mode: 'merge', fail_on_warnings: false,
-                                                 body: swagger_file_content)
-      end
-
-      raise "Failed to create API gateway with name #{api_name}" if gateway_response.nil? && gateway_response.id.nil?
+    def create_stage(api_id, environment_options)
+      deployment_description = "Deploying API #{@api_name} v#{@api_version}\
+        to Environment:#{environment_options.name}"
+      stage_description = "#{environment_options.name} - #{environment_options.description}"
+      @client.create_deployment(
+        rest_api_id: api_id, stage_name: environment_options.name,
+        stage_description: stage_description, description: deployment_description,
+        cache_cluster_enabled: false, variables: environment_options.variables
+      )
+    end
 
-      if api_id.nil?
-        puts "Created api gateway #{api_name} having id #{gateway_response.id}"
-      else
-        puts "Updated api gateway #{api_name} having id #{gateway_response.id}"
+    def extract_specification(file_path)
+      unless File.exist?(file_path)
+        raise ArgumentError, "Open API Spec (Swagger) File does not exist: #{file_path}!"
       end
-
-      # Deploy the service
-      stage_variables.store('environment', env)
-      create_stages(gateway_response.id, env, stage_variables)
-
-      service_uri = "https://#{gateway_response.id}.execute-api.#{ENV['AWS_REGION']}.amazonaws.com/#{env}/"
-      puts "Service deployed at #{service_uri}"
-
-      service_uri
+      spec = Psych.load_file(file_path)
+      raise ArgumentError, 'LambdaWrap only supports swagger v2.0' unless spec['swagger'] == '2.0'
+      raise ArgumentError, 'Invalid Title field in the OAPISpec' unless spec['info']['title'] =~ /[A-Za-z0-9]{1,1024}/
+      spec
     end
 
-    private :get_existing_rest_api, :setup_apigateway_create_rest_api, :setup_apigateway_create_resources,
-            :create_stages, :delete_stage
+    def get_id_for_api(api_name)
+      response = nil
+      loop do
+        response =
+          if !response || response.position.nil?
+            @client.get_rest_apis(limit: 500)
+          else
+            @client.get_rest_apis(limit: 500, position: response.position)
+          end
+        api = response.items.detect { |item| item.name == api_name }
+        return api.id if api
+        return if response.items.empty? || response.position.nil? || response.position.empty?
+      end
+    end
   end
 end

data/lib/lambda_wrap/api_manager.rb

@@ -0,0 +1,270 @@
+module LambdaWrap
+  # Top level class that manages the Serverless Microservice API deployment.
+  #
+  # @!attribute [r] lambdas
+  #   @return [Array<LambdaWrap::Lambda>] The List of Lambdas to be deployed with the API.
+  #
+  # @!attribute [r] dynamo_tables
+  #   @return [Array<LambdaWrap::DynamoTables>] The List of DynamoTables to be deployed with the API.
+  #
+  # @!attribute [r] api_gateways
+  #   @return [Array<LambdaWrap::ApiGateway>] The List of API Gateways to be deployed with the API.
+  #
+  # @!attribute [r] region
+  #   @return [String] The AWS Region to deploy the API.
+  #
+  # @since 1.0
+  class API
+    attr_reader :lambdas
+    attr_reader :dynamo_tables
+    attr_reader :api_gateways
+    attr_reader :region
+
+    # Constructor for the high level API Manager class.
+    #
+    # @param [Hash] options The Options to configure the API.
+    # @option options [String] :access_key_id The AWS Access Key Id to communicate with AWS. Will also check the
+    #   environment variables for this value.
+    # @option options [String] :secret_access_key The AWS Secret Access Key to communicate with AWS. Also checks
+    #   environment variables for this value.
+    # @option options [String] :region The AWS Region to deploy API to. Also checks environment variables for this
+    #   value.
+    #
+    # @todo Allow clients to pass in a YAML file for all construction.
+    def initialize(options = {})
+      unless options[:lambda_client] && options[:dynamo_client] && options[:api_gateway_client]
+        access_key_id = options[:access_key_id] || ENV['AWS_ACCESS_KEY_ID'] || ENV['ACCESS_KEY'] ||
+                        raise(ArgumentError, 'Cannot find AWS Access Key ID.')
+
+        secret_access_key = options[:secret_access_key] || ENV['AWS_SECRET_ACCESS_KEY'] || ENV['SECRET_KEY'] ||
+                            raise(ArgumentError, 'Cannot find AWS Secret Key.')
+
+        credentials = Aws::Credentials.new(access_key_id, secret_access_key)
+      end
+
+      region = options[:region] || ENV['AWS_REGION'] || ENV['AMAZON_REGION'] || ENV['AWS_DEFAULT_REGION'] ||
+               raise(ArgumentError, 'Cannot find AWS Region.')
+
+      @lambdas = []
+      @dynamo_tables = []
+      @api_gateways = []
+
+      @region = region
+      @lambda_client = options[:lambda_client] ||
+                       Aws::Lambda::Client.new(credentials: credentials, region: region)
+      @dynamo_client = options[:dynamo_client] ||
+                       Aws::DynamoDB::Client.new(credentials: credentials, region: region)
+      @api_gateway_client = options[:api_gateway_client] ||
+                            Aws::APIGateway::Client.new(credentials: credentials, region: region)
+    end
+
+    # Add Lambda Object(s) to the API.
+    #
+    # @param [LambdaWrap::Lambda Array<LambdaWrap::Lambda>] new_lambda Splat of LambdaWrap Lambda
+    #  objects to add to the API. Overloaded as:
+    #  add_lambda(lambda1) OR  add_lambda([lambda1, lambda2]) OR add_lambda(lambda1, lambda2)
+    def add_lambda(*new_lambda)
+      flattened_lambdas = new_lambda.flatten
+      flattened_lambdas.each { |lambda| parameter_guard(lambda, LambdaWrap::Lambda, 'LambdaWrap::Lambda') }
+      lambdas.concat(flattened_lambdas)
+    end
+
+    # Add Dynamo Table Object(s) to the API.
+    #
+    # @param [LambdaWrap::DynamoTable, Array<LambdaWrap::DynamoTable>] new_table Splat of LambdaWrap DynamoTable
+    #  objects to add to the API. Overloaded as:
+    #  add_dynamo_table(table1) OR  add_dynamo_table([table1, table2]) OR add_dynamo_table(table1, table2)
+    def add_dynamo_table(*new_table)
+      flattened_tables = new_table.flatten
+      flattened_tables.each { |table| parameter_guard(table, LambdaWrap::DynamoTable, 'LambdaWrap::DynamoTable') }
+      dynamo_tables.concat(flattened_tables)
+    end
+
+    # Add API Gateway Object(s) to the API.
+    #
+    # @param [LambdaWrap::ApiGateway, Array<LambdaWrap::ApiGateway>] new_api_gateway Splat of LambdaWrap API Gateway
+    #  objects to add to the API. Overloaded as:
+    #  add_api_gateway(apig1) OR  add_api_gateway([apig1, apig2]) OR add_api_gateway(apig1, apig2)
+    def add_api_gateway(*new_api_gateway)
+      flattened_api_gateways = new_api_gateway.flatten
+      flattened_api_gateways.each { |apig| parameter_guard(apig, LambdaWrap::ApiGateway, 'LambdaWrap::ApiGateway') }
+      api_gateways.concat(flattened_api_gateways)
+    end
+
+    # Deploys all services to the specified environment.
+    #
+    # @param [LambdaWrap::Environment] environment_options the Environment to deploy
+    def deploy(environment_options)
+      environment_parameter_guard(environment_options)
+      if no_op?
+        puts 'Nothing to deploy.'
+        return
+      end
+
+      deployment_start_message = 'Deploying '
+      deployment_start_message += "#{dynamo_tables.length} Dynamo Tables, " unless dynamo_tables.empty?
+      deployment_start_message += "#{lambdas.length} Lambdas, " unless lambdas.empty?
+      deployment_start_message += "#{api_gateways.length} API Gateways " unless api_gateways.empty?
+      deployment_start_message += "to Environment: #{environment_options.name}"
+      puts deployment_start_message
+
+      total_time_start = Time.now
+
+      services_time_start = total_time_start
+      dynamo_tables.each { |table| table.deploy(environment_options, @dynamo_client, @region) }
+      services_time_end = Time.now
+
+      unless dynamo_tables.empty?
+        puts "Deploying #{dynamo_tables.length} Table(s) took: \
+        #{Time.at(services_time_end - services_time_start).utc.strftime('%H:%M:%S')}"
+      end
+
+      services_time_start = Time.now
+      lambdas.each { |lambda| lambda.deploy(environment_options, @lambda_client, @region) }
+      services_time_end = Time.now
+
+      unless lambdas.empty?
+        puts "Deploying #{lambdas.length} Lambda(s) took: \
+        #{Time.at(services_time_end - services_time_start).utc.strftime('%H:%M:%S')}"
+      end
+
+      services_time_start = Time.now
+      api_gateways.each { |apig| apig.deploy(environment_options, @api_gateway_client, @region) }
+      services_time_end = Time.now
+
+      unless api_gateways.empty?
+        puts "Deploying #{api_gateways.length} API Gateway(s) took: \
+        #{Time.at(services_time_end - services_time_start).utc.strftime('%H:%M:%S')}"
+      end
+
+      total_time_end = Time.now
+
+      puts "Total API Deployment took: \
+      #{Time.at(total_time_end - total_time_start).utc.strftime('%H:%M:%S')}"
+      puts "Successfully deployed API to #{environment_options.name}"
+
+      true
+    end
+
+    # Tearsdown Environment for all services.
+    #
+    # @param [LambdaWrap::Environment] environment_options the Environment to teardown
+    def teardown(environment_options)
+      environment_parameter_guard(environment_options)
+      if no_op?
+        puts 'Nothing to teardown.'
+        return
+      end
+
+      deployment_start_message = 'Tearing-down '
+      deployment_start_message += "#{dynamo_tables.length} Dynamo Tables, " unless dynamo_tables.empty?
+      deployment_start_message += "#{lambdas.length} Lambdas, " unless lambdas.empty?
+      deployment_start_message += "#{api_gateways.length} API Gateways " unless api_gateways.empty?
+      deployment_start_message += " Environment: #{environment_options.name}"
+      puts deployment_start_message
+
+      total_time_start = Time.now
+
+      services_time_start = total_time_start
+      dynamo_tables.each { |table| table.teardown(environment_options, @dynamo_client, @region) }
+      services_time_end = Time.now
+
+      unless dynamo_tables.empty?
+        puts "Tearing-down #{dynamo_tables.length} Table(s) took: \
+        #{Time.at(services_time_end - services_time_start).utc.strftime('%H:%M:%S')}"
+      end
+
+      services_time_start = Time.now
+      lambdas.each { |lambda| lambda.teardown(environment_options, @lambda_client, @region) }
+      services_time_end = Time.now
+
+      unless lambdas.empty?
+        puts "Tearing-down #{lambdas.length} Lambda(s) took: \
+        #{Time.at(services_time_end - services_time_start).utc.strftime('%H:%M:%S')}"
+      end
+
+      services_time_start = Time.now
+      api_gateways.each { |apig| apig.teardown(environment_options, @api_gateway_client, @region) }
+      services_time_end = Time.now
+
+      unless api_gateways.empty?
+        puts "Tearing-down #{api_gateways.length} API Gateway(s) took: \
+        #{Time.at(services_time_end - services_time_start).utc.strftime('%H:%M:%S')}"
+      end
+
+      total_time_end = Time.now
+
+      puts "Total API Tear-down took: \
+      #{Time.at(total_time_end - total_time_start).utc.strftime('%H:%M:%S')}"
+      puts "Successful Teardown API to #{environment_options.name}"
+
+      true
+    end
+
+    # Deletes all services from the cloud.
+    def delete
+      if dynamo_tables.empty? && lambdas.empty? && api_gateways.empty?
+        puts 'Nothing to Deleting.'
+        return
+      end
+
+      deployment_start_message = 'Deleting '
+      deployment_start_message += "#{dynamo_tables.length} Dynamo Tables, " unless dynamo_tables.empty?
+      deployment_start_message += "#{lambdas.length} Lambdas, " unless lambdas.empty?
+      deployment_start_message += "#{api_gateways.length} API Gateways " unless api_gateways.empty?
+      puts deployment_start_message
+
+      total_time_start = Time.now
+
+      services_time_start = total_time_start
+      dynamo_tables.each { |table| table.delete(@dynamo_client, @region) }
+      services_time_end = Time.now
+
+      unless dynamo_tables.empty?
+        puts "Deleting #{dynamo_tables.length} Table(s) took: \
+        #{Time.at(services_time_end - services_time_start).utc.strftime('%H:%M:%S')}"
+      end
+
+      services_time_start = Time.now
+      lambdas.each { |lambda| lambda.delete(@lambda_client, @region) }
+      services_time_end = Time.now
+
+      unless lambdas.empty?
+        puts "Deleting #{lambdas.length} Lambda(s) took: \
+        #{Time.at(services_time_end - services_time_start).utc.strftime('%H:%M:%S')}"
+      end
+
+      services_time_start = Time.now
+      api_gateways.each { |apig| apig.delete(@api_gateway_client, @region) }
+      services_time_end = Time.now
+
+      unless api_gateways.empty?
+        puts "Deleting #{api_gateways.length} API Gateway(s) took: \
+        #{Time.at(services_time_end - services_time_start).utc.strftime('%H:%M:%S')}"
+      end
+
+      total_time_end = Time.now
+
+      puts "Total API Deletion took: \
+      #{Time.at(total_time_end - total_time_start).utc.strftime('%H:%M:%S')}"
+      puts 'Successful Deletion of API'
+
+      true
+    end
+
+    private
+
+    def environment_parameter_guard(parameter)
+      parameter_guard(parameter, LambdaWrap::Environment, 'LambdaWrap::Environment')
+    end
+
+    def parameter_guard(parameter, type, type_name)
+      return if parameter.is_a?(type)
+      raise ArgumentError, "Must pass a #{type_name} to the API Manager. Got: #{parameter}"
+    end
+
+    def no_op?
+      dynamo_tables.empty? && lambdas.empty? && api_gateways.empty?
+    end
+  end
+end

data/lib/lambda_wrap/aws_service.rb

@@ -0,0 +1,40 @@
+module LambdaWrap
+  # Super Abstract Class for all AWS services and their calls.
+  # @abstract
+  # @since 1.0
+  class AwsService
+    def deploy(environment, client, region = 'AWS_REGION')
+      unless environment.is_a?(LambdaWrap::Environment)
+        raise ArgumentError, 'Must pass a LambdaWrap::Environment class.'
+      end
+      @client = client
+      @region = region
+      client_guard
+    end
+
+    def teardown(environment, client, region = 'AWS_REGION')
+      unless environment.is_a?(LambdaWrap::Environment)
+        raise ArgumentError, 'Must pass a LambdaWrap::Environment class.'
+      end
+      @client = client
+      @region = region
+      client_guard
+    end
+
+    def delete(client, region = 'AWS_REGION')
+      @client = client
+      @region = region
+      client_guard
+    end
+
+    private
+
+    def client_guard
+      unless @client.class == Aws::Lambda::Client || @client.class == Aws::DynamoDB::Client ||
+             @client.class == Aws::APIGateway::Client
+        raise ArgumentError, 'AWS client not initialized.'
+      end
+      raise ArgumentError, 'Invalid region' if @region.empty? || !Aws.partition('aws').region(@region)
+    end
+  end
+end