jets-fs 1.6.10

data/lib/jets/router/scope.rb

@@ -0,0 +1,30 @@
+module Jets
+  class Router
+    class Scope
+      attr_reader :options, :parent, :level
+      def initialize(options = {}, parent = nil, level = 1)
+        @options = options
+        @parent = parent
+        @level = level
+      end
+
+      def root?
+        @parent.nil?
+      end
+
+      def new(options={})
+        self.class.new(options, self, level + 1)
+      end
+
+      def full_namespace
+        ns = []
+        current = self
+        while current
+          ns.unshift(current.options[:namespace])
+          current = current.parent
+        end
+        ns.empty? ? nil : ns.join('/')
+      end
+    end
+  end
+end

data/lib/jets/rule.rb

@@ -0,0 +1,4 @@
+class Jets::Rule
+  autoload :Base, "jets/rule/base"
+  autoload :Dsl, "jets/rule/dsl"
+end

data/lib/jets/rule/base.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+# Base public methods get turned into Lambda functions.
+#
+# Jets::Rule::Base < Jets::Lambda::Functions
+# Both Jets::Rule::Base and Jets::Lambda::Functions have Dsl modules included.
+# So the Jets::Rule::Dsl overrides some of the Jets::Lambda::Functions behavior.
+class Jets::Rule
+  class Base < Jets::Lambda::Functions
+    include Dsl
+
+    class << self
+      def process(event, context, meth)
+        job = new(event, context, meth)
+        job.send(meth)
+      end
+    end
+  end
+end

data/lib/jets/rule/dsl.rb

@@ -0,0 +1,110 @@
+# Jets::Rule::Base < Jets::Lambda::Functions
+# Both Jets::Rule::Base and Jets::Lambda::Functions have Dsl modules included.
+# So the Jets::Rule::Dsl overrides some of the Jets::Lambda::Functions behavior.
+#
+# Implements:
+#
+#   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"
+      # Array:  scope ["AWS::EC2::SecurityGroup"]
+      # Hash:   scope {"ComplianceResourceTypes" => ["AWS::EC2::SecurityGroup"]}
+      def scope(value)
+        scope = case value
+          when String
+            {compliance_resource_types: [value]}
+          when Array
+            {compliance_resource_types: value}
+          else # default to hash
+            value
+          end
+        associated_properties(scope: scope)
+      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 default_associated_resource_definition(meth)
+        config_rule_definition(meth)
+      end
+
+      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 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
+
+        # The key to not register the task to all_tasks to avoid creating a Lambda function.
+        # Instead we store it in all_managed_rules.
+        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)
+
+        # 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
+      end
+
+      def managed_rules
+        all_managed_rules.values
+      end
+
+      # Override Lambda::Dsl.build? to account for possible managed_rules
+      def build?
+        !tasks.empty? || !managed_rules.empty?
+      end
+    end
+  end
+end

data/lib/jets/spec_helpers.rb

@@ -0,0 +1,52 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Jets
+  module SpecHelpers
+    autoload :Params, 'jets/spec_helpers/params'
+    autoload :Request, 'jets/spec_helpers/request'
+    autoload :Response, 'jets/spec_helpers/response'
+
+    attr_reader :request, :response
+    def initialize(*)
+      super
+      @request = Request.new(:get, '/', {}, Params.new)
+      @response = nil # will be set after http_call
+    end
+
+    rest_methods = %w[get post put patch delete]
+    rest_methods.each do |meth|
+      define_method(meth) do |path, **params|
+        http_call(method: meth, path: path, **params)
+      end
+      # Example:
+      # def get(path, **params)
+      #   http_call(method: :get, path: path, **params)
+      # end
+    end
+
+    def http_call(method:, path:, **params)
+      request.method = method.to_sym
+      request.path = path
+      request.headers.deep_merge!(params.delete(:headers) || {})
+
+      request.params.body_params = params.delete(:params) || params || {}
+      request.params.path_params = params
+
+      @response = request.dispatch!
+    end
+
+    def fixture_path(filename)
+      "#{Jets.root}/spec/fixtures/#{filename}"
+    end
+
+    def fixture_file(filename)
+      File.new(fixture_path(filename))
+    end
+  end
+end
+
+RSpec.configure do |c|
+  c.include Jets::SpecHelpers
+end

data/lib/jets/spec_helpers/params.rb

@@ -0,0 +1,10 @@
+module Jets
+  module SpecHelpers
+    class Params
+      attr_accessor :path_params, :body_params
+      def initialize(path_params={}, body_params={})
+        @path_params, @body_params = path_params, body_params
+      end
+    end
+  end
+end

