jets-fs 1.6.10

data/lib/jets/resource/api_gateway/domain_name.rb

@@ -0,0 +1,59 @@
+# CloudFormation Docs AWS::ApiGateway::DomainName: https://amzn.to/2Bsnmbq
+#
+# Example:
+#
+#   MyDomainName:
+#     Type: 'AWS::ApiGateway::DomainName'
+#     Properties:
+#       DomainName: api.mydomain.com
+#       CertificateArn: arn:aws:acm:us-east-1:111122223333:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3
+#
+module Jets::Resource::ApiGateway
+  class DomainName < Jets::Resource::Base
+    def definition
+      properties = {
+        domain_name: domain_name,
+        endpoint_configuration: {
+          types: endpoint_types
+        }
+      }
+      # Can really only be REGIONAL or EDGE
+      if endpoint_types.include?("REGIONAL")
+        properties[:regional_certificate_arn] = cert_arn
+      end
+      if endpoint_types.include?("EDGE")
+        properties[:certificate_arn] = cert_arn
+      end
+
+      {
+        domain_name: {
+          type: "AWS::ApiGateway::DomainName",
+          properties: properties
+        }
+      }
+    end
+
+    def outputs
+      {
+        "DomainName" => "!Ref DomainName",
+      }
+    end
+
+    def domain_name
+      subdomain = Jets.project_namespace
+      managed_domain_name = "#{subdomain}.#{Jets.config.domain.hosted_zone_name}"
+      name = Jets.config.domain.name || managed_domain_name
+      # Strip trailing period if there is one set accidentally or else get this error
+      #   Trailing period should be omitted from domain name (Service: AmazonApiGateway; Status Code: 400; Error Code: BadRequestException
+      name.sub(/\.$/,'')
+    end
+
+    def endpoint_types
+      [Jets.config.domain.endpoint_type].flatten
+    end
+
+    def cert_arn
+      Jets.config.domain.cert_arn
+    end
+  end
+end

data/lib/jets/resource/api_gateway/method.rb

@@ -0,0 +1,98 @@
+# Converts a Jets::Route to a CloudFormation Jets::Resource::ApiGateway::Method resource
+module Jets::Resource::ApiGateway
+  class Method < Jets::Resource::Base
+    # also delegate permission for a method
+    delegate :permission,
+             to: :resource
+
+    # route - Jets::Route
+    def initialize(route)
+      @route = route
+    end
+
+    def definition
+      {
+        method_logical_id => {
+          type: "AWS::ApiGateway::Method",
+          properties: {
+            resource_id: "!Ref #{resource_id}",
+            rest_api_id: "!Ref #{RestApi.logical_id}",
+            http_method: @route.method,
+            request_parameters: {},
+            authorization_type: authorization_type,
+            integration: {
+              integration_http_method: "POST",
+              type: "AWS_PROXY",
+              uri: "!Sub arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${{namespace}LambdaFunction.Arn}/invocations"
+            },
+            method_responses: []
+          }
+        }
+      }
+    end
+
+    def method_logical_id
+      # https://stackoverflow.com/questions/6104240/how-do-i-strip-non-alphanumeric-characters-from-a-string-and-keep-spaces
+      # Add path to the logical id to allow 2 different paths to be connected to the same controller action.
+      # Example:
+      #
+      #   root "jets/public#show"
+      #   any "*catchall", to: "jets/public#show"
+      #
+      # Without the path in the logical id, the logical id would be ShowApiMethod for both routes and only the
+      # last one would be created in the CloudFormation template.
+      path = @route.path.gsub('*','')
+              .gsub(/[^0-9a-z]/i, ' ')
+              .gsub(/\s+/, '_')
+      path = nil if path == ''
+      http_verb = @route.method.downcase
+      [path, "{namespace}_#{http_verb}_api_method"].compact.join('_')
+    end
+
+    def replacements
+      # mimic task to grab replacements, we want the namespace to be the lambda function's namespace
+      resources = [definition]
+      task = Jets::Lambda::Task.new(@route.controller_name, @route.action_name,
+               resources: resources)
+      task.replacements
+    end
+
+    def cors
+      Cors.new(@route)
+    end
+    memoize :cors
+
+  private
+
+    def authorization_type
+      type = @route.authorization_type ||
+             controller_auth_type ||
+             Jets.config.api.authorization_type
+      type.to_s.upcase
+    end
+
+    def controller_auth_type
+      controller_name = @route.to.split('#').first
+      controller = "#{controller_name}_controller".classify.constantize
+      # Already handles inheritance via class_attribute
+      controller.authorization_type
+    end
+
+    def resource_id
+      @route.path == '' ?
+       "RootResourceId" :
+       "#{resource_logical_id.camelize}ApiResource"
+    end
+
+    # Example: Posts
+    def resource_logical_id
+      camelized_path.underscore
+    end
+
+    def camelized_path
+      path = @route.path
+      path = "homepage" if path == ''
+      path.gsub('/','_').gsub(':','').gsub('*','').camelize
+    end
+  end
+end

