jets 5.0.14 → 6.0.0.beta1

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

@@ -1,35 +0,0 @@
-# Detects route variable changes
-class Jets::Cfn::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::Cfn::Resource::ApiGateway::RestApi::Routes::Collision.new
-    end
-  end
-end

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

@@ -1,27 +0,0 @@
-# Detects route changes
-class Jets::Cfn::Resource::ApiGateway::RestApi::Routes
-  class Change
-    include Jets::AwsServices
-
-    def changed?
-      return false unless parent_stack_exists?
-      return true if reset?
-
-      # Note: Variable.changed? will likely always true in one_apigw_method_for_all_routes mode
-      # since parent variables are allowed to vary in Jets v5.
-      if Jets.config.cfn.build.routes == "one_apigw_method_for_all_routes"
-        MediaTypes.changed? || To.changed?
-      else
-        MediaTypes.changed? || To.changed? || Variable.changed? || Page.changed?
-      end
-    end
-
-    def reset?
-      ENV['JETS_RESET'] || ENV['JETS_API_REPLACE'] || ENV['JETS_REPLACE_API']
-    end
-
-    def parent_stack_exists?
-      stack_exists?(Jets::Names.parent_stack_name)
-    end
-  end
-end

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

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

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

@@ -1,121 +0,0 @@
-# Detects path variable collisions
-class Jets::Cfn::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/cfn/resource/api_gateway/rest_api/routes.rb

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

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

@@ -1,74 +0,0 @@
-module Jets::Cfn::Resource::ApiGateway
-  class RestApi < Jets::Cfn::Base
-    def definition
-      properties = {
-        Name: Jets::Names.gateway_api_name,
-        EndpointConfiguration: { Types: endpoint_types }
-      }
-      properties[:EndpointConfiguration][:VpcEndpointIds] = vpce_ids if vpce_ids
-      properties[:BinaryMediaTypes] = 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
-
-    private
-
-    def vpce_ids
-      ids = Jets.config.api.vpc_endpoint_ids
-      return nil if ids.nil? || ids.empty?
-
-      ids
-    end
-  end
-end

data/lib/jets/cfn/resource/config/config_rule.rb

@@ -1,74 +0,0 @@
-module Jets::Cfn::Resource::Config
-  class ConfigRule < Jets::Cfn::Base
-    def initialize(app_class, meth, props={})
-      @app_class = app_class.to_s
-      @meth = meth
-      @props = props # associated_properties from dsl.rb
-    end
-
-    def definition
-      base = {
-        config_rule_logical_id => {
-          Type: "AWS::Config::ConfigRule",
-          Properties: definition_properties
-        }
-      }
-
-      # Explicitly set depends_on to help with CloudFormation random race condition.
-      # Seems to be a new CloudFormation and AWS Config resource issue.
-      if definition_properties[:Source][:Owner] == 'CUSTOM_LAMBDA'
-        base[config_rule_logical_id][:DependsOn] = "{namespace}Permission"
-      end
-
-      base
-    end
-
-    # Do not name this method properties, that is a computed method of `Jets::Cfn::Resource`
-    def definition_properties
-      {
-        ConfigRuleName: config_rule_name,
-        Source: {
-          Owner: "CUSTOM_LAMBDA",
-          SourceIdentifier: "!GetAtt {namespace}LambdaFunction.Arn",
-          SourceDetails: [
-            {
-              EventSource: "aws.config",
-              MessageType: "ConfigurationItemChangeNotification"
-            },
-            {
-              EventSource: "aws.config",
-              MessageType: "OversizedConfigurationItemChangeNotification"
-            }
-          ]
-        },
-      }.deep_merge(@props)
-    end
-
-    def config_rule_logical_id
-      "{namespace}ConfigRule"
-    end
-
-    def config_rule_name
-      app_class = @app_class.underscore.gsub(/_rule$/,'')
-      ns = namespace
-      ns = nil if ns == false # for compact
-      [ns, "#{app_class}_#{@meth}"].compact.join('_').dasherize
-    end
-
-    def namespace
-      namespace = nil
-      klass = @app_class.constantize
-      while klass != Jets::Lambda::Functions
-        namespace = klass.rule_namespace
-        break if namespace or namespace == false
-        klass = klass.superclass
-      end
-
-      if namespace.nil?
-        Jets.project_namespace
-      else
-        namespace
-      end
-    end
-  end
-end

data/lib/jets/cfn/resource/config/managed_rule.rb

@@ -1,15 +0,0 @@
-# ManagedRule is just different enough to be a separate class vs being part of the
-# ConfigRule class itself.
-module Jets::Cfn::Resource::Config
-  class ManagedRule < ConfigRule
-    def definition_properties
-      {
-        ConfigRuleName: config_rule_name,
-        Source: {
-          Owner: "AWS",
-          SourceIdentifier: @meth.upcase,
-        },
-      }.deep_merge(@props)
-    end
-  end
-end