data/lib/jets/spec_helpers/request.rb

@@ -0,0 +1,98 @@
+module Jets
+  module SpecHelpers
+    class Request
+      attr_accessor :method, :path, :headers, :params
+      def initialize(method, path, headers={}, params={})
+        @method, @path, @headers, @params = method, path, headers, params
+      end
+
+      def event
+        json = {}
+        id_params = path.scan(%r{:([^/]+)}).flatten
+        expanded_path = path.dup
+        path_parameters = {}
+
+        id_params.each do |id_param|
+          raise "missing param: :#{id_param}" unless params.path_params.include? id_param.to_sym
+
+          path_param_value = params.path_params[id_param.to_sym]
+          raise "Path param :#{id_param} value cannot be blank" if path_param_value.blank?
+
+          expanded_path.gsub!(":#{id_param}", path_param_value.to_s)
+          path_parameters.deep_merge!(id_param => path_param_value.to_s)
+        end
+
+        json['resource'] = path
+        json['path'] = expanded_path
+        json['httpMethod'] = method.to_s.upcase
+        json['pathParameters'] = path_parameters
+        json['headers'] = (headers || {}).stringify_keys
+
+        if method != :get
+          json['headers']['Content-Type'] = "multipart/form-data; boundary=#{multipart_boundary}"
+          body = +''
+          params.body_params.to_a.each do |e|
+            key, value = e
+            body << multipart_item(name: key, value: value)
+          end
+          body << multipart_end
+
+          json['body'] = Base64.encode64 body
+          json['isBase64Encoded'] = true
+        end
+
+        json
+      end
+
+      def multipart_boundary
+        @boundary ||= '-' * 16 + SecureRandom.hex(32)
+      end
+
+      def multipart_item(name:, value:)
+        if value.is_a? File
+          multipart_file(name: name, filename: File.basename(value.path),
+                         data: ::IO.read(value.path))
+        else
+          multipart_text(name: name, text: value)
+        end
+      end
+
+      def multipart_text(name:, text:)
+        "--#{multipart_boundary}\r\nContent-Disposition: form-data; name=\"#{name}\"\r\n"\
+        "Content-Type: text/plain\r\n\r\n#{text}\r\n"
+      end
+
+      def multipart_file(name:, filename:, data:)
+        "--#{multipart_boundary}\r\nContent-Disposition: form-data; name=\"#{name}\"; "\
+        "filename=\"#{filename}\"\r\n\r\n#{data}\r\n"
+      end
+
+      def multipart_end
+        "--#{multipart_boundary}--"
+      end
+
+      def find_route!
+        path = self.path
+        path = path[0..-2] if path.end_with? '/'
+        path = path[1..-1] if path.start_with? '/'
+
+        route = Jets::Router.routes.find { |r| r.path == path && r.method == method.to_s.upcase }
+        raise "Route not found: #{method.to_s.upcase} #{path}" if route.blank?
+
+        route
+      end
+
+      def dispatch!
+        route = find_route!
+        controller = Object.const_get(route.controller_name).new(event, {}, route.action_name)
+        response = controller.dispatch!
+
+        if !response.is_a?(Array) || response.size != 3
+          raise "Expected response to be an array of size 3. Are you rendering correctly?"
+        end
+
+        Response.new(response[0].to_i, response[2].read)
+      end
+    end
+  end
+end

data/lib/jets/spec_helpers/response.rb

@@ -0,0 +1,5 @@
+module Jets
+  module SpecHelpers
+    Response = Struct.new(:status, :body)
+  end
+end

data/lib/jets/stack.rb

@@ -0,0 +1,103 @@
+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}/",'') # 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

data/lib/jets/stack/builder.rb

@@ -0,0 +1,38 @@
+class Jets::Stack
+  class Builder
+    extend Memoist
+
+    def initialize(stack)
+      @stack = stack
+      @template = {} # will build this structure up
+    end
+
+    def template
+      build_section(:parameters)
+      build_section(:resources)
+      build_section(:outputs)
+      Jets::Camelizer.transform(@template)
+    end
+    memoize :template
+
+    def build_section(section)
+      elements = build_elements(section)
+      @template[section] = elements if elements
+    end
+
+    def build_elements(section)
+      # s is a "section element".  Examples:
+      #
+      #   Jets::Stack::Parameter
+      #   Jets::Stack::Resource
+      #   Jets::Stack::Output
+      #
+      section_elements = @stack.send(section)
+      return unless section_elements
+
+      section_elements.inject({}) do |template_section, s|
+        template_section.merge(s.template)
+      end
+    end
+  end
+end