jets.benforeva 3.0.17.pre.mount.pre.fix

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

@@ -0,0 +1,102 @@
+# Converts a Jets::Route to a CloudFormation Jets::Resource::ApiGateway::Method resource
+module Jets::Resource::ApiGateway
+  class Method < Jets::Resource::Base
+    include Authorization
+
+    # 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: props
+        }
+      }
+    end
+
+    def props
+      props = {
+        resource_id: "!Ref #{resource_id}",
+        rest_api_id: "!Ref #{RestApi.logical_id}",
+        http_method: @route.method,
+        request_parameters: {},
+        authorization_type: authorization_type,
+        api_key_required: api_key_required?,
+        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: []
+      }
+      props[:authorizer_id] = authorizer_id if authorizer_id
+      props[:authorization_scopes] = authorization_scopes if authorization_scopes
+
+      props
+    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 controller_klass
+      @controller_klass ||= "#{controller_name}_controller".camelize.constantize
+    end
+
+    def controller_name
+      @controller_name ||= @route.to.split('#').first
+    end
+
+    def resource_id
+      @route.path == '' ?
+       "RootResourceId" :
+       Jets::Resource.truncate_id(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('*','').gsub('.','').camelize
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+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
+        Jets::Resource.truncate_id path_logical_id(@path), "ApiResource"
+      end
+    end
+
+    # For parameter description
+    def desc
+      path.empty? ? 'Homepage route: /' : "Route for: /#{path}"
+    end
+
+    def parent_path_parameter
+      if @path.include?('/') # posts/:id or posts/:id/edit
+        parent_path = @path.split('/')[0..-2].join('/')
+        parent_logical_id = path_logical_id(parent_path)
+        Jets::Resource.truncate_id(parent_logical_id, "ApiResource")
+      else
+        "RootResourceId"
+      end
+    end
+
+    def parent_id
+      "!Ref " + parent_path_parameter
+    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('*','').gsub('-','_').gsub('.','_').camelize
+    end
+  end
+end

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

@@ -0,0 +1,10 @@
+class Jets::Resource::ApiGateway::RestApi
+  class ChangeDetection
+    extend Memoist
+    include Jets::AwsServices
+
+    def changed?
+      Routes.changed?
+    end
+  end
+end

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

@@ -0,0 +1,49 @@
+class Jets::Resource::ApiGateway::RestApi::LogicalId
+  class Message
+    def routes_changed
+      <<~EOL
+      Routes Change Detection: Jets has detected that a new brand API Gateway is required to be deployed.
+      IMPORTANT: This will result in the API Gateway endpoint changing.
+      EOL
+    end
+
+    def custom_domain
+      api = Jets::Resource::ApiGateway::DomainName.new
+      domain_name = api.domain_name
+      if domain_name
+        <<~EOL
+        It looks like you have already set up a custom domain.
+        The domain name: #{domain_name}
+
+        So you should be good to go as the custom domain will be updated with the new API Gateway endpoint.
+        To avoid this prompt in the future, you can configure:
+
+        config/application.rb
+
+            config.api.auto_replace = true
+
+        More info: custom domain docs: https://rubyonjets.com/docs/routing/custom-domain/
+        EOL
+      else
+        "Please set up a custom domain https://rubyonjets.com/docs/routing/custom-domain/"
+      end
+    end
+
+    def auto_replace_disabled
+      <<~EOL
+      It looks like `config.api.auto_replace = false`. IE:
+
+      config/application.rb
+
+          config.api.auto_replace = false
+
+      The deploy will not continue. See:
+
+      * https://rubyonjets.com/docs/app-config/reference/
+      * https://rubyonjets.com/docs/routing/custom-domain/
+
+      EOL
+    end
+  end
+end
+

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

@@ -0,0 +1,98 @@
+class Jets::Resource::ApiGateway::RestApi
+  class LogicalId
+    extend Memoist
+    include Jets::AwsServices
+
+    def get
+      return default if ENV['JETS_BUILD_NO_INTERNET']
+      return default unless stack_exists?(parent_stack_name) && api_gateway_exists?
+
+      if changed?
+        auto_replace_prompt
+        new_id
+      else
+        current
+      end
+    end
+
+    def auto_replace_prompt
+      return if ENV['JETS_API_AUTO_REPLACE']
+      return unless ARGV[0] == "deploy"
+      case Jets.config.api.auto_replace
+      when nil
+        puts message.routes_changed
+        puts message.custom_domain
+        print "Would you like to continue the deployment? (y/N) "
+        answer = get_answer
+        exit 1 unless answer =~ /^y/
+      when false
+        puts message.routes_changed
+        puts message.auto_replace_disabled
+        exit 1
+      end
+    end
+
+    def message
+      Message.new
+    end
+    memoize :message
+
+    TIMEOUT_PERIOD = 120
+    def get_answer
+      Timeout::timeout(TIMEOUT_PERIOD) do
+        $stdin.gets
+      end
+    rescue Timeout::Error => e
+      puts "#{e.class}: #{e.message}".color(:red)
+      puts "Deployment timeout after #{TIMEOUT_PERIOD}s. Waited too long answer. Exiting."
+      exit 1
+    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/change/base.rb

@@ -0,0 +1,136 @@
+class Jets::Resource::ApiGateway::RestApi::Routes::Change
+  class Base
+    extend Memoist
+    include Jets::AwsServices
+
+    def self.changed?
+      new.changed?
+    end
+
+    # 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,
+          limit: 500, # default: 25 max: 500
+        )
+        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::Router::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)
+      # https://docs.aws.amazon.com/apigateway/latest/developerguide/limits.html
+      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 = aws_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

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