data/lib/jets/resource/api_gateway/resource.rb

@@ -0,0 +1,78 @@
+module Jets::Resource::ApiGateway
+  class Resource < Jets::Resource::Base
+    def initialize(path, internal: false)
+      @path = path # Examples: "posts/:id/edit" or "posts"
+      @internal = internal
+    end
+
+    def definition
+      {
+        resource_logical_id => {
+          type: "AWS::ApiGateway::Resource",
+          properties: {
+            parent_id: parent_id,
+            path_part: path_part,
+            rest_api_id: "!Ref #{RestApi.logical_id(@internal)}",
+          }
+        }
+      }
+    end
+
+    def outputs
+      {
+        logical_id => "!Ref #{logical_id}",
+      }
+    end
+
+    def resource_logical_id
+      if @path == ''
+        "RootResourceId"
+      else
+        "#{path_logical_id(@path)}ApiResource"
+      end
+    end
+
+    # For parameter description
+    def desc
+      path.empty? ? 'Homepage route: /' : "Route for: /#{path}"
+    end
+
+    def parent_id
+      if @path.include?('/') # posts/:id or posts/:id/edit
+        parent_path = @path.split('/')[0..-2].join('/')
+        parent_logical_id = path_logical_id(parent_path)
+        "!Ref #{parent_logical_id}ApiResource"
+      else
+        "!GetAtt #{RestApi.logical_id(@internal)}.RootResourceId"
+      end
+    end
+
+    def path_part
+      last_part = path.split('/').last
+      last_part.split('/').map {|s| transform_capture(s) }.join('/') if last_part
+    end
+
+    # Modify the path to conform to API Gateway capture expressions
+    def path
+      @path.split('/').map {|s| transform_capture(s) }.join('/')
+    end
+
+    def transform_capture(text)
+      if text.starts_with?(':')
+        text = text.sub(':','')
+        text = "{#{text}}" # :foo => {foo}
+      end
+      if text.starts_with?('*')
+        text = text.sub('*','')
+        text = "{#{text}+}" # *foo => {foo+}
+      end
+      text
+    end
+
+  private
+    # Similar path_logical_id method in resource/route.rb
+    def path_logical_id(path)
+      path.gsub('/','_').gsub(':','').gsub('*','').camelize
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api.rb

@@ -0,0 +1,60 @@
+module Jets::Resource::ApiGateway
+  class RestApi < Jets::Resource::Base
+    autoload :ChangeDetection, 'jets/resource/api_gateway/rest_api/change_detection'
+    autoload :LogicalId, 'jets/resource/api_gateway/rest_api/logical_id'
+    autoload :Routes, 'jets/resource/api_gateway/rest_api/routes'
+
+    def definition
+      properties = {
+        name: Jets::Naming.gateway_api_name,
+        endpoint_configuration: { types: endpoint_types }
+      }
+      properties[:binary_media_types] = binary_media_types if binary_media_types
+
+      {
+        internal_logical_id => {
+          type: "AWS::ApiGateway::RestApi",
+          properties: properties
+        }
+      }
+    end
+
+    def internal_logical_id
+      self.class.logical_id(true)
+    end
+
+    def self.logical_id(internal=false)
+      internal ? internal_logical_id : "RestApi"
+    end
+
+    @@internal_logical_id = nil
+    def self.internal_logical_id
+      @@internal_logical_id ||= LogicalId.new.get
+    end
+
+    def outputs
+      {
+        "RestApi" => "!Ref #{internal_logical_id}",
+        "Region" => "!Ref AWS::Region",
+        "RootResourceId" => "!GetAtt #{internal_logical_id}.RootResourceId",
+      }
+    end
+
+    def endpoint_types
+      [Jets.config.api.endpoint_type].flatten
+    end
+
+    # TODO: Looks like there's a bug with CloudFormation. On an API Gateway update
+    # we need to pass in the escaped version: multipart~1form-data
+    # On a brand new API Gateway creation, we need to pass in the unescaped form:
+    # multipart/form-data
+    # We are handling this with a full API Gateway replacement instead because it
+    # can be generalized more easily.
+    def binary_media_types
+      types = Jets.config.api.binary_media_types
+      return nil if types.nil? || types.empty?
+
+      [types].flatten
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/change_detection.rb

