jets 5.0.14 → 6.0.0.beta1

data/lib/jets/cfn/builder/nested.rb

@@ -1,130 +0,0 @@
-# Note: compose implemented by the classes that include this
-class Jets::Cfn::Builder
-  class Nested
-    include Interface
-
-    # The app_class is can be a controller, job or anonymous function class.
-    # IE: PostsController, HardJob
-    def initialize(app_class)
-      @app_class = app_class
-      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
-    end
-
-    # interface method
-    def template_path
-      Jets::Names.app_template_path(@app_class)
-    end
-
-    def add_common_parameters
-      common_parameters = Jets::Cfn::Params::Common.parameters
-      common_parameters.each do |k,_|
-        add_parameter(k)
-      end
-
-      depends_on_params.each do |output_key, _|
-        add_parameter(output_key)
-      end
-    end
-
-    def depends_on_params
-      return {} if Jets.one_lambda_for_all_controllers? && @app_class.to_s.ends_with?("Controller")
-      return {} if @app_class.is_a?(Hash)
-      return {} unless @app_class.depends_on
-      depends = Jets::Stack::Depends.new(@app_class.depends_on)
-      depends.params
-    end
-
-    def add_functions
-      validate_function_names!
-      if Jets.one_lambda_per_controller? && @app_class.to_s.ends_with?("Controller")
-        one_lambda_per_controller
-      else
-        one_lambda_per_method
-      end
-    end
-
-    def one_lambda_per_method
-      add_class_iam_policy
-      @app_class.definitions.each do |definition|
-        add_function(definition)
-        add_function_iam_policy(definition)
-      end
-    end
-
-    def one_lambda_per_controller
-      add_class_iam_policy
-      definition = Jets::Lambda::Definition.new(@app_class, "lambda_handler",
-        lang: :ruby,
-      )
-      add_function(definition)
-      unless Jets::Router.no_routes?
-        controller = Jets::Cfn::Resource::Lambda::Function::Controller.new(definition)
-        add_resource(controller.permission)
-      end
-    end
-
-    def add_function(definition)
-      resource = Jets::Cfn::Resource::Lambda::Function.new(definition)
-      add_resource(resource)
-      # apigw lambda permission is also added to the controller template next to the function
-      route = Jets::Router.find_by_definition(definition)
-      if route
-        # Creates a permission more directly to set principal apigateway.amazonaws.com
-        method = Jets::Cfn::Resource::ApiGateway::Method.new(route)
-        add_resource(method.permission)
-      end
-    end
-
-    # routes scoped to this controller template.
-    def scoped_routes
-      @routes ||= Jets::Router.routes.select do |route|
-        route.controller_name == @app_class.to_s
-      end
-    end
-
-    def add_class_iam_policy
-      return unless build_class_iam_policy?
-
-      resource = Jets::Cfn::Resource::Iam::ClassRole.new(@app_class)
-      add_resource(resource)
-    end
-
-    def build_class_iam_policy?
-      should_build = false
-      klass = @app_class
-      while klass && klass != Object
-        if klass&.build_class_iam?
-          should_build = true
-          break
-        end
-        klass = klass.superclass
-      end
-      should_build
-    end
-
-    def add_function_iam_policy(definition)
-      return unless definition.build_function_iam?
-
-      resource = Jets::Cfn::Resource::Iam::FunctionRole.new(definition)
-      add_resource(resource)
-    end
-
-    def validate_function_names!
-      invalids = @app_class.definitions.reject do |definition|
-        definition.meth.to_s =~ /^[a-zA-Z][a-zA-Z0-9_]/
-      end
-      return if invalids.empty?
-      list = invalids.map do |definition|
-        "    #{definition.class_name}##{definition.meth}" # IE: PostsController#index
-      end.join("\n")
-      puts "ERROR: Detected invalid AWS Lambda function names".color(:red)
-      puts <<~EOL
-        Lambda function names must start with a letter and can only contain letters, numbers, and underscores.
-        Invalid function names:
-
-        #{list}
-      EOL
-      exit 1
-    end
-  end
-end

data/lib/jets/cfn/builder/one_controller.rb