@@ -0,0 +1,36 @@
+class Jets::Resource::ApiGateway::RestApi::Routes::Change
+  class MediaTypes < Base
+    def changed?
+      current_binary_media_types != new_binary_media_types
+    end
+
+    def new_binary_media_types
+      rest_api = Jets::Resource::ApiGateway::RestApi.new
+      rest_api.binary_media_types
+    end
+    memoize :new_binary_media_types
+
+    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/routes/change/page.rb

@@ -0,0 +1,93 @@
+class Jets::Resource::ApiGateway::RestApi::Routes::Change
+  class Page < Base
+    def changed?
+      route_page_moved? || old_api_template?
+    end
+
+    def route_page_moved?
+      moved?(new_pages, deployed_pages)
+    end
+
+    # Routes page to logical ids
+    def moved?(new_pages, deployed_pages)
+      not_moved = true # page has not moved
+      new_pages.each do |logical_id, new_page_number|
+        if !deployed_pages[logical_id].nil? && deployed_pages[logical_id] != new_page_number
+          not_moved = false # page has moved
+          break
+        end
+      end
+      !not_moved # moved
+    end
+
+    def new_pages
+      local_logical_ids_map
+    end
+    memoize :new_pages
+
+    def deployed_pages
+      remote_logical_ids_map
+    end
+    memoize :deployed_pages
+
+    # logical id to page map
+    # Important: In Cfn::Builders::ApiGatewayBuilder, the add_gateway_routes and ApiResourcesBuilder needs to run
+    # before the parent add_gateway_rest_api method.
+    def local_logical_ids_map(path_expression="#{Jets::Naming.template_path_prefix}-api-resources-*.yml")
+      logical_ids = {} # logical id => page number
+
+      Dir.glob(path_expression).each do |path|
+        md = path.match(/-api-resources-(\d+).yml/)
+        page_number = md[1]
+
+        template = Jets::Cfn::BuiltTemplate.get(path)
+        template['Resources'].keys.each do |logical_id|
+          logical_ids[logical_id] = page_number
+        end
+      end
+
+      logical_ids
+    end
+
+    # aws cloudformation describe-stack-resources --stack-name demo-dev-ApiResources1-DYGLIEY3VAWT | jq -r '.StackResources[].LogicalResourceId'
+    def remote_logical_ids_map
+      logical_ids = {} # logical id => page number
+
+      parent_resources.each do |resource|
+        stack_name = resource.physical_resource_id # full physical id can be used as stack name also
+        regexp = Regexp.new("#{Jets.config.project_namespace}-ApiResources(\\d+)-") # tricky to escape \d pattern
+        md = stack_name.match(regexp)
+        if md
+          page_number = md[1]
+
+          resp = cfn.describe_stack_resources(stack_name: stack_name)
+          resp.stack_resources.map(&:logical_resource_id).each do |logical_id|
+            logical_ids[logical_id] = page_number
+          end
+        end
+      end
+
+      logical_ids
+    end
+
+    def old_api_template?
+      logical_resource_ids = parent_resources.map(&:logical_resource_id)
+
+      api_gateway_found = logical_resource_ids.detect do |logical_id|
+        logical_id == "ApiGateway"
+      end
+      return false unless api_gateway_found
+
+      api_resources_found = logical_resource_ids.detect do |logical_id|
+        logical_id.match(/^ApiResources\d+$/)
+      end
+      !api_resources_found # if api_resources_found then it's the new structure. so opposite is old structure
+    end
+
+    def parent_resources
+      resp = cfn.describe_stack_resources(stack_name: Jets::Naming.parent_stack_name)
+      resp.stack_resources
+    end
+    memoize :parent_resources
+  end
+end

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