@@ -0,0 +1,42 @@
+class Jets::Resource::ApiGateway::RestApi
+  class ChangeDetection
+    extend Memoist
+    include Jets::AwsServices
+
+    def changed?
+      return false unless parent_stack_exists?
+      current_binary_media_types != new_binary_media_types ||
+      Routes.changed?
+    end
+
+    def new_binary_media_types
+      rest_api = Jets::Resource::ApiGateway::RestApi.new
+      rest_api.binary_media_types
+    end
+    memoize :new_binary_media_types
+
+    # Duplicated in rest_api/change_detection.rb, base_path/role.rb, rest_api/routes.rb
+    def current_binary_media_types
+      return nil unless parent_stack_exists?
+
+      stack = cfn.describe_stacks(stack_name: parent_stack_name).stacks.first
+
+      api_gateway_stack_arn = lookup(stack[:outputs], "ApiGateway")
+
+      stack = cfn.describe_stacks(stack_name: api_gateway_stack_arn).stacks.first
+      rest_api_id = lookup(stack[:outputs], "RestApi")
+
+      resp = apigateway.get_rest_api(rest_api_id: rest_api_id)
+      resp.binary_media_types
+    end
+    memoize :current_binary_media_types
+
+    def parent_stack_exists?
+      stack_exists?(parent_stack_name)
+    end
+
+    def parent_stack_name
+      Jets::Naming.parent_stack_name
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/logical_id.rb

@@ -0,0 +1,63 @@
+class Jets::Resource::ApiGateway::RestApi
+  class LogicalId
+    extend Memoist
+    include Jets::AwsServices
+
+    def get
+      return default unless stack_exists?(parent_stack_name) && api_gateway_exists?
+
+      if changed?
+        new_id
+      else
+        current
+      end
+    end
+
+    def changed?
+      change_detection = ChangeDetection.new
+      change_detection.changed?
+    end
+
+    # Takes current logical id and increments the number that is appended to it.
+    #
+    # Examples:
+    #
+    #   RestApi => RestApi1
+    #   RestApi1 => RestApi2
+    #   RestApi2 => RestApi3
+    #   RestApi7 => RestApi8
+    def new_id
+      regexp = /(\d+)/
+      md = current.match(regexp)
+      if md
+        current.gsub(regexp,'') + (md[1].to_i + 1).to_s
+      else
+        current + "1"
+      end
+    end
+
+    def current
+      resources = cfn.describe_stack_resources(stack_name: api_gateway_stack_arn).stack_resources
+      rest_api = resources.find { |r| r.resource_type == 'AWS::ApiGateway::RestApi' }
+      rest_api.logical_resource_id
+    end
+    memoize :current
+
+    def api_gateway_stack_arn
+      stack = cfn.describe_stacks(stack_name: parent_stack_name).stacks.first
+      lookup(stack[:outputs], "ApiGateway") # api_gateway_stack_arn
+    end
+
+    def api_gateway_exists?
+      !!api_gateway_stack_arn
+    end
+
+    def parent_stack_name
+      Jets::Naming.parent_stack_name
+    end
+
+    def default
+      "RestApi"
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/routes.rb

@@ -0,0 +1,11 @@
+class Jets::Resource::ApiGateway::RestApi
+  class Routes
+    autoload :Base, 'jets/resource/api_gateway/rest_api/routes/base'
+    autoload :Change, 'jets/resource/api_gateway/rest_api/routes/change'
+    autoload :Collision, 'jets/resource/api_gateway/rest_api/routes/collision'
+
+    def self.changed?
+      Change.new.changed?
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/routes/change.rb

@@ -0,0 +1,12 @@
+# Detects route changes
+class Jets::Resource::ApiGateway::RestApi::Routes
+  class Change
+    autoload :Base, 'jets/resource/api_gateway/rest_api/routes/change/base'
+    autoload :To, 'jets/resource/api_gateway/rest_api/routes/change/to'
+    autoload :Variable, 'jets/resource/api_gateway/rest_api/routes/change/variable'
+
+    def changed?
+      To.changed? || Variable.changed? || ENV['JETS_REPLACE_API']
+    end
+  end
+end

data/lib/jets/resource/api_gateway/rest_api/routes/change/base.rb

