jets-fs 1.6.10

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

@@ -0,0 +1,22 @@
+module Jets::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/resource/iam/policy_document.rb

@@ -0,0 +1,41 @@
+module Jets::Resource::Iam
+  class PolicyDocument
+    extend Memoist
+
+    attr_reader :definitions
+    def initialize(*definitions)
+      @definitions = definitions.flatten
+      # empty starting policy that will be altered
+      @policy = {
+        version: "2012-10-17",
+        statement: []
+      }
+    end
+
+    def policy_document
+      definitions.map { |definition| standardize(definition) }
+      Jets::Camelizer.transform(@policy)
+    end
+    memoize :policy_document # only process policy_document once
+
+    def standardize(definition)
+      case definition
+      when String
+        # Expands simple string from: logs => logs:*
+        definition = "#{definition}:*" unless definition.include?(':')
+        @policy[:statement] << {
+          action: [definition],
+          effect: "Allow",
+          resource: "*",
+        }
+      when Hash
+        definition = definition.stringify_keys
+        if definition.key?("Version") # special case where we replace the policy entirely
+          @policy = definition
+        else
+          @policy[:statement] << definition
+        end
+      end
+    end
+  end
+end

data/lib/jets/resource/lambda.rb

@@ -0,0 +1,5 @@
+module Jets::Resource::Lambda
+  autoload :Function, 'jets/resource/lambda/function'
+  autoload :GemLayer, 'jets/resource/lambda/gem_layer'
+  autoload :LayerVersion, 'jets/resource/lambda/layer_version'
+end

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

@@ -0,0 +1,216 @@
+module Jets::Resource::Lambda
+  class Function < Jets::Resource::Base
+    autoload :Environment, 'jets/resource/lambda/function/environment'
+    include Environment
+
+    def initialize(task)
+      @task = task
+      @app_class = task.class_name.to_s
+    end
+
+    def definition
+      {
+        function_logical_id => {
+          type: "AWS::Lambda::Function",
+          properties: combined_properties
+        }
+      }
+    end
+
+    def function_logical_id
+      "{namespace}_lambda_function".underscore
+    end
+
+    def replacements
+      @task.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: {
+          s3_bucket: "!Ref S3Bucket",
+          s3_key: code_s3_key
+        },
+        role: "!Ref IamRole",
+        environment: { variables: environment },
+      }
+
+      appplication_config = Jets.application.config.function.to_h
+      baseline.merge(appplication_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_task(@task)
+
+      class_properties = lookup_class_properties(klass)
+      if klass.build_class_iam?
+        iam_policy = Jets::Resource::Iam::ClassRole.new(klass)
+        class_properties[:role] = "!GetAtt #{iam_policy.logical_id}.Arn"
+      end
+
+      class_properties
+    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 = @task.properties
+      if @task.build_function_iam?
+        iam_policy = Jets::Resource::Iam::FunctionRole.new(@task)
+        properties[:role] = "!GetAtt #{iam_policy.logical_id}.Arn"
+      end
+      properties
+    end
+
+    # Properties managed by Jets with merged with finality.
+    def finalize_properties!(props)
+      handler = full_handler(props)
+      runtime = get_runtime(props)
+      managed = {
+        handler: handler,
+        runtime: runtime,
+        description: description,
+      }
+      managed[:function_name] = 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/
+      ["!Ref GemLayer"] + Jets.config.lambda.layers
+    end
+
+    def get_runtime(props)
+      props[:runtime] || default_runtime
+    end
+
+    def default_runtime
+      map = {
+        node: "nodejs8.10",
+        python: "python3.6",
+        ruby: "ruby2.5",
+      }
+      map[@task.lang]
+    end
+
+    def default_handler
+      map = {
+        node: @task.full_handler(:handler), # IE: handlers/controllers/posts/show.handler
+        python: @task.full_handler(:lambda_handler), # IE: handlers/controllers/posts/show.lambda_handler
+        ruby: handler, # IE: handlers/controllers/posts_controllers.index
+      }
+      map[@task.lang]
+    end
+
+    def handler
+      handler_value(@task.meth)  # IE: handlers/controllers/posts_controllers.index
+    end
+
+    # Used for node-shim also
+    def handler_value(meth)
+      "handlers/#{@task.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
+
+    MAX_FUNCTION_NAME_SIZE = 64
+    # Examples:
+    #   "#{Jets.config.project_namespace}-sleep_job-perform"
+    #   "demo-dev-sleep_job-perform"
+    def function_name
+      # Example values:
+      #   @app_class: admin/pages_controller
+      #   @task.meth: index
+      #   method: admin/pages_controller
+      #   method: admin-pages_controller-index
+      method = @app_class.underscore
+      method = method.gsub('/','-').gsub(/[^0-9a-z\-_]/i, '') + "-#{@task.meth}"
+      function_name = "#{Jets.config.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 description
+      # Example values:
+      #   @app_class: Admin/PagesController
+      #   @task.meth: index
+      # Returns:
+      #   Admin/PagesController#index
+      "#{@app_class}##{@task.meth}"
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+class Jets::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 }}
+    end
+
+    def environment
+      env = Jets.config.environment ? Jets.config.environment.to_h : {}
+      env.deep_merge(jets_env)
+    end
+
+    # These jets env variables are special variables that get included to keeps some state
+    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_PROJECT_NAME] = ENV['JETS_PROJECT_NAME'] if ENV['JETS_PROJECT_NAME']
+      env[:JETS_STAGE] = Jets::Resource::ApiGateway::Deployment.stage_name
+      env
+    end
+
+  private
+    def check_reserved_variables!(variables)
+      found_reserved_vars = variables.keys & reserved_variables
+      return if found_reserved_vars.empty?
+
+      puts "You have configured some environment variables that are reserved by AWS Lambda.".color(:red)
+      puts found_reserved_vars
+      puts "The deployment to AWS Lambda will failed when using reserved variables."
+      puts "Please remove these reserved variables. "
+      puts "More info: https://docs.aws.amazon.com/lambda/latest/dg/current-supported-versions.html#lambda-environment-variables"
+      exit 1
+    end
+
+    # https://docs.aws.amazon.com/lambda/latest/dg/current-supported-versions.html#lambda-environment-variables
+    def reserved_variables
+      %w[
+        _HANDLER
+        AWS_REGION
+        AWS_EXECUTION_ENV
+        AWS_LAMBDA_FUNCTION_NAME
+        AWS_LAMBDA_FUNCTION_MEMORY_SIZE
+        AWS_LAMBDA_FUNCTION_VERSION
+        AWS_LAMBDA_LOG_GROUP_NAME
+        AWS_LAMBDA_LOG_STREAM_NAME
+        AWS_ACCESS_KEY_ID
+        AWS_SECRET_ACCESS_KEY
+        AWS_SESSION_TOKEN
+        TZ
+        LAMBDA_TASK_ROOT
+        LAMBDA_RUNTIME_DIR
+        AWS_LAMBDA_RUNTIME_API
+      ]
+    end
+
+
+  end
+end

