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

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,109 @@
+# 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/controllers/params.rb

@@ -0,0 +1,8 @@
+module Jets::SpecHelpers::Controllers
+  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

data/lib/jets/spec_helpers/controllers/request.rb

@@ -0,0 +1,101 @@
+module Jets::SpecHelpers::Controllers
+  class Request
+    extend Memoist
+
+    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 = route.path.scan(%r{:([^/]+)}).flatten
+      expanded_path = escape_path(path)
+      path_parameters = {}
+
+      id_params.each do |id_param|
+        raise "missing param: :#{id_param}" unless path_params.include? id_param.to_sym
+
+        path_param_value = path_params[id_param.to_sym]
+        raise "Path param :#{id_param} value cannot be blank" if path_param_value.blank?
+
+        escaped_path_param_value = CGI.escape(path_param_value.to_s)
+        expanded_path.gsub!(":#{id_param}", escaped_path_param_value)
+        path_parameters.deep_merge!(id_param => escaped_path_param_value)
+      end
+
+      json['resource'] = escape_path(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'
+
+        if params.body_params.is_a? String
+          body = params.body_params
+          json['headers']['Content-Length'] ||= body.length.to_s
+        else
+          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
+        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.deep_dup
+      end
+
+      json
+    end
+
+    def path_params
+      params.path_params.reverse_merge(extract_parameters)
+    end
+    memoize :path_params
+
+    def extract_parameters
+      route.extract_parameters(normalized_path).symbolize_keys
+    end
+
+    def normalized_path
+      path = self.path
+      path = path[0..-2] if path.end_with? '/'
+      path = path[1..-1] if path.start_with? '/'
+      path
+    end
+
+    def route
+      Jets::Router::Finder.new(normalized_path, method).run
+    end
+    memoize :route
+
+    def dispatch!
+      klass = Object.const_get(route.controller_name)
+      controller = klass.new(event, {}, route.action_name)
+      response = controller.process! # response is API Gateway Hash
+
+      unless response['statusCode'] && response['body']
+        raise "Expected response to an API Gateway Hash Structure. Are you rendering correctly?"
+      end
+
+      Response.new(response) # converts APIGW hash to prettier object
+    end
+
+    private
+
+    def escape_path(path)
+      path.to_s.split('/').map { |s| s =~ /\A[:\*]/ ? s : CGI.escape(s) }.join('/')
+    end
+  end
+end

data/lib/jets/spec_helpers/controllers/response.rb

@@ -0,0 +1,10 @@
+module Jets::SpecHelpers::Controllers
+  class Response
+    attr_reader :status, :headers, :body
+    def initialize(response)
+      @status = response['statusCode'].to_i
+      @headers = response['headers']
+      @body = response['body']
+    end
+  end
+end

data/lib/jets/spec_helpers/controllers.rb

@@ -0,0 +1,47 @@
+module Jets::SpecHelpers
+  module Controllers
+    include Jets::Router::Helpers # must be at the top because response is overridden later
+
+    attr_reader :response
+    # Note: caching it like this instead of within the initialize results in the headers not being cached
+    # See: https://community.rubyonjets.com/t/is-jets-spechelpers-controllers-request-being-cached/244/2
+    def request
+      @request ||= Request.new(:get, '/', {}, Params.new)
+    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.query_params = params.delete(:query)
+
+      if request.method == :get
+        request.params.body_params = {}
+        request.params.query_params ||= params.delete(:params)
+        request.params.query_params ||= params
+      else
+        request.params.body_params = params.delete(:body)
+        request.params.body_params ||= params.delete(:params)
+        request.params.body_params ||= params
+      end
+
+      request.params.query_params ||= {}
+
+      request.params.path_params = params
+
+      @response = request.dispatch!
+    end
+  end
+end

data/lib/jets/spec_helpers/fixtures.rb

@@ -0,0 +1,11 @@
+module Jets::SpecHelpers
+  module Fixtures
+    def fixture_path(filename)
+      "#{Jets.root}/spec/fixtures/#{filename}"
+    end
+
+    def fixture_file(filename)
+      File.new(fixture_path(filename))
+    end
+  end
+end

data/lib/jets/spec_helpers.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require 'base64'
+
+module Jets
+  module SpecHelpers
+    include Fixtures
+    include Controllers
+  end
+end
+
+if File.exist?("#{Jets.root}/config/database.yml") && !ENV["SKIP_MIGRATION_CHECK"]
+  ActiveRecord::Tasks::DatabaseTasks.db_dir = "#{Jets.root}/db"
+  ActiveRecord::Migration.extend ActiveRecord::MigrationChecker
+  ActiveRecord::Migration.prepare_test_db
+end
+
+require "rspec"
+RSpec.configure do |c|
+  c.include Jets::SpecHelpers
+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

data/lib/jets/stack/definition.rb

@@ -0,0 +1,50 @@
+# Class that include Definition should implement:
+#
+#   template - method should use @definition to build a CloudFormation template section
+#
+class Jets::Stack
+  module Definition
+    extend ActiveSupport::Concern
+
+    # Example of usage that leads here:
+    #
+    #   Parameter.new(self, *definition).register
+    #
+    # Which  is defined in parameter/dsl.rb
+    #
+    # Example subclass: ExampleStack < Jets::Stack
+    def initialize(subclass, *definition)
+      @subclass = subclass.to_s # important to use to_s, dont want the object as keys in @definitions
+      @definition = definition.flatten
+    end
+
+    def register
+      self.class.register(@subclass, *@definition)
+    end
+
+    def camelize(attributes)
+      Jets::Camelizer.transform(attributes)
+    end
+
+    class_methods do
+      def register(subclass, *definition)
+        @definitions ||= {}
+        @definitions[subclass.to_s] ||= []
+        # Create instance of the CloudFormation section class and register it.  Examples:
+        #   Stack::Parameter.new(definition)
+        #   Stack::Resource.new(definition)
+        #   Stack::Output.new(definition)
+        @definitions[subclass.to_s] << new(subclass, definition)
+      end
+
+      def definitions(subclass)
+        @definitions ||= {}
+        @definitions[subclass.to_s]
+      end
+
+      def all_definitions
+        @definitions
+      end
+    end
+  end
+end

data/lib/jets/stack/depends/item.rb

@@ -0,0 +1,26 @@
+# Usage examples:
+#
+#   Jets::Stack::Depends::Item.new(:custom)
+#   Jets::Stack::Depends::Item.new(:custom, :alert)
+#   Jets::Stack::Depends::Item.new(:custom, class_prefix: true)
+#   Jets::Stack::Depends::Item.new(:custom, :alert, class_prefix: true)
+#
+# The Jets::Stack::Depends#params uses the options to determine if the class prefix should be added.
+#
+class Jets::Stack::Depends
+  class Item
+    attr_reader :stack, :options
+    def initialize(stack, options={})
+      @stack = stack # should be underscore format. IE: admin/posts_controller
+      @options = options
+    end
+
+    def logical_id
+      @stack.to_s.gsub('::','').gsub('/','_').camelize
+    end
+
+    def class_name
+      @stack.to_s.camelize
+    end
+  end
+end

data/lib/jets/stack/depends.rb

@@ -0,0 +1,34 @@
+class Jets::Stack
+  class Depends
+    def initialize(items)
+      @items = items # Jets::Stack::Depends::Item - has stack and options properties
+    end
+
+    def params
+      result = {}
+      @items.each do |item|
+        class_name = item.class_name
+        dependency_outputs(class_name).each do |output|
+          dependency_class = class_name.to_s.camelize
+          output_key = item.options[:class_prefix] ?
+            "#{dependency_class}#{output}" : # already camelized
+            output
+
+          output_value = "!GetAtt #{dependency_class}.Outputs.#{output}"
+          result[output_key] = output_value
+        end
+      end
+      result
+    end
+
+    # Returns CloudFormation template logical ids
+    def stack_list
+      @items.map(&:logical_id)
+    end
+
+  private
+    def dependency_outputs(class_name)
+      class_name.to_s.camelize.constantize.output_keys
+    end
+  end
+end

data/lib/jets/stack/function.rb

@@ -0,0 +1,69 @@
+class Jets::Stack
+  class Function
+    extend Memoist
+
+    attr_reader :template
+    def initialize(template)
+      @template = template
+    end
+
+    def meth
+      attributes = @template.values.first
+      handler = attributes['Properties']['Handler']
+      handler.split('.').last
+    end
+
+    def lang
+      return if internal?
+
+      if source_file
+        # Detect language from file extension
+        ext = File.extname(source_file).sub(/^\./,'').to_sym
+        lang_map[ext]
+      else
+        puts "WARN: Unable to find a source file for function. Looked at: #{search_expression}".color(:yellow)
+      end
+    end
+
+    def lang_map
+      {
+        rb: :ruby,
+        py: :python,
+        js: :node,
+      }
+    end
+
+    def source_file
+      Dir.glob(search_expression).first
+    end
+    memoize :source_file
+
+    def search_expression
+      base_search_expression.sub('handlers/shared/', "#{Jets.root}/app/shared/")
+    end
+
+    def internal_search_expression
+      internal = File.expand_path("../internal", File.dirname(__FILE__))
+      base_search_expression.sub('handlers/shared/', "#{internal}/app/shared/")
+    end
+
+    def base_search_expression
+      attributes = @template.values.first
+      handler = attributes['Properties']['Handler']
+      handler.split('.')[0..-2].join('.') + '.*' # search_expression
+      # Example: handlers/shared/functions/jets/s3_bucket_config.*
+    end
+
+    # Internal flag is mainly used to disable WARN messages
+    def internal?
+      !!Dir.glob(internal_search_expression).first
+    end
+
+    # Relative path
+    # app/shared/functions/kevin.py => handlers/shared/functions/kevin.py
+    def handler_dest
+      return unless source_file
+      source_file.sub(%r{.*/app/}, "handlers/")
+    end
+  end
+end

data/lib/jets/stack/main/dsl/base.rb

@@ -0,0 +1,63 @@
+module Jets::Stack::Main::Dsl
+  module Base
+    def ref(value)
+      "!Ref #{value.to_s.camelize}"
+    end
+
+    # Examples:
+    #   get_attr("logical_id.attribute")
+    #   get_attr("logical_id", "attribute")
+    #   get_attr(["logical_id", "attribute"])
+    def get_att(*item)
+      item = item.flatten
+      options = item.last.is_a?(Hash) ? item.pop : {}
+
+      # list is an Array
+      list = if item.size == 1
+                item.first.split('.')
+              else
+                item
+              end
+      list.map! { |s| s.to_s.camelize } unless options[:autoformat] == false
+      { "Fn::GetAtt" => list }
+    end
+
+    def logical_id(value)
+      value.to_s.camelize
+    end
+
+    def depends_on(*stacks)
+      if stacks == []
+        @depends_on
+      else
+        @depends_on ||= []
+        @depends_on += stacks
+      end
+    end
+
+    # Due to `if Jets::Stack.has_resources?` check early on in the bootstraping process
+    # The code has not been built at that point. So we use a placeholder and will replace
+    # the placeholder as part of the cfn template build process after the code has been built
+    # and the code_s3_key with md5 is available.
+    def code_s3_key
+      "code_s3_key_placeholder"
+    end
+
+    # resource(:hello,
+    #   function_name: "hello",
+    #   code: {
+    #     s3_bucket: "!Ref S3Bucket",
+    #     s3_key: code_s3_key
+    #   },
+    #   description: "Hello world",
+    #   handler: handler_function("hello.lambda_handler"),
+    #   memory_size: 128,
+    #   role: "!Ref IamRole",
+    #   runtime: "python3.6",
+    #   timeout: 20,
+    # )
+    def handler(name)
+      "handlers/shared/functions/#{name}" # generated handler
+    end
+  end
+end

data/lib/jets/stack/main/dsl/cloudwatch.rb

@@ -0,0 +1,19 @@
+module Jets::Stack::Main::Dsl
+  module Cloudwatch
+    def cloudwatch_alarm(id, hash={})
+      if hash.key?(:depends_on)
+        attributes = hash # leave structure alone and add type only
+        attributes[:type] = "AWS::CloudWatch::Alarm"
+      else
+        # the attributes are properties
+        properties = hash
+        attributes = {
+          type: "AWS::CloudWatch::Alarm",
+          properties: properties,
+        }
+      end
+      resource(id, attributes)
+      output(id)
+    end
+  end
+end

data/lib/jets/stack/main/dsl/iam.rb

@@ -0,0 +1,8 @@
+module Jets::Stack::Main::Dsl
+  module Iam
+    def iam_role(id, props={})
+      resource(id, "AWS::IAM::Role", props)
+      output(id) # IAM Arn
+    end
+  end
+end

data/lib/jets/stack/main/dsl/kinesis.rb

@@ -0,0 +1,15 @@
+module Jets::Stack::Main::Dsl
+  module Kinesis
+    def kinesis_stream(id, props={})
+      defaults = {
+        name: id,
+        shard_count: 1
+      }
+
+      props = defaults.merge(props)
+
+      resource(id, "AWS::Kinesis::Stream", props)
+      output(id)
+    end
+  end
+end