jets 4.0.8 → 5.0.0.beta1

data/lib/jets/cfn/resource/lambda/function.rb

@@ -0,0 +1,266 @@
+module Jets::Cfn::Resource::Lambda
+  class Function < Jets::Cfn::Base
+    MAX_FUNCTION_NAME_SIZE = 64
+    include Environment
+
+    def initialize(definition)
+      @definition = definition
+      @app_class = definition.class_name.to_s
+    end
+
+    def definition
+      {
+        function_logical_id => {
+          Type: "AWS::Lambda::Function",
+          Properties: combined_properties
+        }
+      }
+    end
+
+    # Examples:
+    #   one_lambda_per_controller PostsControllerLambdaHandlerLambdaFunction
+    #   one_lambda_per_method     PostsControllerIndexLambdaFunction
+    def function_logical_id
+      "{namespace}LambdaFunction"
+    end
+
+    def replacements
+      @definition.replacements # has namespace replacement
+    end
+
+    def combined_properties
+      props = env_properties
+        .deep_merge(global_properties)
+        .deep_merge(class_properties)
+        .deep_merge(function_properties)
+      finalize_properties!(props)
+    end
+
+    # Global properties example:
+    # jets defaults are in jets/default/application.rb.
+    # Your application's default config/application.rb then get used. Example:
+    #
+    #   Jets.application.configure do
+    #     config.function = ActiveSupport::OrderedOptions.new
+    #     config.function.timeout = 30
+    #     config.function.runtime = "nodejs8.10"
+    #     config.function.memory_size = 1536
+    #   end
+    def global_properties
+      baseline = {
+        Code: {
+          S3Bucket: "!Ref S3Bucket",
+          S3Key: code_s3_key
+        },
+        Role: "!Ref IamRole",
+        Environment: { Variables: environment },
+      }
+
+      application_config = camelize(Jets.application.config.function.to_h)
+      baseline.merge(application_config)
+    end
+
+    # Class properties example:
+    #
+    #   class PostsController < ApplicationController
+    #     class_timeout 22
+    #     ...
+    #   end
+    #
+    # Also handles iam policy override at the class level. Example:
+    #
+    #   class_iam_policy("logs:*")
+    #
+    def class_properties
+      # klass is PostsController, HardJob, GameRule, Hello or HelloFunction
+      klass = Jets::Klass.from_definition(@definition)
+
+      class_properties = lookup_class_properties(klass)
+      if assign_iam_role?(klass)
+        iam_policy = Jets::Cfn::Resource::Iam::ClassRole.new(klass)
+        class_properties[:Role] = "!GetAtt #{iam_policy.logical_id}.Arn"
+      end
+
+      camelize(class_properties)
+    end
+
+    # The IAM Role is built in the same nested template but determination of
+    # whether or not to assign the IAM Role is determined by the inheritance.
+    # The merging of permissions is already handled by Resource::Iam::*Role classes.
+    # This also avoids having to pass Application IAM role around.
+    def assign_iam_role?(klass)
+      assign = false
+      while klass && klass != Object
+        if klass&.build_class_iam?
+          assign = true
+          break
+        end
+        klass = klass.superclass
+      end
+      assign
+    end
+
+    # Accounts for inherited class_properties
+    def lookup_class_properties(klass)
+      all_classes = []
+      while klass != Object
+        all_classes << klass
+        klass = klass.superclass
+      end
+      class_properties = {}
+      # Go back down class heirachry top to down
+      all_classes.reverse.each do |k|
+        class_properties.merge!(k.class_properties)
+      end
+      class_properties
+    end
+
+    # Function properties example:
+    #
+    # class PostsController < ApplicationController
+    #   timeout 18
+    #   def index
+    #     ...
+    #   end
+    #
+    # Also handles iam policy override at the function level. Example:
+    #
+    #   iam_policy("ec2:*")
+    #   def new
+    #     render json: params.merge(action: "new")
+    #   end
+    #
+    def function_properties
+      properties = @definition.properties
+      if @definition.build_function_iam?
+        iam_policy = Jets::Cfn::Resource::Iam::FunctionRole.new(@definition)
+        properties[:Role] = "!GetAtt #{iam_policy.logical_id}.Arn"
+      end
+      camelize(properties)
+    end
+
+    # Properties managed by Jets merged with finality.
+    def finalize_properties!(props)
+      handler = full_handler(props)
+      runtime = get_runtime(props)
+      description = get_descripton(props)
+      managed = {
+        Handler: handler,
+        Runtime: runtime,
+        Description: description,
+      }
+      managed[:FunctionName] = function_name if function_name
+      layers = get_layers(runtime)
+      managed[:Layers] = layers if layers
+      props.merge!(managed)
+    end
+
+    def get_layers(runtime)
+      return nil unless runtime =~ /^ruby/ || runtime =~ /^provided/
+      return Jets.config.lambda.layers if Jets.config.pro.disable
+
+      ["!Ref GemLayer"] + Jets.config.lambda.layers
+    end
+
+    def get_runtime(props)
+      # Only allow custom runtime for ruby so polymorphic support works for python and node
+      if @definition.lang == :ruby
+        props[:Runtime] || default_runtime
+      else
+        default_runtime
+      end
+    end
+
+    def default_runtime
+      self.class.default_runtimes[@definition.lang]
+    end
+
+    # Also used by jets/stack/main/dsl/lambda.rb
+    def self.default_runtimes
+      {
+        node: "nodejs18.x",
+        python: "python3.10",
+        ruby: Jets.ruby_runtime,
+      }
+    end
+
+    def default_handler
+      map = {
+        node: @definition.full_handler(:handler), # IE: handlers/controllers/posts/show.handler
+        python: @definition.full_handler(:lambda_handler), # IE: handlers/controllers/posts/show.lambda_handler
+        ruby: handler, # IE: handlers/controllers/posts_controllers.index
+      }
+      map[@definition.lang]
+    end
+
+    def handler
+      handler_value(@definition.meth)  # IE: handlers/controllers/posts_controllers.index
+    end
+
+    # Used for node-shim also
+    def handler_value(meth)
+      "handlers/#{@definition.type.pluralize}/#{@app_class.underscore}.#{meth}"
+    end
+
+    # Ensure that the handler path is normalized.
+    def full_handler(props)
+      if props[:Handler]
+        handler_value(props[:Handler])
+      else
+        default_handler
+      end
+    end
+
+    def code_s3_key
+      checksum = Jets::Builders::Md5.checksums["stage/code"]
+      "jets/code/code-#{checksum}.zip" # s3_key
+    end
+
+    # Examples:
+    #   "#{Jets.project_namespace}-sleep_job-perform"
+    #   "demo-dev-sleep_job-perform"
+    def function_name
+      return if ENV['JETS_RESET'] # reset mode, let CloudFormation manage the function name
+      # Example values:
+      #   @app_class: admin/pages_controller
+      #   @definition.meth: index
+      #   method: admin/pages_controller
+      #   method: admin-pages_controller-index
+
+      method = @app_class.underscore
+      method = method.gsub('/','-').gsub(/[^0-9a-z\-_]/i, '')
+      unless one_lambda_per_controller?
+        method += "-#{@definition.meth}"
+      end
+      function_name = "#{Jets.project_namespace}-#{method}"
+
+      # Returns nil if function name is too long.
+      # CloudFormation will managed the the function name in this case.
+      # A pretty function name won't be generated but the deploy will be successful.
+      function_name.size > MAX_FUNCTION_NAME_SIZE ? nil : function_name
+    end
+
+    def get_descripton(props)
+      props[:Description] || default_description
+    end
+
+    # Example values:
+    #   @app_class: Admin/PagesController
+    #   @definition.meth: index
+    # Returns:
+    #   Admin/PagesController
+    # or
+    #   Admin/PagesController#index
+    def default_description
+      if one_lambda_per_controller?
+        "#{@app_class}"
+      else
+        "#{@app_class}##{@definition.meth}"
+      end
+    end
+
+    def one_lambda_per_controller?
+      Jets.one_lambda_per_controller? && @app_class.to_s.ends_with?("Controller")
+    end
+  end
+end