@@ -0,0 +1,130 @@
+class Jets::Resource::ApiGateway::RestApi::Routes::Change
+  class Base
+    extend Memoist
+    include Jets::AwsServices
+
+    # Build up deployed routes from the existing CloudFormation resources.
+    def deployed_routes
+      routes = []
+
+      resources, position = [], true
+      while position
+        position = nil if position == true # start of loop
+        resp = apigateway.get_resources(
+          rest_api_id: rest_api_id,
+          position: position,
+        )
+        resources += resp.items
+        position = resp.position
+      end
+
+      resources.each do |resource|
+        resource_methods = resource.resource_methods
+        next if resource_methods.nil?
+
+        resource_methods.each do |http_verb, resource_method|
+          # puts "#{http_verb} #{resource.path} | resource.id #{resource.id}"
+          # puts to(resource.id, http_verb)
+
+          # Test changing config.cors and CloudFormation does an in-place update
+          # on the resource. So no need to do bluegreen deployments for OPTIONS.
+          next if http_verb == "OPTIONS"
+
+          path = recreate_path(resource.path)
+          method = http_verb.downcase.to_sym
+          to = to(resource.id, http_verb)
+          route = Jets::Route.new(path: path, method: method, to: to)
+          routes << route
+        end
+      end
+      routes
+    end
+    memoize :deployed_routes
+
+    def recreate_path(path)
+      path = path.gsub(%r{^/},'')
+      path = path.gsub(/{([^}]*)\+}/, '*\1')
+      path.gsub(/{([^}]*)}/, ':\1')
+    end
+
+    def to(resource_id, http_method)
+      uri = method_uri(resource_id, http_method)
+      recreate_to(uri) unless uri.nil?
+    end
+
+    def method_uri(resource_id, http_method)
+      resp = apigateway.get_method(
+        rest_api_id: rest_api_id,
+        resource_id: resource_id,
+        http_method: http_method
+      )
+      resp.method_integration.uri
+    end
+
+    # Parses method uri and recreates a Route to argument.
+    # So:
+    #   "arn:aws:apigateway:us-west-2:lambda:path/2015-03-31/functions/arn:aws:lambda:us-west-2:112233445566:function:demo-test-posts_controller-new/invocations"
+    # Returns:
+    #   posts#new
+    def recreate_to(method_uri)
+      md = method_uri.match(/function:(.*)\//)
+      function_arn = md[1] # IE: demo-dev-posts_controller-new
+      controller, action = get_controller_action(function_arn)
+      "#{controller}##{action}" # IE: posts#new
+    end
+
+    def get_controller_action(function_arn)
+      if function_arn.include?('_controller-')
+        controller_action_from_string(function_arn)
+      else
+        controller_action_from_api(function_arn)
+      end
+    end
+
+    # TODO: If this hits the Lambda Rate limit, then list_functions also contains the Lambda
+    # function description. So we can paginate through list_functions results and store
+    # description from there if needed.
+    # Dont think this will be needed though because controller_action_from_string gets called
+    # most of the time. Also, user might be able to request their Lambda limit to be increased.
+    def controller_action_from_api(function_arn)
+      desc = lambda_function_description(function_arn)
+      controller, action = desc.split('#')
+      controller = controller.underscore.sub(/_controller$/,'')
+      [controller, action]
+    end
+
+    def controller_action_from_string(function_arn)
+      controller_action = function_arn.sub("#{Jets.project_namespace}-", '')
+      md = controller_action.match(/(.*)_controller-(.*)/)
+      controller = md[1]
+      controller = controller.gsub('-','/')
+      action = md[2]
+      [controller, action]
+    end
+
+    def lambda_function_description(function_arn)
+      resp = lambda.get_function(function_name: function_arn)
+      resp.configuration.description # contains full info: PostsController#index
+    end
+
+    # Duplicated in rest_api/change_detection.rb, base_path/role.rb, rest_api/routes.rb
+    def rest_api_id
+      stack_name = Jets::Naming.parent_stack_name
+      return "RestApi" unless stack_exists?(stack_name)
+
+      stack = cfn.describe_stacks(stack_name: stack_name).stacks.first
+
+      api_gateway_stack_arn = lookup(stack[:outputs], "ApiGateway")
+
+      # resources = cfn.describe_stack_resources(stack_name: api_gateway_stack_arn).stack_resources
+      stack = cfn.describe_stacks(stack_name: api_gateway_stack_arn).stacks.first
+      lookup(stack[:outputs], "RestApi") # rest_api_id
+    end
+    memoize :rest_api_id
+
+    def new_routes
+      Jets::Router.routes
+    end
+    memoize :new_routes
+  end
+end