jets 3.1.0 → 5.0.10

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

@@ -0,0 +1,21 @@
+# Handles one_lambda_per_controller
+class Jets::Cfn::Resource::Lambda::Function
+  class Controller < Jets::Cfn::Resource::Lambda::Function
+    # override
+    def combined_properties
+      props = env_properties
+        .deep_merge(global_properties)
+        .deep_merge(class_properties)
+        # .deep_merge(function_properties) # comment left to emphasize controller cannot have function_properties
+      finalize_properties!(props)
+    end
+
+    # override
+    def permission
+      Jets::Cfn::Resource::Lambda::Permission.new(replacements, self,
+        Principal: "apigateway.amazonaws.com",
+        SourceArn: "!Sub arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${RestApi}/*/*",
+      )
+    end
+  end
+end

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

@@ -1,14 +1,14 @@
-class Jets::Resource::Lambda::Function
+class Jets::Cfn::Resource::Lambda::Function
   module Environment
     def env_properties
       env_vars = Jets::Dotenv.load!(true)
       variables = environment.merge(env_vars)
       check_reserved_variables!(variables)
-      {environment: { variables: variables }}
+      {Environment: { Variables: variables }}
     end
 
     def environment
-      env = Jets.config.environment ? Jets.config.environment.to_h : {}
+      env = Jets.config.function.environment ? Jets.config.function.environment.to_h : {}
       env.deep_merge(jets_env)
     end
 
@@ -16,9 +16,9 @@ class Jets::Resource::Lambda::Function
     def jets_env
       env = {}
       env[:JETS_ENV] = Jets.env.to_s
-      env[:JETS_ENV_EXTRA] = Jets.config.env_extra if Jets.config.env_extra
+      env[:JETS_EXTRA] = Jets.extra if Jets.extra
       env[:JETS_PROJECT_NAME] = ENV['JETS_PROJECT_NAME'] if ENV['JETS_PROJECT_NAME']
-      env[:JETS_STAGE] = Jets::Resource::ApiGateway::Deployment.stage_name
+      env[:JETS_STAGE] = Jets::Cfn::Resource::ApiGateway::Deployment.stage_name
       env[:JETS_AWS_ACCOUNT] = Jets.aws.account
       env
     end
@@ -36,21 +36,23 @@ class Jets::Resource::Lambda::Function
       exit 1
     end
 
-    # https://docs.aws.amazon.com/lambda/latest/dg/current-supported-versions.html#lambda-environment-variables
+    # https://docs.aws.amazon.com/lambda/latest/dg/configuration-envvars.html
     def reserved_variables
       %w[
         _HANDLER
+        AWS_DEFAULT_REGION
         AWS_REGION
         AWS_EXECUTION_ENV
         AWS_LAMBDA_FUNCTION_NAME
         AWS_LAMBDA_FUNCTION_MEMORY_SIZE
         AWS_LAMBDA_FUNCTION_VERSION
+        AWS_LAMBDA_INITIALIZATION_TYPE
         AWS_LAMBDA_LOG_GROUP_NAME
         AWS_LAMBDA_LOG_STREAM_NAME
+        AWS_ACCESS_KEY
         AWS_ACCESS_KEY_ID
         AWS_SECRET_ACCESS_KEY
         AWS_SESSION_TOKEN
-        TZ
         LAMBDA_TASK_ROOT
         LAMBDA_RUNTIME_DIR
         AWS_LAMBDA_RUNTIME_API

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