data/lib/jets/{resource → cfn/resource}/lambda/gem_layer.rb

@@ -1,4 +1,4 @@
-module Jets::Resource::Lambda
+module Jets::Cfn::Resource::Lambda
   class GemLayer < LayerVersion
     def description
       "Jets Ruby Gems"
@@ -6,7 +6,7 @@ module Jets::Resource::Lambda
 
     def layer_name
       # Do not include the Jets.extra_env to group the layers in same app together
-      "#{Jets.config.short_env}-#{Jets.config.project_name}-gems"
+      "#{Jets.short_env}-#{Jets.project_name}-gems"
     end
 
     def code_s3_key

data/lib/jets/{resource → cfn/resource}/lambda/layer_version.rb

@@ -8,20 +8,20 @@
 #   Description: String
 #   LayerName: String
 #   LicenseInfo: String
-module Jets::Resource::Lambda
-  class LayerVersion < Jets::Resource::Base
+module Jets::Cfn::Resource::Lambda
+  class LayerVersion < Jets::Cfn::Base
     def definition
       {
         layer_version_logical_id => {
-          type: "AWS::Lambda::LayerVersion",
-          properties: {
-            content: {
-              s3_bucket: s3_bucket,
-              s3_key: code_s3_key,
+          Type: "AWS::Lambda::LayerVersion",
+          Properties: {
+            Content: {
+              S3Bucket: s3_bucket,
+              S3Key: code_s3_key,
             },
-            description: description,
-            layer_name: layer_name,
-            license_info: "MIT",
+            Description: description,
+            LayerName: layer_name,
+            LicenseInfo: "Nonstandard",
           }
         }
       }

data/lib/jets/cfn/resource/lambda/permission.rb

@@ -0,0 +1,51 @@
+# Resource: Permissions are at the cfn/resource/permission.rb level because the
+# principal is determined by the calling or associated resource.
+# IE: Principal: events.amazonaws.com for Jets Jobs.
+module Jets::Cfn::Resource::Lambda
+  class Permission < Jets::Cfn::Base
+    def initialize(replacements, associated_resource, options={})
+      @replacements = replacements
+      @associated_resource = associated_resource
+      # allow override for Jets::Cfn::Resource::Lambda::Function::Controller permission
+      @principal = options[:Principal]
+      @source_arn = options[:SourceArn]
+    end
+
+    def definition
+      logical_id = permission_logical_id
+
+      definition = {
+        logical_id => {
+          Type: "AWS::Lambda::Permission",
+          Properties: {
+            FunctionName: "!Ref {namespace}LambdaFunction",
+            Action: "lambda:InvokeFunction",
+            Principal: principal
+          }
+        }
+      }
+
+      # From AWS docs: https://amzn.to/2N0QXQL
+      # source_arn is "not supported by all event sources"
+      definition[logical_id][:Properties][:SourceArn] = source_arn if source_arn
+
+      definition
+    end
+
+    def permission_logical_id
+      logical_id = "{namespace}Permission"
+      md = @associated_resource.logical_id.match(/(\d+)$/)
+      counter = md[1] if md
+      [logical_id, counter].compact.join('')
+    end
+
+    # Auto-detect principal from the associated resources.
+    def principal
+      @principal || replacer.principal_map(@associated_resource.type)
+    end
+
+    def source_arn
+      @source_arn || replacer.source_arn_map(@associated_resource.type)
+    end
+  end
+end

data/lib/jets/cfn/resource/logs/subscription_filter.rb

@@ -0,0 +1,31 @@
+# CloudFormation Log Subscription docs: https://amzn.to/2SNiSpr
+module Jets::Cfn::Resource::Logs
+  class SubscriptionFilter < Jets::Cfn::Base
+    def initialize(props={})
+      @props = props # associated_properties from dsl.rb
+    end
+
+    def definition
+      {
+        log_logical_id => {
+          Type: "AWS::Logs::SubscriptionFilter",
+          Properties: merged_properties,
+        }
+      }
+    end
+
+    # Do not name this method properties, that is a computed method of `Jets::Cfn::Resource`
+    def merged_properties
+      {
+        DestinationArn: "!GetAtt {namespace}LambdaFunction.Arn",
+        FilterPattern: "", # matches everything https://amzn.to/2N3b39I
+        # LogGroupName: string # will be set by log_event
+        # RoleArn: string # only required for kinensis, we dont use this for Lambda
+      }.deep_merge(@props)
+    end
+
+    def log_logical_id
+      "{namespace}SubscriptionFilter"
+    end
+  end
+end

data/lib/jets/cfn/resource/nested/api/base.rb

@@ -0,0 +1,4 @@
+module Jets::Cfn::Resource::Nested::Api
+  class Base < Jets::Cfn::Resource::Nested::Base
+  end
+end

data/lib/jets/cfn/resource/nested/api/deployment.rb

@@ -0,0 +1,53 @@
+module Jets::Cfn::Resource::Nested::Api
+  class Deployment < Base
+    # interface method
+    def definition
+      {
+        deployment_id => {
+          Type: "AWS::CloudFormation::Stack",
+          Properties: {
+            TemplateURL: template_url,
+            Parameters: parameters,
+          },
+          DependsOn: depends_on,
+        }
+      }
+    end
+
+    def parameters
+      { RestApi: "!GetAtt ApiGateway.Outputs.RestApi" }
+    end
+
+    def depends_on
+      depends_on_controllers + depends_on_api_methods
+    end
+
+    def depends_on_api_methods
+      pages = Jets::Cfn::Builder::Api::Pages::Methods.pages
+      pages.map do |page|
+        "ApiMethods#{page.number}"
+      end
+    end
+
+    def depends_on_controllers
+      controller_logical_ids = []
+      expression = "#{Jets::Names.templates_folder}/*_controller*"
+      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::Names.templates_folder}/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::Cfn::Resource::ApiGateway::Deployment.logical_id
+    end
+  end
+end

data/lib/jets/cfn/resource/nested/api/gateway.rb

@@ -0,0 +1,15 @@
+module Jets::Cfn::Resource::Nested::Api
+  class Gateway < Base
+    # interface method
+    def definition
+      {
+        ApiGateway: {
+          Type: "AWS::CloudFormation::Stack",
+          Properties: {
+            TemplateURL: template_url,
+          }
+        }
+      }
+    end
+  end
+end

data/lib/jets/cfn/resource/nested/api/mapping.rb

@@ -0,0 +1,33 @@
+module Jets::Cfn::Resource::Nested::Api
+  class Mapping < Base
+    # interface method
+    def definition
+      {
+        ApiMapping: {
+          Type: "AWS::CloudFormation::Stack",
+          Properties: {
+            TemplateURL: template_url,
+            Parameters: parameters,
+          },
+          DependsOn: 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
+      p
+    end
+
+    def depends_on
+      [Jets::Cfn::Resource::ApiGateway::Deployment.logical_id]
+    end
+  end
+end

data/lib/jets/cfn/resource/nested/api/methods.rb

@@ -0,0 +1,30 @@
+module Jets::Cfn::Resource::Nested::Api
+  # interface method
+  class Methods < Page
+    def definition
+      {
+        "ApiMethods#{@page_number}" =>  {
+          Type: "AWS::CloudFormation::Stack",
+          Properties: {
+            TemplateURL: template_url,
+            Parameters: parameters,
+          },
+        }
+      }
+    end
+
+    # Read current paged ApiMethods1 template and see what parameters it needs.
+    # Then add them to the params hash from Controller Lambda functions outputs
+    # Example:
+    #
+    # api-methods-1.yml:
+    #
+    #   params["PostsControllerIndexLambdaFunction"] = "!GetAtt UpController.Outputs.PostsControllerIndexLambdaFunction"
+    #
+    def parameters
+      template_path = Jets::Names.api_methods_template_path(@page_number)
+      api_methods = Jets::Cfn::Params::Api::Methods.new(template_path: template_path)
+      api_methods.params
+    end
+  end
+end

data/lib/jets/cfn/resource/nested/api/page.rb

@@ -0,0 +1,8 @@
+module Jets::Cfn::Resource::Nested::Api
+  class Page < Base
+    def initialize(options={})
+      super
+      @page_number = options[:page_number]
+    end
+  end
+end

data/lib/jets/cfn/resource/nested/api/resources.rb

@@ -0,0 +1,22 @@
+module Jets::Cfn::Resource::Nested::Api
+  class Resources < Page
+    # interface method
+    def definition
+      {
+        "ApiResources#{@page_number}" =>  {
+          Type: "AWS::CloudFormation::Stack",
+          Properties: {
+            TemplateURL: template_url,
+            Parameters: parameters,
+          }
+        }
+      }
+    end
+
+    def parameters
+      template_path = Jets::Names.api_resources_template_path(@page_number)
+      api_resources = Jets::Cfn::Params::Api::Resources.new(template_path: template_path)
+      api_resources.params
+    end
+  end
+end

data/lib/jets/{resource/child_stack → cfn/resource/nested}/app_class.rb

@@ -1,29 +1,23 @@
-# Implements:
-#
-#   definition
-#   template_filename
-#
-module Jets::Resource::ChildStack
+module Jets::Cfn::Resource::Nested
   class AppClass < Base
-    include CommonParameters
-
-    def initialize(s3_bucket, options={})
+    def initialize(options={})
       super
       @path = options[:path]
     end
 
+    # interface method
     def definition
       logical_id = app_logical_id
       defintion = {
         logical_id => {
-          type: "AWS::CloudFormation::Stack",
-          properties: {
-            template_url: template_url,
-            parameters: parameters,
+          Type: "AWS::CloudFormation::Stack",
+          Properties: {
+            TemplateURL: template_url,
+            Parameters: parameters,
           }
         }
       }
-      defintion[logical_id][:depends_on] = depends.stack_list if depends
+      defintion[logical_id][:DependsOn] = depends.stack_list if depends
       defintion
     end
 
@@ -54,48 +48,31 @@ module Jets::Resource::ChildStack
     end
 
     def parameters
-      params = self.class.common_parameters
+      params = Jets::Cfn::Params::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?
+      return {} if Jets::Router.no_routes?
 
       params = {
         RestApi: "!GetAtt ApiGateway.Outputs.RestApi",
       }
 
       template_path = @path
-      template = Jets::Cfn::BuiltTemplate.get(template_path)
-      template['Parameters'].each do |p,data|
+      template = Jets::Cfn::Template.load_file(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"
+          params[p] = "!GetAtt #{authorizer_output(data[:Description])}"
         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
@@ -118,14 +95,8 @@ module Jets::Resource::ChildStack
       @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::Names.template_path_prefix}-app-"
+      templates_prefix = "#{Jets::Names.templates_folder}/app-"
       @path.sub(templates_prefix, '')
         .sub(/\.yml$/,'')
         .gsub('-','/')
@@ -137,13 +108,9 @@ module Jets::Resource::ChildStack
     #   /tmp/jets/demo/templates/demo-dev-2-posts_controller.yml to
     #   PostsController
     def app_logical_id
-      regexp = Regexp.new(".*#{Jets.config.project_namespace}-app-")
+      regexp = Regexp.new(".*#{Jets::Names.templates_folder}/app-")
       controller_name = @path.sub(regexp, '').sub('.yml', '')
       controller_name.underscore.camelize
     end
-
-    def template_filename
-      @path
-    end
   end
 end