jets_bb_fork 0.0.4

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/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.
+module 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,54 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Jets
+  module SpecHelpers
+    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.query_params = params.delete(:query)
+      request.params.query_params ||= params if request.method == :get
+      request.params.query_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
+
+require "rspec"
+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, :query_params
+      def initialize(path_params={}, body_params={}, query_params={})
+        @path_params, @body_params, @query_params = path_params, body_params, query_params
+      end
+    end
+  end
+end

data/lib/jets/spec_helpers/request.rb

@@ -0,0 +1,78 @@
+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'] = 'application/x-www-form-urlencoded'
+          body = Rack::Multipart.build_multipart(params.body_params)
+
+          if body
+            json['headers']['Content-Length'] ||= body.length.to_s
+            json['headers']['Content-Type'] = "multipart/form-data; boundary=#{Rack::Multipart::MULTIPART_BOUNDARY}"
+          else
+            body = Rack::Utils.build_nested_query(params.body_params)
+          end
+
+          json['body'] = Base64.encode64(body)
+          json['isBase64Encoded'] = true
+        end
+
+        params.query_params.each do |key, value|
+          json['queryStringParameters'] ||= {}
+          json['queryStringParameters'][key.to_s] = value.to_s
+        end
+
+        json
+      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,88 @@
+module Jets
+  class Stack
+    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
+
+      # klass = Jets::Stack.new_class("Bucket3")
+      def new_class(class_name, &block)
+        # https://stackoverflow.com/questions/4113479/dynamic-class-definition-with-a-class-name
+        # Defining the constant this way gets around: SyntaxError: dynamic constant assignment error
+        klass = Class.new(Jets::Stack) # First klass is an anonymous class. IE: class.name is nil
+        klass = Object.const_set(class_name, klass) # now klass is a named class
+        Jets::Stack.subclasses << klass # mimic inherited hook because
+
+        # Must run class_eval after adding to subclasses in order for the resource declarations in the
+        # so that the resources get registered to the right subclass.
+        klass.class_eval(&block)
+        klass # return klass
+      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
+
+      # Eager loading the app/shared resources to ensure shared resources have been registered.
+      # Not being used anymore but keeping around just in case for now.
+      def eager_load_shared_resources!
+        Dir.glob("#{Jets.root}/app/shared/**").each do |path|
+          next if path.include?("app/shared/functions")
+          Jets::Autoloaders.main.preload(path)
+        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,43 @@
+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)
+      return unless elements
+
+      if section == :parameters
+        elements["GemLayer"] = {"Type"=>"String"} unless Jets.poly_only?
+      end
+      @template[section] = 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