jets-fs 1.6.10

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

@@ -0,0 +1,24 @@
+# Inheriting classes should implement:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class Base < Jets::Resource::Base
+    def initialize(s3_bucket, options={})
+      @s3_bucket = s3_bucket
+      @options = options
+    end
+
+    def outputs
+      {
+        logical_id => "!Ref #{logical_id}",
+      }
+    end
+
+    def template_url
+      basename = File.basename(template_filename)
+      "https://s3.amazonaws.com/#{@s3_bucket}/jets/cfn-templates/#{basename}"
+    end
+  end
+end

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

@@ -0,0 +1,90 @@
+# Implements:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class Shared < AppClass
+    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.classify
+          props[:parameters][output] = "!GetAtt #{dependency_class}.Outputs.#{output}"
+        end
+      end if depends_on
+
+      props
+    end
+
+    def common_parameters
+      {
+        IamRole: "!GetAtt IamRole.Arn",
+        S3Bucket: "!Ref S3Bucket",
+      }
+    end
+
+    # Returns output keys associated with the stack.  They are the resource logical ids.
+    def dependency_outputs(dependency)
+      dependency.to_s.classify.constantize.output_keys
+    end
+
+    def depends_on
+      return unless current_shared_class.depends_on
+      current_shared_class.depends_on.map { |x| x.to_s.singularize.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('-','/')
+        .classify
+        .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.rb

@@ -0,0 +1,4 @@
+module Jets::Resource::Config
+  autoload :ConfigRule, 'jets/resource/config/config_rule'
+  autoload :ManagedRule, 'jets/resource/config/managed_rule'
+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.rb

@@ -0,0 +1,3 @@
+module Jets::Resource::Events
+  autoload :Rule, 'jets/resource/events/rule'
+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.rb

@@ -0,0 +1,8 @@
+module Jets::Resource::Iam
+  autoload :BaseRoleDefinition, 'jets/resource/iam/base_role_definition'
+  autoload :ApplicationRole, 'jets/resource/iam/application_role'
+  autoload :ClassRole, 'jets/resource/iam/class_role'
+  autoload :FunctionRole, 'jets/resource/iam/function_role'
+  autoload :PolicyDocument, 'jets/resource/iam/policy_document'
+  autoload :ManagedPolicy, 'jets/resource/iam/managed_policy'
+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