@@ -1,53 +0,0 @@
-class Jets::Cfn::Builder
-  class OneController < Nested
-    def build?
-      true
-    end
-
-    # interface method
-    def compose
-      add_one_function
-      add_common_parameters
-      add_api_gateway_parameters
-      add_outputs
-    end
-
-    # interface method
-    def template_path
-      Jets::Names.one_controller_template_path
-    end
-
-    def add_one_function
-      resource = Jets::Cfn::Resource::One::Function.new
-      add_resource(resource)
-      add_application_controller_iam_policy
-      unless Jets::Router.no_routes?
-        permission = Jets::Cfn::Resource::One::Permission.new
-        add_resource(permission)
-      end
-    end
-
-    def add_application_controller_iam_policy
-      klass = ApplicationController
-      return unless klass.build_class_iam?
-      resource = Jets::Cfn::Resource::Iam::ClassRole.new(klass)
-      add_resource(resource)
-    end
-
-    def add_outputs
-      outputs = {}
-      @template[:Resources].each do |logical_id, resource|
-        next unless resource[:Type] == "AWS::Lambda::Function"
-        outputs.merge!(logical_id => {
-          Value: "!GetAtt #{logical_id}.Arn"
-        })
-      end
-      @template[:Outputs] = outputs
-    end
-
-    def add_api_gateway_parameters
-      return if Jets::Router.no_routes?
-      add_parameter(:RestApi)
-    end
-  end
-end

data/lib/jets/cfn/builder/parent/stagger.rb

@@ -1,34 +0,0 @@
-class Jets::Cfn::Builder::Parent
-  module Stagger
-    def add_stagger(resource)
-      batch_size = stagger_batch_size # shorter convenience variable
-      return if !stagger_enabled || batch_size.nil? || batch_size == 0
-
-      # initialize all here to keep logic together
-      @previous_stacks ||= []
-      @added_count ||= 0
-
-      if @previous_stacks.size >= batch_size
-        at_boundary = @added_count % batch_size == 0
-        if at_boundary
-          @left = @added_count - batch_size
-          @right = @left + batch_size - 1
-        end
-        previous_stack_batch = @previous_stacks[@left..@right]
-        resource.add_stagger_depends_on(previous_stack_batch)
-      end
-
-      @added_count += 1
-      @previous_stacks << resource
-    end
-
-    def stagger_batch_size
-      Jets.config.deploy.stagger.batch_size
-    end
-
-    # for spec-ing
-    def stagger_enabled
-      Jets.config.deploy.stagger.enabled
-    end
-  end
-end

data/lib/jets/cfn/builder/parent.rb

