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

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

@@ -0,0 +1,121 @@
+# Detects path variable collisions
+class Jets::Resource::ApiGateway::RestApi::Routes
+  class Collision
+    attr_reader :collisions
+    def initialize
+      @collisions = []
+    end
+
+    def collision?(paths)
+      paths = paths_with_variables(paths)
+      parents = variable_parents(paths)
+
+      collide = false
+      parents.each do |parent|
+        collide ||= variable_collision_exists?(parent, paths)
+      end
+      collide
+    end
+
+    def exception
+      VariableException.new(collision_message)
+    end
+
+    def collision_message
+      <<~EOL
+        There are routes with sibling variables under the same parent that collide.
+
+        Collisions:
+          #{@collisions.join("\n  ")}
+
+        API Gateway only allows one unique variable path You must use the same variable name within
+        the same parent route path.
+        Example: /posts/:id and /posts/:post_id/reveal should both be /posts/:id and /posts/:id/reveal.
+
+        Please check your `config/routes.rb` and remove the colliding routes.
+        More info: http://rubyonjets.com/docs/considerations/api-gateway/
+      EOL
+    end
+
+    def variable_collision_exists?(parent, paths)
+      paths = paths_with_variables(paths)
+      variables = parent_variables(parent, paths)
+      collide = variables.uniq.size > 1
+      register_collision(parent, variables) if collide
+      collide
+    end
+
+    # register collision for later display
+    # We don't register the full path but this might be more helpful.
+    def register_collision(parent, variables)
+      return unless variables.uniq.size # check again just in case
+
+      variables.each do |v|
+        @collisions << "#{parent}/#{v}"
+      end
+      @collisions.uniq!
+    end
+
+    def parent_variables(parent, paths)
+      paths = paths.select do |path|
+        parent?(parent, path)
+      end
+      paths.map do |path|
+        path.sub("#{parent}/",'').gsub(%r{/.*},'')
+      end.select { |x| x =~ /^:/ }.uniq.sort
+    end
+
+    def parent?(parent, path)
+      return false if parent == path
+
+      parent_parts = parent.split('/')
+      path_parts = path.split('/')
+
+      n = parent_parts.size-1
+      parent_parts[0..n] == path_parts[0..n]
+    end
+
+    def direct_parent?(parent, path)
+      leaf = variable_leaf(path)
+      leaf_parent = leaf.split('/')[0..-2].join('/')
+      parent == leaf_parent
+    end
+
+    def variable_parents(paths)
+      parents = []
+      paths = paths_with_variables(paths)
+      paths.each do |path|
+        parents << variable_parent(path)
+      end
+      parents.uniq.sort
+    end
+
+    # Strips the path down until only the leaf node part is a variable
+    # Example: users/:user_id/posts/:post_id/edit
+    # Returns: users/:user_id/posts
+    def variable_parent(path)
+      path = variable_leaf(path)
+      # drop last variable to leave behind the parent
+      path.split('/')[0..-2].join('/')
+    end
+
+    # Strips the path down until only the leaf node part is a variable
+    # Example: users/:user_id/posts/:post_id/edit
+    # Returns: users/:user_id/posts
+    def variable_leaf(path)
+      return '' unless path.include?(':')
+
+      parts = path.split('/')
+      is_variable = parts.last.include?(':')
+      until is_variable
+        parts.pop
+        is_variable = parts.last.include?(':')
+      end
+      parts[0..-1].join('/') # parent
+    end
+
+    def paths_with_variables(paths)
+      paths.select { |p| p.include?(':') }.uniq
+    end
+  end
+end

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

@@ -0,0 +1,7 @@
+class Jets::Resource::ApiGateway::RestApi
+  class Routes
+    def self.changed?
+      Change.new.changed?
+    end
+  end
+end

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