@@ -0,0 +1,25 @@
+# Detects route to changes
+class Jets::Resource::ApiGateway::RestApi::Routes::Change
+  class To < Base
+    def changed?
+      deployed_routes.each do |deployed_route|
+        new_route = find_comparable_route(deployed_route)
+        if new_route && new_route.to != deployed_route.to
+          # change in already deployed route has been detected, requires bluegreen deploy
+          return true
+        end
+      end
+      false # Reaching here means no routes have been changed in a way that requires a bluegreen deploy
+    end
+
+    # Find a route that has the same path and method. This is a comparable route
+    # Then we will compare the to or controller action to see if an already
+    # deployed route has been changed.
+    def find_comparable_route(deployed_route)
+      new_routes.find do |new_route|
+        new_route.path == deployed_route.path &&
+        new_route.method == deployed_route.method
+      end
+    end
+  end
+end

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

@@ -0,0 +1,35 @@
+# Detects route variable changes
+class Jets::Resource::ApiGateway::RestApi::Routes::Change
+  class Variable < Base
+    def changed?
+      changed = false
+      deployed_routes.each do |deployed_route|
+        parent = collision.variable_parent(deployed_route.path)
+        parent_variables = collision.parent_variables(parent, [deployed_route.path])
+        new_parent_variables = collision.parent_variables(parent, new_paths)
+
+        changed = parent_variables.size > 0 && new_parent_variables.size > 0 &&
+                  parent_variables != new_parent_variables
+        break if changed
+      end
+      changed
+    end
+
+    # Only consider paths with variables
+    def new_paths
+      new_routes.map(&:path).select {|p| p.include?(':')}.uniq
+    end
+
+    # Only consider deployed routes with variables
+    def deployed_routes
+      deployed_routes = super
+      deployed_routes.select do |route|
+        route.path.include?(':')
+      end
+    end
+
+    def collision
+      @collision ||= Jets::Resource::ApiGateway::RestApi::Routes::Collision.new
+    end
+  end
+end

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

@@ -0,0 +1,16 @@
+# Detects route changes
+class Jets::Resource::ApiGateway::RestApi::Routes
+  class Change
+    include Jets::AwsServices
+
+    def changed?
+      return false unless parent_stack_exists?
+
+      MediaTypes.changed? || To.changed? || Variable.changed? || Page.changed? || ENV['JETS_REPLACE_API']
+    end
+
+    def parent_stack_exists?
+      stack_exists?(Jets::Naming.parent_stack_name)
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+class Jets::Resource::ApiGateway::RestApi::Routes::Collision
+  class VariableException < RuntimeError
+    def initialize(message="Route variable collisions")
+      super(message)
+    end
+  end
+end