jets 0.8.18 → 0.9.0

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

@@ -22,5 +22,33 @@ module Jets::Resource::Iam
         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/policy_document.rb

@@ -10,8 +10,6 @@ module Jets::Resource::Iam
         version: "2012-10-17",
         statement: []
       }
-      # https://docs.aws.amazon.com/IAM/latest/UserGuide/reference_policies_elements_sid.html
-      @sid = 0 # counter
     end
 
     def policy_document
@@ -21,13 +19,11 @@ module Jets::Resource::Iam
     memoize :policy_document # only process policy_document once
 
     def standardize(definition)
-      @sid += 1
       case definition
       when String
         # Expands simple string from: logs => logs:*
         definition = "#{definition}:*" unless definition.include?(':')
         @policy[:statement] << {
-          sid: "Stmt#{@sid}",
           action: [definition],
           effect: "Allow",
           resource: "*",

data/lib/jets/resource/permission.rb

@@ -6,17 +6,24 @@ class Jets::Resource
     end
 
     def definition
-      {
-        permission_logical_id => {
+      logical_id = permission_logical_id
+
+      definition = {
+        logical_id => {
           type: "AWS::Lambda::Permission",
           properties: {
             function_name: "!GetAtt {namespace}LambdaFunction.Arn",
             action: "lambda:InvokeFunction",
-            principal: principal,
-            source_arn: source_arn,
+            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
@@ -32,8 +39,7 @@ class Jets::Resource
     end
 
     def source_arn
-      default_arn = "!GetAtt #{@associated_resource.logical_id}.Arn"
-      Replacer.source_arn_map(@associated_resource.type) || default_arn
+      Replacer.source_arn_map(@associated_resource.type)
     end
   end
 end

data/lib/jets/resource/replacer.rb

@@ -62,6 +62,10 @@ class Jets::Resource
         "#{service}.amazonaws.com"
       end
 
+      # From AWS docs: https://amzn.to/2N0QXQL
+      # source_arn is "not supported by all event sources"
+      #
+      # When it is not available the resource definition should add it.
       def source_arn_map(type)
         map = {
           "AWS::ApiGateway::Method" => "!Sub arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${RestApi}/*/*",

data/lib/jets/resource/sns.rb

@@ -0,0 +1,3 @@
+module Jets::Resource::Sns
+  autoload :Topic, 'jets/resource/sns/topic'
+end

data/lib/jets/resource/standardizer.rb

@@ -0,0 +1,42 @@
+class Jets::Resource
+  class Standardizer
+    attr_reader :definition
+    def initialize(*definition)
+      @definition = definition.flatten
+    end
+
+    def template
+      camelize(standarize(@definition))
+    end
+
+    def camelize(attributes)
+      Jets::Camelizer.transform(attributes)
+    end
+
+    def standarize(definition)
+      first, second, third, _ = definition
+      if definition.size == 1 && first.is_a?(Hash) # long form
+        first # pass through
+      elsif definition.size == 2 && second.is_a?(Hash) # medium form
+        logical_id, attributes = first, second
+        attributes.delete(:properties) if attributes[:properties].nil? || attributes[:properties].empty?
+        { logical_id => attributes }
+      elsif definition.size == 2 && second.is_a?(String) # short form
+        logical_id, type = first, second
+        { logical_id => {
+            type: type
+        }}
+      elsif definition.size == 3 && (second.is_a?(String) || second.is_a?(NilClass))# short form
+        logical_id, type, properties = first, second, third
+        template = { logical_id => {
+                       type: type
+                    }}
+        attributes = template.values.first
+        attributes[:properties] = properties unless properties.empty?
+        template
+      else # Dont understand this form
+        raise "Invalid form provided. definition #{definition.inspect}"
+      end
+    end
+  end
+end

data/lib/jets/router.rb

@@ -30,7 +30,15 @@ module Jets
     end
 
     def api_mode?
-      Jets.config.api_generator
+      if Jets.config.api_generator
+        puts <<~EOL.colorize(:yellow)
+          DEPRECATED: Jets.config.api_generator
+          Instead, please update your config/application.rb to use:
+            Jets.config.api_mode
+        EOL
+      end
+      api_mode = Jets.config.api_mode || Jets.config.api_generator
+      api_mode
     end
 
     def create_route(options)

data/lib/jets/rule/dsl.rb

@@ -3,12 +3,22 @@
 # So the Jets::Rule::Dsl overrides some of the Jets::Lambda::Functions behavior.
 #
 # Implements:
-#   default_associated_resource: must return @resources
+#
+#   default_associated_resource_definition
+#
 module Jets::Rule::Dsl
   extend ActiveSupport::Concern
 
   included do
     class << self
+      def rule_namespace(value=nil)
+        if value.nil?
+          @rule_namespace # getter
+        else
+          @rule_namespace = value # # setter
+        end
+      end
+
       # Allows for different types of values. Examples:
       #
       # String: scope "AWS::EC2::SecurityGroup"
@@ -23,102 +33,65 @@ module Jets::Rule::Dsl
           else # default to hash
             value
           end
-        update_properties(scope: scope)
+        associated_properties(scope: scope)
       end
 
-      def config_rule_name(value)
-        update_properties(config_rule_name: value)
-      end
-
-      def description(value)
-        update_properties(description: value)
-      end
+      # Convenience method that set properties. List based on https://amzn.to/2oSph1P
+      # Not all properties are included because some properties are not meant to be set
+      # directly. For example, function_name is a calculated setting by Jets.
+      ASSOCIATED_PROPERTIES = %W[
+        config_rule_name
+        description
+        input_parameters
+        maximum_execution_frequency
+      ]
+      define_associated_properties(ASSOCIATED_PROPERTIES)
       alias_method :desc, :description
 
-      def input_parameters(value)
-        update_properties(input_parameters: value)
+      def default_associated_resource_definition(meth)
+        config_rule_definition(meth)
       end
 
-      def maximum_execution_frequency(value)
-        update_properties(maximum_execution_frequency: value)
+      def config_rule_definition(meth)
+        resource = Jets::Resource::Config::ConfigRule.new(self, meth, associated_properties)
+        resource.definition # returns a definition to be added by associated_resources
       end
 
-      def source(value)
-        update_properties(source: value)
-      end
-
-      def default_associated_resource
-        config_rule
-      end
-
-      def config_rule(props={})
-        default_props = {
-          config_rule_name: "{config_rule_name}",
-          source: {
-            owner: "CUSTOM_LAMBDA",
-            source_identifier: "{namespace}LambdaFunction.Arn",
-            source_details: [
-              {
-                event_source: "aws.config",
-                message_type: "ConfigurationItemChangeNotification"
-              },
-              {
-                event_source: "aws.config",
-                message_type: "OversizedConfigurationItemChangeNotification"
-              }
-            ]
-          }
-        }
-        properties = default_props.deep_merge(props)
-
-        resource("{namespace}ConfigRule" => {
-          type: "AWS::Config::ConfigRule",
-          properties: properties
-        })
-        @resources # must return @resoures for update_properties
-      end
-
-      def managed_rule(name, props={})
+      def managed_rule(name)
         name = name.to_s
+        managed_rule = Jets::Resource::Config::ManagedRule.new(self, name, associated_properties)
+        resource(managed_rule.definition) # Sets @associated_resources
 
-        # Similar logic in Replacer::ConfigRule#config_rule_name
-        name_without_rule = self.name.underscore.gsub(/_rule$/,'')
-        config_rule_name = "#{name_without_rule}_#{name}".dasherize
-        source_identifier = name.upcase
-
-        default_props = {
-          config_rule_name: config_rule_name,
-          source: {
-            owner: "AWS",
-            source_identifier: source_identifier,
-          }
-        }
-        properties = default_props.deep_merge(props)
-        # The key is to use update_properties to update the current resource and maintain
-        # the added properties from the convenience methods like scope and description.
-        # At the same time, we do not register the task to all_tasks to avoid creating a Lambda function.
+        # The key to not register the task to all_tasks to avoid creating a Lambda function.
         # Instead we store it in all_managed_rules.
-        update_properties(properties)
-        definition = @resources.first
-
-        register_managed_rule(name, definition)
+        register_managed_rule(name, managed_rule.definition)
       end
 
       # Creates a task but registers it to all_managed_rules instead of all_tasks
       # because we do not want Lambda functions to be created.
       def register_managed_rule(name, definition)
-        # A task object is needed to build {namespace} for later replacing.
-        task = Jets::Lambda::Task.new(self.name, name, resources: @resources)
 
-        # TODO: figure out better way for specific replacements for different classes
-        name_without_rule = self.name.underscore.gsub(/_rule$/,'')
-        config_rule_name = "#{name_without_rule}_#{name}".dasherize
-        replacements = task.replacements.merge(config_rule_name: config_rule_name)
-
-        all_managed_rules[name] = { definition: definition, replacements: replacements }
+        # Mimic task to grab base_replacements, namely namespace.
+        # Do not actually use the task to create a Lambda function for managed rules.
+        # Only using the task for base_replacements.
+        resources = [definition]
+        meth = name
+        task = Jets::Lambda::Task.new(self.name, meth,
+                 resources: resources,
+                 replacements: replacements(meth))
+        all_managed_rules[name] = { definition: definition, replacements: task.replacements }
         clear_properties
       end
 
+      # Override lambda/dsl.rb to add config_rule_name also
+      def replacements(meth)
+        name_without_rule = self.name.underscore.gsub(/_rule$/,'')
+        config_rule_name = "#{name_without_rule}_#{meth}".dasherize
+        {
+          config_rule_name: config_rule_name
+        }
+      end
+
       # AWS managed rules are not actual Lambda functions and require their own storage.
       def all_managed_rules
         @all_managed_rules ||= ActiveSupport::OrderedHash.new
@@ -128,7 +101,7 @@ module Jets::Rule::Dsl
         all_managed_rules.values
       end
 
-      # Override Lambda::Dsl.build? to account of possible managed_rules
+      # Override Lambda::Dsl.build? to account for possible managed_rules
       def build?
         !tasks.empty? || !managed_rules.empty?
       end

data/lib/jets/stack.rb

@@ -0,0 +1,105 @@
+require 'active_support/concern'
+
+module Jets
+  class Stack
+    autoload :Definition, 'jets/stack/definition' # Registration and definitions
+    autoload :Main, 'jets/stack/main'
+    autoload :Parameter, 'jets/stack/parameter'
+    autoload :Output, 'jets/stack/output'
+    autoload :Resource, 'jets/stack/resource'
+    autoload :Builder, 'jets/stack/builder'
+    autoload :Function, 'jets/stack/function'
+
+    include Main::Dsl
+    include Parameter::Dsl
+    include Output::Dsl
+    include Resource::Dsl
+
+    class << self
+      extend Memoist
+
+      # Track all command subclasses.
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(base)
+        super
+        self.subclasses << base if base.name
+      end
+
+      # Build it to figure out if we need to build the stack for the SharedBuilder
+      def build?
+        empty = template == {"Parameters"=>{"IamRole"=>{"Type"=>"String"}, "S3Bucket"=>{"Type"=>"String"}}}
+        !empty
+      end
+
+      def functions
+        stack = new
+        # All the & because resources might be nil
+        templates = stack.resources&.map(&:template)&.select do |t|
+          attributes = t.values.first
+          attributes['Type'] == 'AWS::Lambda::Function'
+        end
+        templates ||= []
+        templates.map { |t| Function.new(t) }
+      end
+
+      def template
+        # Pretty funny looking, creating an instance of stack to be passed to the Builder.
+        # Another way of looking at it:
+        #
+        #   stack = new # MyStack.new
+        #   builder = Jets::Stack::Builder.new(stack)
+        #
+        builder = Jets::Stack::Builder.new(new)
+        builder.template
+      end
+      memoize :template
+
+      def has_resources?
+        !subclasses.empty?
+      end
+
+      # Usage:
+      #
+      #   Jets::Stack.has_resources?
+      #
+      def has_resources?
+        # need to eager load the app/shared resources in order to check if shared resources have been registered
+        eager_load_shared_resources!
+        !!subclasses.detect do |subclass|
+          subclass.build?
+        end
+      end
+
+      def eager_load_shared_resources!
+        ActiveSupport::Dependencies.autoload_paths += ["#{Jets.root}app/shared/resources"]
+        Dir.glob("#{Jets.root}app/shared/resources/*.rb").select do |path|
+          next if !File.file?(path) or path =~ %r{/javascript/} or path =~ %r{/views/}
+
+          class_name = path
+                        .sub(/\.rb$/,'') # remove .rb
+                        .sub(Jets.root.to_s,'') # remove ./
+                        .sub(%r{app/shared/resources/},'') # remove app/shared/resources/
+                        .classify
+          class_name.constantize # use constantize instead of require so dont have to worry about order.
+        end
+      end
+
+      def lookup(logical_id)
+        looker.output(logical_id)
+      end
+
+      def looker
+        Jets::Stack::Output::Lookup.new(self)
+      end
+      memoize :looker
+
+      def output_keys
+        outputs = new.outputs || []
+        outputs.map(&:template).map {|o| o.keys.first}
+      end
+    end
+  end
+end