jets.benforeva 3.0.17.pre.mount.pre.fix

data/lib/jets/resource/child_stack/shared.rb

@@ -0,0 +1,85 @@
+# Implements:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class Shared < AppClass
+    include CommonParameters
+
+    def initialize(s3_bucket, options={})
+      super
+      @path = options[:path]
+    end
+
+    def definition
+      logical_id = shared_logical_id
+      definition = {
+        logical_id => {
+          type: "AWS::CloudFormation::Stack",
+          properties: child_properties
+        }
+      }
+      definition[logical_id][:depends_on] = depends_on if depends_on
+      definition
+    end
+
+    def child_properties
+      props = {
+        template_url: template_url,
+      }
+
+      props[:parameters] = common_parameters # common child parameters
+      # add depends on parameters
+      depends_on.each do |dependency|
+        dependency_outputs(dependency).each do |output|
+          dependency_class = dependency.to_s.camelize
+          props[:parameters][output] = "!GetAtt #{dependency_class}.Outputs.#{output}"
+        end
+      end if depends_on
+
+      props
+    end
+
+    # Returns output keys associated with the stack.  They are the resource logical ids.
+    def dependency_outputs(dependency)
+      dependency.to_s.camelize.constantize.output_keys
+    end
+
+    def depends_on
+      return unless current_shared_class.depends_on
+      current_shared_class.depends_on.map { |x| x.to_s.camelize }
+    end
+
+    # map the path to a camelized logical_id. Example:
+    #   /tmp/jets/demo/templates/demo-dev-2-shared-resources.yml to
+    #   PostsController
+    def shared_logical_id
+      regexp = Regexp.new(".*#{Jets.config.project_namespace}-shared-") # remove the shared
+      shared_name = @path.sub(regexp, '').sub('.yml', '')
+      shared_name.underscore.camelize
+    end
+
+    # IE: app/resource.rb => Resource
+    # Returns Resource class object in the example
+    def current_shared_class
+      templates_prefix = "#{Jets::Naming.template_path_prefix}-shared-"
+      @path.sub(templates_prefix, '')
+        .sub(/\.yml$/,'')
+        .gsub('-','/')
+        .camelize
+        .constantize # returns actual class
+    end
+
+    # Tells us if there are any resources defined in the shared class.
+    #
+    # Returns: Boolean
+    def resources?
+      current_shared_class.build?
+    end
+
+    def template_filename
+      "#{Jets.config.project_namespace}-shared-#{current_shared_class.to_s.underscore}.yml"
+    end
+  end
+end

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

@@ -0,0 +1,74 @@
+module Jets::Resource::Config
+  class ConfigRule < Jets::Resource::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][:depends_on] = "{namespace}Permission"
+      end
+
+      base
+    end
+
+    # Do not name this method properties, that is a computed method of `Jets::Resource::Base`
+    def definition_properties
+      {
+        config_rule_name: config_rule_name,
+        source: {
+          owner: "CUSTOM_LAMBDA",
+          source_identifier: "!GetAtt {namespace}LambdaFunction.Arn",
+          source_details: [
+            {
+              event_source: "aws.config",
+              message_type: "ConfigurationItemChangeNotification"
+            },
+            {
+              event_source: "aws.config",
+              message_type: "OversizedConfigurationItemChangeNotification"
+            }
+          ]
+        },
+      }.deep_merge(@props)
+    end
+
+    def config_rule_logical_id
+      "{namespace}_config_rule"
+    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.config.project_namespace
+      else
+        namespace
+      end
+    end
+  end
+end

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/environment.rb

@@ -0,0 +1,62 @@
+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[:JETS_AWS_ACCOUNT] = Jets.aws.account
+      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