@@ -0,0 +1,64 @@
+module Jets::Resource::ApiGateway
+  class RestApi < Jets::Resource::Base
+    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
+      properties[:policy] = endpoint_policy if endpoint_policy
+
+      {
+        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
+
+    def endpoint_policy
+      endpoint_policy = Jets.config.api.endpoint_policy
+      return nil if endpoint_policy.nil? || endpoint_policy.empty?
+
+      endpoint_policy
+    end
+  end
+end

data/lib/jets/resource/associated.rb

@@ -0,0 +1,37 @@
+# Does not do full expansion, mainly a container that holds the definition and
+# standardizes it without camelizing it.
+class Jets::Resource
+  class Associated
+    extend Memoist
+
+    attr_reader :definition
+    attr_accessor :multiple_resources
+    def initialize(*definition)
+      @definition = definition.flatten
+      # Some associated resources require multiple resources for a single Lambda function. For
+      # example `sqs_event` can create a `SQS::Queue` and `Lambda::EventSourceMapping`.  We set
+      # a `multiple` flag so `add_logical_id_counter` can use it to avoid adding counter ids to
+      # these type of resources. The `multiple` flag allows us to handle both:
+      #
+      #   1. Associated resources that contain multiple resources for a single Lambda function
+      #   2. A single Lambda function with multiple events.  In this case, a counter is added
+      #
+      # Setting `multiple` to true means the counter id will not be added.
+      @multiple_resources = false
+    end
+
+    def logical_id
+      standardized.keys.first
+    end
+
+    def attributes
+      standardized.values.first
+    end
+
+    def standardized
+      standardizer = Standardizer.new(definition)
+      standardizer.standarize(definition) # doesnt camelize keys yet
+    end
+    memoize :standardized
+  end
+end

data/lib/jets/resource/base.rb

@@ -0,0 +1,28 @@
+# Classes that inherit from this method should NOT define and override:
+#
+#   logical_id
+#   type
+#   properties
+#   attributes
+#
+# These are computed methods that derive their values from the resource definition itself.
+# Overriding these methods will remove the computed logical which handles things
+# like camelizing and replacements.
+#
+# The implementation of these methods are in `Jets::Resource`.
+class Jets::Resource
+  class Base
+    extend Memoist
+    delegate :logical_id, :type, :properties, :attributes, :parameters, :outputs,
+             to: :resource
+
+    def resource
+      Jets::Resource.new(definition, replacements)
+    end
+    memoize :resource
+
+    def replacements
+      @replacements || {}
+    end
+  end
+end

data/lib/jets/resource/child_stack/api_deployment.rb

@@ -0,0 +1,58 @@
+# Implements:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class ApiDeployment < Base
+    def definition
+      {
+        deployment_id => {
+          type: "AWS::CloudFormation::Stack",
+          properties: {
+            template_url: template_url,
+            parameters: parameters,
+          },
+          depends_on: depends_on,
+        }
+      }
+    end
+
+    def parameters
+      p = {
+        GemLayer: "!Ref GemLayer",
+        IamRole: "!GetAtt IamRole.Arn",
+        RestApi: "!GetAtt ApiGateway.Outputs.RestApi",
+        S3Bucket: "!Ref S3Bucket",
+      }
+      p[:DomainName] = "!GetAtt ApiGateway.Outputs.DomainName" if Jets.custom_domain?
+      p[:BasePath] = Jets.config.domain.base_path unless Jets.config.domain.base_path.nil?
+      p
+    end
+
+    def depends_on
+      expression = "#{Jets::Naming.template_path_prefix}-*_controller*"
+      controller_logical_ids = []
+      Dir.glob(expression).each do |path|
+        next unless File.file?(path)
+
+        # map the path to a camelized logical_id. Example:
+        #   /tmp/jets/demo/templates/demo-dev-2-posts_controller.yml to
+        #   PostsController
+        regexp = Regexp.new(".*#{Jets.config.project_namespace}-app-")
+        controller_name = path.sub(regexp, '').sub('.yml', '')
+        controller_logical_id = controller_name.underscore.camelize
+        controller_logical_ids << controller_logical_id
+      end
+      controller_logical_ids
+    end
+
+    def deployment_id
+      Jets::Resource::ApiGateway::Deployment.logical_id
+    end
+
+    def template_filename
+      "#{Jets.config.project_namespace}-api-deployment.yml"
+    end
+  end
+end

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

@@ -0,0 +1,23 @@
+# Implements:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class ApiGateway < Base
+    def definition
+      {
+        api_gateway: {
+          type: "AWS::CloudFormation::Stack",
+          properties: {
+            template_url: template_url,
+          }
+        }
+      }
+    end
+
+    def template_filename
+      "#{Jets.config.project_namespace}-api-gateway.yml"
+    end
+  end
+end

data/lib/jets/resource/child_stack/api_resource/page.rb

@@ -0,0 +1,20 @@
+class Jets::Resource::ChildStack::ApiResource
+  # Find the ApiResource Page that contains the AWS::ApiGateway::Resource
+  # Returns: logical id of ApiResource Page
+  class Page
+    def self.logical_id(parameter)
+      expression = "#{Jets::Naming.template_path_prefix}-api-resources-*"
+      # IE: path: #{Jets.build_root}/templates/demo-dev-2-api-resources-1.yml"
+      template_paths = Dir.glob(expression).sort.to_a
+      found_template = template_paths.detect do |path|
+        next unless File.file?(path)
+
+        template = Jets::Cfn::BuiltTemplate.get(path)
+        template['Outputs'].keys.include?(parameter)
+      end
+      md = found_template.match(/-(api-resources-\d+)/)
+
+      md[1].underscore.camelize # IE: ApiResources1
+    end
+  end
+end

data/lib/jets/resource/child_stack/api_resource.rb

@@ -0,0 +1,54 @@
+# Implements:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class ApiResource < Base
+    def initialize(*)
+      super
+      @page = @options[:page]
+    end
+
+    def definition
+      {
+        "api_resources_#{@page}" =>  {
+          type: "AWS::CloudFormation::Stack",
+          # depends_on: "ApiGateway", # CloudFormation seems to be smart enough
+          properties: {
+            template_url: template_url,
+            parameters: parameters,
+          }
+        }
+      }
+    end
+
+    def parameters
+      params = {}
+      # Since dont have all the info required.
+      # Read the template back to find the parameters required.
+      # Actually might be easier to rationalize this approach.
+      template_path = Jets::Naming.api_resources_template_path(@page)
+      template = Jets::Cfn::BuiltTemplate.get(template_path)
+      template['Parameters'].keys.each do |p|
+        case p
+        when "RestApi"
+          params[p] = "!GetAtt ApiGateway.Outputs.RestApi"
+        when "RootResourceId"
+          params[p] = "!GetAtt ApiGateway.Outputs.RootResourceId"
+        else
+          params[p] = "!GetAtt #{api_resource_page(p)}.Outputs.#{p}"
+        end
+      end
+      params
+    end
+
+    def api_resource_page(parameter)
+      Page.logical_id(parameter)
+    end
+
+    def template_filename
+      "#{Jets.config.project_namespace}-api-resources-#{@page}.yml"
+    end
+  end
+end

data/lib/jets/resource/child_stack/app_class.rb

@@ -0,0 +1,149 @@
+# Implements:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class AppClass < Base
+    include CommonParameters
+
+    def initialize(s3_bucket, options={})
+      super
+      @path = options[:path]
+    end
+
+    def definition
+      logical_id = app_logical_id
+      defintion = {
+        logical_id => {
+          type: "AWS::CloudFormation::Stack",
+          properties: {
+            template_url: template_url,
+            parameters: parameters,
+          }
+        }
+      }
+      defintion[logical_id][:depends_on] = depends.stack_list if depends
+      defintion
+    end
+
+    def depends
+      return if all_depends_on.empty?
+      Jets::Stack::Depends.new(all_depends_on)
+    end
+    memoize :depends
+
+    # Always returns an Array, could be empty
+    def all_depends_on
+      depends_on = current_app_class.depends_on || [] # contains Depends::Items
+      stagger_depends_on = @stagger_depends_on  || [] # contains Depends::Items
+      depends_on + stagger_depends_on
+    end
+
+    # For staggering. We're abusing depends_on to slow down the update rate.
+    #
+    # For this type of depends_on, there are no template parameters or outputs. To use the normal depends at we would
+    # have to make app classes adhere to what Jets::Stack::Depends requires.  This is mainly dependency_outputs and
+    # output_keys for each class right now.  It would not be that difficult but is not needed. So we create the
+    # Jets::Stack::Depends::Item objects directly.
+    def add_stagger_depends_on(stacks)
+      stack_names = stacks.map { |s| s.current_app_class.to_s.underscore }
+      items = stack_names.map { |name| Jets::Stack::Depends::Item.new(name) }
+      @stagger_depends_on ||= []
+      @stagger_depends_on += items.flatten
+    end
+
+    def parameters
+      params = self.class.common_parameters
+      params.merge!(controller_params) if controller?
+      params.merge!(depends.params) if depends
+      params
+    end
+
+    def self.common_parameters
+      parameters = {
+        IamRole: "!GetAtt IamRole.Arn",
+        S3Bucket: "!Ref S3Bucket",
+      }
+      parameters[:GemLayer] = "!Ref GemLayer" unless Jets.poly_only?
+      parameters
+    end
+
+    def controller_params
+      return {} if Jets::Router.routes.empty?
+
+      params = {
+        RestApi: "!GetAtt ApiGateway.Outputs.RestApi",
+      }
+
+      template_path = @path
+      template = Jets::Cfn::BuiltTemplate.get(template_path)
+      template['Parameters'].each do |p,data|
+        case p
+        when /Resource$/ # AWS::ApiGateway::Resource in api-resources templates. IE: demo-dev-api-resources-2.yml
+          params[p] = "!GetAtt #{api_resource_page(p)}.Outputs.#{p}"
+        when /Authorizer$/ # AWS::ApiGateway::Authorizer in authorizers templates. IE: demo-dev-authorizers.yml
+          # Description contains metadata to get the Authorizer logical id
+          params[p] = "!GetAtt #{authorizer_output(data["Description"])}"
+        when 'RootResourceId'
+          params[p] = "!GetAtt ApiGateway.Outputs.RootResourceId"
+        end
+      end
+      params
+    end
+
+    def api_resource_page(parameter)
+      ApiResource::Page.logical_id(parameter)
+    end
+
+    def authorizer_output(desc)
+      authorizer_stack, authorizer_logical_id = desc.split('.')
+      # IE: MainAuthorizer.Outputs.ProtectAuthorizer
+      "#{authorizer_stack}.Outputs.#{authorizer_logical_id}"
+    end
+
+    def outputs
+      if controller? or job?
+        {}
+      else
+        super # { logical_id => "!Ref #{logical_id}" } in base.rb
+      end
+    end
+
+    def controller?
+      @path.include?('_controller.yml')
+    end
+
+    def job?
+      @path.include?('_job.yml')
+    end
+
+    def scoped_routes
+      @routes ||= Jets::Router.routes.select do |route|
+        route.controller_name == current_app_class.to_s
+      end
+    end
+
+    def current_app_class
+      templates_prefix = "#{Jets::Naming.template_path_prefix}-app-"
+      @path.sub(templates_prefix, '')
+        .sub(/\.yml$/,'')
+        .gsub('-','/')
+        .camelize
+        .constantize
+    end
+
+    # map the path to a camelized logical_id. Example:
+    #   /tmp/jets/demo/templates/demo-dev-2-posts_controller.yml to
+    #   PostsController
+    def app_logical_id
+      regexp = Regexp.new(".*#{Jets.config.project_namespace}-app-")
+      controller_name = @path.sub(regexp, '').sub('.yml', '')
+      controller_name.underscore.camelize
+    end
+
+    def template_filename
+      @path
+    end
+  end
+end

data/lib/jets/resource/child_stack/authorizer.rb

@@ -0,0 +1,40 @@
+module Jets::Resource::ChildStack
+  class Authorizer < Base
+    include CommonParameters
+
+    def initialize(s3_bucket, options={})
+      super
+      @path = options[:path]
+    end
+
+    def definition
+      logical_id = authorizer_logical_id
+      {
+        logical_id => {
+          type: "AWS::CloudFormation::Stack",
+          properties: {
+            template_url: template_url,
+            parameters: parameters,
+          }
+        }
+      }
+    end
+
+    def parameters
+      params = common_parameters
+      params[:RestApi] = "!GetAtt ApiGateway.Outputs.RestApi"
+      params
+    end
+
+    # map the path to a camelized logical_id. IE: ProtectAuthorizer
+    def authorizer_logical_id
+      regexp = Regexp.new(".*#{Jets.config.project_namespace}-authorizers-")
+      authorizer_name = @path.sub(regexp, '').sub('.yml', '')
+      authorizer_name.underscore.camelize
+    end
+
+    def template_filename
+      @path
+    end
+  end
+end

data/lib/jets/resource/child_stack/base.rb

@@ -0,0 +1,24 @@
+# Inheriting classes should implement:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class Base < Jets::Resource::Base
+    def initialize(s3_bucket, options={})
+      @s3_bucket = s3_bucket
+      @options = options
+    end
+
+    def outputs
+      {
+        logical_id => "!Ref #{logical_id}",
+      }
+    end
+
+    def template_url
+      basename = File.basename(template_filename)
+      "https://s3.amazonaws.com/#{@s3_bucket}/jets/cfn-templates/#{basename}"
+    end
+  end
+end

data/lib/jets/resource/child_stack/common_parameters.rb

@@ -0,0 +1,14 @@
+module Jets::Resource::ChildStack
+  module CommonParameters
+    def common_parameters
+      parameters = {
+        IamRole: "!GetAtt IamRole.Arn",
+        S3Bucket: "!Ref S3Bucket",
+      }
+      parameters[:GemLayer] = "!Ref GemLayer" unless Jets.poly_only?
+      parameters
+    end
+
+    extend self
+  end
+end