data/lib/jets/cfn/resource/events/rule.rb

@@ -1,31 +0,0 @@
-module Jets::Cfn::Resource::Events
-  class Rule < Jets::Cfn::Base
-    def initialize(props={})
-      @props = props # associated_properties from dsl.rb
-    end
-
-    def definition
-      {
-        rule_logical_id => {
-          Type: "AWS::Events::Rule",
-          Properties: merged_properties
-        }
-      }
-    end
-
-    # Do not name this method properties, that is a computed method of `Jets::Cfn::Resource`
-    def merged_properties
-      {
-        State: "ENABLED",
-        Targets: [{
-          Arn: "!GetAtt {namespace}LambdaFunction.Arn",
-          Id: "{namespace}RuleTarget"
-        }]
-      }.deep_merge(@props)
-    end
-
-    def rule_logical_id
-      "{namespace}EventsRule"
-    end
-  end
-end

data/lib/jets/cfn/resource/iam/application_role.rb

@@ -1,27 +0,0 @@
-module Jets::Cfn::Resource::Iam
-  class ApplicationRole < Jets::Cfn::Base
-    include BaseRoleDefinition
-
-    def initialize
-      @policy_definitions = Jets.config.iam_policy # config.iam_policy contains definitions
-      @policy_definitions = @policy_definitions ? [@policy_definitions].flatten : []
-
-      @managed_policy_definitions = Jets.config.managed_iam_policy # config.managed_iam_policy contains definitions
-      @managed_policy_definitions = @managed_policy_definitions ? [@managed_policy_definitions].flatten : []
-    end
-
-    def role_logical_id
-      "IamRole"
-    end
-
-    def policy_name
-      "#{Jets.project_namespace}-application-policy"
-    end
-
-    def outputs
-      {
-        logical_id => "!Ref #{logical_id}",
-      }
-    end
-  end
-end

data/lib/jets/cfn/resource/iam/base_role_definition.rb

@@ -1,56 +0,0 @@
-module Jets::Cfn::Resource::Iam
-  module BaseRoleDefinition
-    attr_reader :policy_definitions, :managed_policy_definitions
-
-    def definition
-      logical_id = role_logical_id
-
-      # Do not assign pretty role_name because long controller names might hit the 64-char
-      # limit. Also, IAM roles are global, so assigning role names prevents cross region deploys.
-      definition = {
-        logical_id => {
-          Type: "AWS::IAM::Role",
-          Properties: {
-            Path: "/",
-            AssumeRolePolicyDocument: {
-              Version: "2012-10-17",
-              Statement: [{
-                Effect: "Allow",
-                Principal: {Service: ["lambda.amazonaws.com"]},
-                Action: ["sts:AssumeRole"]}
-              ]
-            }
-          }
-        }
-      }
-
-      # Add vpc permissions to all policies
-      definition[logical_id][:Properties][:Policies] = [
-        PolicyName: "vpc", # required, limited to 128-chars
-        PolicyDocument: vpc_policy_document,
-      ] if vpc_policy_document
-
-      unless managed_policy_arns.empty?
-        definition[logical_id][:Properties][:ManagedPolicyArns] = managed_policy_arns
-      end
-
-      definition
-    end
-
-    def vpc_policy_document
-      if Jets.config.function.vpc_config
-        {
-          Statement: [Jets.config.vpc_iam_policy_statement]
-        }
-      end
-    end
-
-    def policy_document
-      PolicyDocument.new(@policy_definitions.flatten.uniq).policy_document
-    end
-
-    def managed_policy_arns
-      ManagedPolicy.new(@managed_policy_definitions.flatten.uniq).arns
-    end
-  end
-end

data/lib/jets/cfn/resource/iam/class_role.rb