data/lib/jets/resource/lambda/gem_layer.rb

@@ -0,0 +1,17 @@
+module Jets::Resource::Lambda
+  class GemLayer < LayerVersion
+    def description
+      "Jets Ruby Gems"
+    end
+
+    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"
+    end
+
+    def code_s3_key
+      checksum = Jets::Builders::Md5.checksums["stage/opt"]
+      "jets/code/opt-#{checksum}.zip" # s3_key
+    end
+  end
+end

data/lib/jets/resource/lambda/layer_version.rb

@@ -0,0 +1,44 @@
+# Type: "AWS::Lambda::LayerVersion"
+# Properties:
+#   CompatibleRuntimes:
+#     - String
+#     - ...
+#   Content:
+#     Content
+#   Description: String
+#   LayerName: String
+#   LicenseInfo: String
+module Jets::Resource::Lambda
+  class LayerVersion < Jets::Resource::Base
+    def definition
+      {
+        layer_version_logical_id => {
+          type: "AWS::Lambda::LayerVersion",
+          properties: {
+            content: {
+              s3_bucket: s3_bucket,
+              s3_key: code_s3_key,
+            },
+            description: description,
+            layer_name: layer_name,
+            license_info: "MIT",
+          }
+        }
+      }
+    end
+
+    def s3_bucket
+      "!Ref S3Bucket"
+    end
+
+    def layer_version_logical_id
+      self.class.name.split('::').last
+    end
+
+    def outputs
+      {
+        logical_id => "!Ref #{logical_id}",
+      }
+    end
+  end
+end

data/lib/jets/resource/permission.rb

@@ -0,0 +1,45 @@
+class Jets::Resource
+  class Permission < Jets::Resource::Base
+    def initialize(replacements, associated_resource)
+      @replacements = replacements
+      @associated_resource = associated_resource
+    end
+
+    def definition
+      logical_id = permission_logical_id
+
+      definition = {
+        logical_id => {
+          type: "AWS::Lambda::Permission",
+          properties: {
+            function_name: "!GetAtt {namespace}LambdaFunction.Arn",
+            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][:source_arn] = 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('').underscore
+    end
+
+    # Auto-detect principal from the associated resources.
+    def principal
+      Replacer.principal_map(@associated_resource.type)
+    end
+
+    def source_arn
+      Replacer.source_arn_map(@associated_resource.type)
+    end
+  end
+end