@@ -1,149 +0,0 @@
-class Jets::Cfn::Builder
-  class Parent
-    include Interface
-    include Jets::AwsServices
-    include Stagger
-
-    def initialize(options={})
-      @options = options
-      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
-    end
-
-    # interface method
-    def compose
-      build_minimal_resources
-      build_child_resources
-    end
-
-    # interface method
-    def template_path
-      Jets::Names.parent_template_path
-    end
-
-    def build_minimal_resources
-      add_description("Jets: #{Jets.version} Code: #{Util::Source.version}")
-
-      # Initial s3 bucket, used to store code zipfile and templates Jets generates
-      #
-      # AWS changed the default behavior of s3 buckets to block public access
-      #   https://aws.amazon.com/blogs/aws/amazon-s3-block-public-access-another-layer-of-protection-for-your-accounts-and-buckets/
-      #   https://github.com/aws-amplify/amplify-cli/issues/12503
-      #
-      # Jets uploads assets to s3 bucket with acl: "public-read" here
-      #   https://github.com/boltops-tools/jets/blob/c5858ec2706a606665a92c3ada3f16ae4c753372/lib/jets/cfn/upload.rb#L97
-      #
-      # Use minimal s3 bucket policy to allow public read access to assets.
-      # Leave the other options as comments to help document the default behavior.
-      resource = Jets::Cfn::Resource::S3::JetsBucket.new
-      add_resource(resource)
-      add_outputs(resource.outputs)
-
-      return unless full?
-      # Add application-wide IAM policy from Jets.config.iam_role
-      resource = Jets::Cfn::Resource::Iam::ApplicationRole.new
-      add_resource(resource)
-      add_outputs(resource.outputs)
-
-      return unless Jets.gem_layer?
-      resource = Jets::Cfn::Resource::Lambda::GemLayer.new
-      add_resource(resource)
-      add_outputs(resource.outputs)
-    end
-
-    def build_child_resources
-      return unless full?
-
-      add_one_lambda_controller if Jets.one_lambda_for_all_controllers? && Jets.config.mode != "job"
-      for_each_path(:app) do |path|
-        add_app_class_stack(path)
-      end
-      for_each_path(:shared) do |path|
-        add_shared_resources(path)
-      end
-
-      return if Jets::Router.no_routes?
-      for_each_path(:authorizers) do |path|
-        add_authorizer_resources(path)
-      end
-      add_api_gateway
-      add_api_resources
-      add_api_methods
-      add_api_deployment
-      add_api_mapping
-    end
-
-    def full?
-      @options[:stack_type] == :full
-    end
-
-    def add_one_lambda_controller
-      resource = Jets::Cfn::Resource::Nested::OneController.new(@options)
-      add_child_resources(resource)
-    end
-
-      # Example paths:
-    #    #{Jets.build_root}/templates/shared-resources.yml
-    #    #{Jets.build_root}/templates/app-comments_controller.yml
-    #    #{Jets.build_root}/templates/authorizers-main_authorizer.yml
-    def for_each_path(type)
-      expression = "#{Jets::Names.templates_folder}/#{type}-*"
-      Dir.glob(expression).each do |path|
-        next unless File.file?(path)
-        yield(path)
-      end
-    end
-
-    def add_app_class_stack(path)
-      resource = Jets::Cfn::Resource::Nested::AppClass.new(@options.merge(path: path))
-      add_stagger(resource)
-      add_child_resources(resource)
-    end
-
-    def add_authorizer_resources(path)
-      resource = Jets::Cfn::Resource::Nested::Authorizer.new(@options.merge(path: path))
-      add_child_resources(resource)
-    end
-
-    def add_shared_resources(path)
-      resource = Jets::Cfn::Resource::Nested::Shared.new(@options.merge(path: path))
-      add_child_resources(resource) if resource.resources?
-    end
-
-    def add_api_gateway
-      resource = Jets::Cfn::Resource::Nested::Api::Gateway.new(@options)
-      add_child_resources(resource)
-    end
-
-    def add_api_resources
-      pages = Api::Pages::Resources.pages
-      pages.each do |page|
-        resource = Jets::Cfn::Resource::Nested::Api::Resources.new(@options.merge(page_number: page.number))
-        add_child_resources(resource)
-      end
-    end
-
-    def add_api_methods
-      pages = Api::Pages::Methods.pages
-      pages.each do |page|
-        resource = Jets::Cfn::Resource::Nested::Api::Methods.new(@options.merge(page_number: page.number))
-        add_child_resources(resource)
-      end
-    end
-
-    def add_api_deployment
-      resource = Jets::Cfn::Resource::Nested::Api::Deployment.new(@options)
-      add_child_resources(resource)
-    end
-
-    def add_api_mapping
-      return unless Jets.custom_domain?
-      resource = Jets::Cfn::Resource::Nested::Api::Mapping.new(@options)
-      add_child_resources(resource)
-    end
-
-    def add_child_resources(resource)
-      add_resource(resource)
-      add_outputs(resource.outputs)
-    end
-  end
-end

data/lib/jets/cfn/builder/rule.rb

@@ -1,20 +0,0 @@
-class Jets::Cfn::Builder
-  class Rule < Nested
-    # interface method
-    def compose
-      add_common_parameters
-      add_functions
-      add_resources
-      add_managed_rules
-    end
-
-    # Handle config_rules associated with aws managed rules.
-    # List of AWS Config Managed Rules: https://amzn.to/2BOt9KN
-    def add_managed_rules
-      @app_class.managed_rules.each do |rule|
-        resource = Jets::Cfn::Resource.new(rule[:definition], rule[:replacements])
-        add_resource(resource)
-      end
-    end
-  end
-end