@@ -1,74 +0,0 @@
-module Jets::Cfn::Resource::Iam
-  class ClassRole < Jets::Cfn::Base
-    include BaseRoleDefinition
-
-    def initialize(app_class)
-      @app_class = app_class.to_s # IE: PostsController, HardJob, Hello, HelloFunction
-      @policy_definitions = lookup_iam_policies
-      @managed_policy_definitions = lookup_managed_iam_policies
-    end
-
-    def role_logical_id
-      "{namespace}IamRole"
-    end
-
-    def policy_name
-      class_namespace = replacements[:namespace].underscore.dasherize
-      "#{Jets.project_namespace}-#{class_namespace}-policy" # camelized because used as template value
-    end
-
-    def replacements
-      {
-        namespace: @app_class.gsub('::','').camelize, # camelized because can be used as value
-      }
-    end
-
-    def policy_document
-      # Handles precedence inheritance from the ApplicationRole to the ClassRole
-      @policy_definitions += application_role.policy_definitions if inherit?
-      super
-    end
-
-    def managed_policy_arns
-      @managed_policy_definitions += application_role.managed_policy_definitions if inherit?
-      super
-    end
-
-    # There are 2 types of inheritance: from superclasses and from higher precedence policies.
-    # This one manages the inheritance for higher precedence policies.
-    def inherit?
-      !@policy_definitions.empty? || !@managed_policy_definitions.empty?
-    end
-
-    def application_role
-      Jets::Cfn::Resource::Iam::ApplicationRole.new
-    end
-    memoize :application_role
-
-    # Accounts for inherited class_managed_iam_policy from superclasses
-    def lookup_managed_iam_policies
-      all_classes.map do |k|
-        k.class_managed_iam_policy # class_managed_iam_policy contains definitions
-      end.uniq
-    end
-
-    # Accounts for inherited class_iam_policies from superclasses
-    def lookup_iam_policies
-      all_classes.map do |k|
-        k.class_iam_policy # class_iam_policy contains definitions
-      end.uniq
-    end
-
-    # Class heirachry in top to down order
-    def all_classes
-      klass = @app_class.constantize
-      all_classes = []
-      while klass != Object
-        all_classes << klass
-        klass = klass.superclass
-      end
-      all_classes.reverse
-    end
-    memoize :all_classes
-  end
-end

data/lib/jets/cfn/resource/iam/function_role.rb

@@ -1,54 +0,0 @@
-module Jets::Cfn::Resource::Iam
-  class FunctionRole < Jets::Cfn::Base
-    include BaseRoleDefinition
-
-    def initialize(task)
-      @task = task
-      @policy_definitions = task.iam_policy || [] # iam_policy contains policy definitions
-      @managed_policy_definitions = task.managed_iam_policy || [] # managed_iam_policy contains policy definitions
-    end
-
-    def role_logical_id
-      "{namespace}IamRole"
-    end
-
-    def policy_name
-      funcion_namespace = replacements[:namespace].underscore.dasherize
-      "#{Jets.project_namespace}-#{funcion_namespace}-policy" # camelized because used as template value
-    end
-
-    def replacements
-      {
-        namespace: "#{@task.class_name.gsub('::','')}#{@task.meth.to_s.camelize}", # camelized because can be used as value
-      }
-    end
-
-    def policy_document
-      if inherit?
-        @policy_definitions += class_role.policy_definitions + application_role.policy_definitions
-      end
-      super
-    end
-
-    def managed_policy_arns
-      if inherit?
-        @managed_policy_definitions += class_role.managed_policy_definitions + application_role.managed_policy_definitions
-      end
-      super
-    end
-
-    def inherit?
-      !@policy_definitions.empty? || !@managed_policy_definitions.empty?
-    end
-
-    def class_role
-      Jets::Cfn::Resource::Iam::ClassRole.new(@task.class_name.constantize)
-    end
-    memoize :class_role
-
-    def application_role
-      Jets::Cfn::Resource::Iam::ApplicationRole.new
-    end
-    memoize :application_role
-  end
-end

data/lib/jets/cfn/resource/iam/managed_policy.rb

@@ -1,22 +0,0 @@
-module Jets::Cfn::Resource::Iam
-  class ManagedPolicy
-    extend Memoist
-
-    attr_reader :definitions
-    def initialize(*definitions)
-      @definitions = definitions.flatten.compact
-    end
-
-    def arns
-      definitions.map { |definition| standardize(definition) }
-    end
-    memoize :arns # only process arns once
-
-    # AmazonEC2ReadOnlyAccess => arn:aws:iam::aws:policy/AmazonEC2ReadOnlyAccess
-    def standardize(definition)
-      return definition if definition.include?('iam::aws:policy')
-
-      "arn:aws:iam::aws:policy/#{definition}"
-    end
-  end
-end

data/lib/jets/cfn/resource/iam/policy.rb

@@ -1,31 +0,0 @@
-module Jets::Cfn::Resource::Iam
-  class Policy < Jets::Cfn::Base
-    def initialize(role)
-      @role = role
-    end
-    delegate :policy_document, :policy_name, :role_logical_id, :replacements, to: :@role
-
-    def policy_logical_id
-      role_logical_id.sub(/Role$/, "Policy")
-    end
-
-    def definition
-      logical_id = policy_logical_id
-
-      # Do not assign pretty role_name because long controller names might hit the 64-char
-      # limit. Also, IAM roles are global, so assigning role names prevents cross region deploys.
-      definition = {
-        logical_id => {
-          Type: "AWS::IAM::Policy",
-          Properties: {
-            Roles: [Ref: role_logical_id.camelize],
-            PolicyName: "#{policy_name[0..127]}", # required, limited to 128-chars
-            PolicyDocument: policy_document,
-          }
-        }
-      }
-
-      definition
-    end
-  end
-end