jets_bb_fork 0.0.4

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

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

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

@@ -0,0 +1,31 @@
+module Jets::Resource::Events
+  class Rule < Jets::Resource::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::Resource::Base`
+    def merged_properties
+      {
+        state: "ENABLED",
+        targets: [{
+          arn: "!GetAtt {namespace}LambdaFunction.Arn",
+          id: "{namespace}RuleTarget"
+        }]
+      }.deep_merge(@props)
+    end
+
+    def rule_logical_id
+      "{namespace}_events_rule"
+    end
+  end
+end

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

@@ -0,0 +1,27 @@
+module Jets::Resource::Iam
+  class ApplicationRole < Jets::Resource::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
+      "iam_role"
+    end
+
+    def policy_name
+      "#{Jets.config.project_namespace}-application-policy"
+    end
+
+    def outputs
+      {
+        logical_id => "!Ref #{logical_id}",
+      }
+    end
+  end
+end

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

@@ -0,0 +1,47 @@
+module Jets::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: "/",
+            assume_role_policy_document: {
+              version: "2012-10-17",
+              statement: [{
+                effect: "Allow",
+                principal: {service: ["lambda.amazonaws.com"]},
+                action: ["sts:AssumeRole"]}
+              ]
+            }
+          }
+        }
+      }
+
+      definition[logical_id][:properties][:policies] = [
+        policy_name: "#{policy_name[0..127]}", # required, limited to 128-chars
+        policy_document: policy_document,
+      ] unless policy_document['Statement'].empty?
+
+      unless managed_policy_arns.empty?
+        definition[logical_id][:properties][:managed_policy_arns] = managed_policy_arns
+      end
+
+      definition
+    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/resource/iam/class_role.rb

@@ -0,0 +1,74 @@
+module Jets::Resource::Iam
+  class ClassRole < Jets::Resource::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}_iam_role".underscore
+    end
+
+    def policy_name
+      class_namespace = replacements[:namespace].underscore.dasherize
+      "#{Jets.config.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::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/resource/iam/function_role.rb

@@ -0,0 +1,54 @@
+module Jets::Resource::Iam
+  class FunctionRole < Jets::Resource::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}_iam_role".underscore
+    end
+
+    def policy_name
+      funcion_namespace = replacements[:namespace].underscore.dasherize
+      "#{Jets.config.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::Resource::Iam::ClassRole.new(@task.class_name.constantize)
+    end
+    memoize :class_role
+
+    def application_role
+      Jets::Resource::Iam::ApplicationRole.new
+    end
+    memoize :application_role
+  end
+end

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/iot/topic_rule.rb

@@ -0,0 +1,34 @@
+# CloudFormation AWS::IoT::TopicRule docs: https://amzn.to/2SMBOVm
+module Jets::Resource::Iot
+  class TopicRule < Jets::Resource::Base
+    def initialize(props={})
+      @props = props # associated_properties from dsl.rb
+    end
+
+    def definition
+      {
+        topic_logical_id => {
+          type: "AWS::IoT::TopicRule",
+          properties: merged_properties,
+        }
+      }
+    end
+
+    # Do not name this method properties, that is a computed method of `Jets::Resource::Base`
+    def merged_properties
+      {
+        # required properties
+        topic_rule_payload: {
+          actions: [{
+            lambda: { function_arn: "!GetAtt {namespace}LambdaFunction.Arn" }
+          }],
+          rule_disabled: 'true',
+        }
+      }.deep_merge(@props)
+    end
+
+    def topic_logical_id
+      "{namespace}_iot_topic_rule"
+    end
+  end
+end

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

@@ -0,0 +1,31 @@
+# Note the Lambda function timeout must be less than or equal to the sqs queue default timeout.
+module Jets::Resource::Lambda
+  class EventSourceMapping < Jets::Resource::Base
+    def initialize(props={})
+      @props = props # associated_properties from dsl.rb
+    end
+
+    def definition
+      # CloudFormation Docs: https://amzn.to/2WM6165
+      properties = {
+        # batch_size: 10, # Defaults: Kinesis 100, DynamoDB Streams: 100, SQS: 10
+        # enabled: boolean,
+        # event_source_arn: string, # required
+        function_name: "!Ref {namespace}LambdaFunction",
+        # starting_position: string # reqiured for Required for Amazon Kinesis and Amazon DynamoDB Streams sources
+      }
+      properties.merge!(@props)
+
+      {
+        event_source_mapping_logical_id => {
+          type: "AWS::Lambda::EventSourceMapping",
+          properties: properties
+        }
+      }
+    end
+
+    def event_source_mapping_logical_id
+      "{namespace}EventSourceMapping"
+    end
+  end
+end

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

@@ -0,0 +1,214 @@
+module Jets::Resource::Lambda
+  class Function < Jets::Resource::Base
+    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
+
+    # 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 > Jets::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