data/lib/jets/cfn/builder/shared.rb

@@ -1,15 +0,0 @@
-class Jets::Cfn::Builder
-  class Shared < Nested
-    # interface method
-    def compose
-      stack = @app_class.new # @app_class is subclass. IE: Alarm < Jets::Stack
-      builder = Jets::Stack::Builder.new(stack)
-      @template = builder.template # overwrite entire @template
-    end
-
-    # interface method
-    def template_path
-      Jets::Names.shared_template_path(@app_class)
-    end
-  end
-end

data/lib/jets/cfn/builder/util/source.rb

@@ -1,21 +0,0 @@
-module Jets::Cfn::Builder::Util
-  class Source
-    class << self
-      def version
-        return '' unless git_installed?
-        sha = sh "git rev-parse HEAD 2>/dev/null"
-        return '' if sha == ''  # if its not a git repo, it'll be an empty string
-        sha[0..7]
-      end
-
-    private
-      def git_installed?
-        system("type git > /dev/null 2>&1")
-      end
-
-      def sh(command)
-        `#{command}`.strip
-      end
-    end
-  end
-end

data/lib/jets/cfn/builder.rb

@@ -1,230 +0,0 @@
-module Jets::Cfn
-  class Builder
-    extend Memoist
-    include Jets::AwsServices
-
-    def initialize(options)
-      @options = options
-    end
-
-    def build
-      puts "Building CloudFormation templates"
-      clean_templates
-      build_minimal_parent_template
-      if @options[:stack_type] == :full
-        build_all_templates
-        build_full_parent_template # must be called at the end
-      end
-      Jets::Router::State.save_apigw_state if ENV['JETS_API_STATE_DEBUG']
-      puts "Built CloudFormation templates at #{Jets.build_root}/templates"
-    end
-
-    def build_minimal_parent_template
-      Parent.new(@options.merge(stack_type: :minimal)).build
-    end
-
-    def build_all_templates
-      # CloudFormation templates
-      # 1. Shared and authorizer templates - child templates needs them
-      build_api_gateway_templates unless Jets::Router.no_routes?
-      build_authorizer_templates # controllers can use these
-      # 2. Child templates - parent template needs them
-      build_one_lambda_for_all_controllers
-      build_app_child_templates
-      # 3. Child templates - parent template needs them
-      build_shared_resources_templates
-    end
-
-    def build_full_parent_template
-      Parent.new(@options.merge(stack_type: :full)).build
-    end
-
-    def build_api_gateway_templates
-      Api::Gateway.new(@options).build
-      Api::Resources.build_pages(@options)
-      Api::Methods.build_pages(@options)
-      Api::Deployment.new(@options).build
-      Api::Mapping.new(@options).build
-    end
-
-    def build_authorizer_templates
-      authorizer_files.each do |path|
-        Authorizer.new(path).build
-      end
-    end
-
-    def build_one_lambda_for_all_controllers
-      return if Jets.config.mode == "job"
-      return unless Jets.one_lambda_for_all_controllers?
-      OneController.new(@options).build
-    end
-
-    def build_app_child_templates
-      app_files.each do |path|
-        build_child_template(path)
-      end
-    end
-
-    def build_shared_resources_templates
-      Jets::Stack.subclasses.each do |subclass|
-        Shared.new(subclass).build
-      end
-    end
-
-    # path: app/controllers/comments_controller.rb
-    # path: app/jobs/easy_job.rb
-    def build_child_template(path)
-      return if authorizer?(path) # AuthorizerBuilder is built earlier
-
-      md = path.match(%r{app/(.*?)/}) # extract: controller, job or function
-      app_class = md[1].classify
-
-      if app_class == "Controller" && Jets.one_lambda_for_all_controllers? # app/controllers
-        return
-      end
-
-      builder_class = "Jets::Cfn::Builder::#{app_class}".constantize
-
-      app_class = Jets::Klass.from_path(path)
-      if !Jets.gem_layer? && app_class == Jets::PreheatJob
-        return # No prewarm when there's only poly functions and no gem layer
-      end
-
-      # Builder class fully qualified name:
-      #   Controller => Jets::Cfn::Builder::Controller
-      # Examples:
-      #   Controller.new(PostsController).build
-      #   Job.new(EasyJob).build
-      #   Rule.new(CheckRule).build
-      #   Function.new(Hello).build
-      #   Function.new(HelloFunction).build
-      builder_class.new(app_class).build
-    end
-
-    def authorizer?(path)
-      path.include?("app/authorizers")
-    end
-
-    def clean_templates
-      FileUtils.rm_rf("#{Jets.build_root}/templates")
-    end
-
-    def app_files
-      self.class.app_files
-    end
-
-    def shared_files
-      self.class.shared_files
-    end
-
-    def authorizer_files
-      self.class.authorizer_files
-    end
-
-    class << self
-      # Crucial that the Dir.pwd is in the tmp_code because for because Jets.boot set ups autoload_paths and this is
-      # how project classes are loaded.
-      # TODO: rework code so that Dir.pwd does not have to be in tmp_code for build to work.
-      #
-      # app_files used to determine what CloudFormation templates to build.
-      # app_files also used to determine what handlers to build.
-      def app_files
-        paths = []
-        expression = "#{Jets.root}/app/**/**/*.rb"
-        Dir.glob(expression).each do |path|
-          next unless app_file?(path)
-          relative_path = path.sub("#{Jets.root}/", '') # rid of the Jets.root at beginning
-          paths << relative_path
-        end
-
-        if Jets.config.prewarm.enable
-          internal = File.expand_path("../internal", __dir__)
-          paths << "#{internal}/app/jobs/jets/preheat_job.rb"
-        end
-
-        paths
-      end
-
-      APP_FOLDERS = %w[authorizers controllers functions jobs rules]
-      def app_file?(path)
-        return false unless File.extname(path) == ".rb"
-        return false unless File.file?(path) unless Jets.env.test?
-        return false if application_abstract_classes.detect { |p| path.include?(p) }
-        return false if concerns?(path)
-        return true if APP_FOLDERS.detect { |p| path.include?("app/#{p}") }
-        false
-      end
-
-      # Do not define lamda functions for abstract application parent classes. Examples:
-      #
-      #   application_controller.rb
-      #   application_job.rb
-      #   application_authorizer.rb
-      def application_abstract_classes
-        APP_FOLDERS.map { |a| "application_#{a.singularize}.rb" }
-      end
-
-      def concerns?(path)
-        path =~ %r{app/\w+/concerns/}
-      end
-
-      def authorizer_files
-        app_files.select { |p| p.include?("app/authorizers") }
-      end
-
-      def shared_files
-        find_app_paths("shared/resources")
-      end
-
-      def find_app_paths(app_path)
-        paths = []
-        expression = "#{Jets.root}/app/#{app_path}/**/*.rb"
-        Dir.glob(expression).each do |path|
-          return false unless File.file?(path)
-
-          relative_path = path.sub("#{Jets.root}/", '')
-          # Rids of the Jets.root at beginning
-          paths << relative_path
-        end
-        paths
-      end
-
-      # Finds out of the app has polymorphic functions only and zero ruby functions.
-      # In this case, we can skip a lot of the ruby related building and speed up the
-      # deploy process.
-      def poly_only?
-        !app_has_ruby? && !shared_has_ruby?
-      end
-
-      def app_has_ruby?
-        has_ruby = app_files.detect do |path|
-          app_class = Jets::Klass.from_path(path)  # IE: PostsController, Jets::PublicController
-          langs = app_class.definitions.map(&:lang)
-          langs.include?(:ruby) && app_class != Jets::PreheatJob
-        end
-        !!has_ruby
-      end
-
-      def shared_has_ruby?
-        has_ruby = false
-        Jets::Stack.subclasses.each do |klass|
-          klass.functions.each do |fun|
-            if fun.lang == :ruby
-              has_ruby = true
-              break
-            end
-          end
-        end
-        has_ruby
-      end
-
-      def router_has?(controller)
-        Jets::Router.has_controller?(controller)
-      end
-
-      def tmp_code(full_build_path=false)
-        full_build_path ? "#{Jets.build_root}/stage/code" : "stage/code"
-      end
-    end
-  end
-end