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

data/lib/jets/cfn/builders/api_gateway_builder.rb

@@ -0,0 +1,123 @@
+module Jets::Cfn::Builders
+  class ApiGatewayBuilder
+    extend Memoist
+    include Interface
+    include Jets::AwsServices
+
+    def initialize(options={})
+      @options = options
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+
+    # compose is an interface method
+    def compose
+      add_gateway_routes # "child template": build before add_gateway_rest_api. RestApi logical id and change detection is dependent on it.
+      add_gateway_rest_api # changes parent template
+      add_custom_domain    # changes parent template
+    end
+
+    # template_path is an interface method
+    def template_path
+      Jets::Naming.api_gateway_template_path
+    end
+
+    # do not bother writing a template if routes are empty
+    def write
+      super unless Jets::Router.routes.empty?
+    end
+
+    # If the are routes in config/routes.rb add Gateway API in parent stack
+    def add_gateway_rest_api
+      rest_api = Jets::Resource::ApiGateway::RestApi.new
+      add_resource(rest_api)
+      add_outputs(rest_api.outputs)
+
+      deployment = Jets::Resource::ApiGateway::Deployment.new
+      outputs = deployment.outputs(true)
+      add_output("RestApiUrl", Value: outputs["RestApiUrl"])
+    end
+
+    def add_custom_domain
+      return unless Jets.custom_domain?
+      add_domain_name
+      add_route53_dns if Jets.config.domain.route53
+    end
+
+    def add_domain_name
+      add_outputs(create_domain_name)
+    end
+
+    def add_route53_dns
+      dns = Jets::Resource::Route53::RecordSet.new
+      if !existing_domain_name?(dns.domain_name) or existing_dns_record_on_stack? 
+        add_resource(dns)
+        add_outputs(dns.outputs)
+      end
+    end
+
+    def create_domain_name()
+      resource = Jets::Resource::ApiGateway::DomainName.new
+      
+      return {
+        "DomainName" => resource.domain_name
+      } if (existing_domain_name?(resource) and !existing_domain_name_on_stack?)
+      
+      add_resource(resource)
+      return resource.outputs
+    end
+
+    def existing_domain_name?(resource)
+      apigateway.get_domain_name({
+        domain_name: resource.domain_name
+      })
+      return true
+    rescue
+      return false
+    end
+    memoize :existing_domain_name?
+
+    def existing_domain_name_on_stack?
+      cfn.describe_stack_resource({
+        stack_name: api_gateway_physical_resource_id,
+        logical_resource_id: "DomainName"
+      })
+      return true
+    rescue
+      return false
+    end
+
+    def existing_dns_record_on_stack?
+      cfn.describe_stack_resource({
+        stack_name: api_gateway_physical_resource_id,
+        logical_resource_id: "DnsRecord"
+      })
+      return true
+    rescue
+      return false
+    end
+
+    def api_gateway_physical_resource_id
+      cfn.describe_stack_resource({
+        stack_name: Jets::Naming.parent_stack_name,
+        logical_resource_id: "ApiGateway"
+      })
+      .stack_resource_detail
+      .physical_resource_id
+    rescue
+      return nil
+    end
+    memoize :api_gateway_physical_resource_id
+
+    # Adds route related Resources and Outputs
+    # Delegates to ApiResourcesBuilder
+    PAGE_LIMIT = Integer(ENV['JETS_AWS_OUTPUTS_LIMIT'] || 200) # Allow override for testing
+    def add_gateway_routes
+      # Reject homepage. Otherwise we have 200 - 1 resources on the first page.
+      # There's a next call in ApiResources.add_gateway_resources to skip the homepage.
+      all_paths = Jets::Router.all_paths.reject { |p| p == '' }
+      all_paths.each_slice(PAGE_LIMIT).each_with_index do |paths, i|
+        ApiResourcesBuilder.new(@options, paths, i+1).build
+      end
+    end
+  end
+end

data/lib/jets/cfn/builders/api_resources_builder.rb

@@ -0,0 +1,44 @@
+module Jets::Cfn::Builders
+  class ApiResourcesBuilder
+    include Interface
+    include Jets::AwsServices
+
+    def initialize(options={}, paths=[], page)
+      @options, @paths, @page = options, paths, page
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+
+    # compose is an interface method
+    def compose
+      add_rest_api_parameter
+      add_gateway_routes
+    end
+
+    # template_path is an interface method
+    def template_path
+      Jets::Naming.api_resources_template_path(@page)
+    end
+
+    def add_rest_api_parameter
+      add_parameter("RestApi", Description: "RestApi")
+    end
+
+    def add_gateway_routes
+      @paths.each do |path|
+        homepage = path == ''
+        next if homepage # handled by RootResourceId output already
+
+        resource = Jets::Resource::ApiGateway::Resource.new(path)
+        add_resource(resource)
+        add_outputs(resource.outputs)
+
+        parent_path = resource.parent_path_parameter
+        add_parameter(parent_path) unless part_of_template?(parent_path)
+      end
+    end
+
+    def part_of_template?(parent_path)
+      @template["Resources"].key?(parent_path)
+    end
+  end
+end

data/lib/jets/cfn/builders/authorizer_builder.rb

@@ -0,0 +1,67 @@
+# Implements:
+#
+#   compose
+#   template_path
+#
+module Jets::Cfn::Builders
+  class AuthorizerBuilder < BaseChildBuilder
+    include Interface
+    include Jets::AwsServices
+
+    def initialize(path)
+      @path = path # IE: app/authorizers/main_authorizer.rb
+      @app_class = Jets::Klass.from_path(path)
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+
+    def compose
+      add_common_parameters
+      add_api_gateway_parameters
+      add_functions
+      add_resources
+      add_outputs
+      # These dont have lambda functions associated with them
+      add_cognito_authorizers
+      add_cognito_outputs
+    end
+
+    def add_cognito_authorizers
+      @app_class.cognito_authorizers.each do |authorizer|
+        resource = Jets::Resource.new(authorizer[:definition], authorizer[:replacements])
+        add_resource(resource)
+      end
+    end
+
+    def add_outputs
+      # IE: @app_class = MainAuthorizer
+      # The associated resource is the Jets::Resource::ApiGateway::Authorizer definition built during evaluation
+      # of the user defined Authorizer class. We'll use it to compute the logical id.
+      @app_class.tasks.each do |task|
+        authorizer = task.associated_resources.first
+        next unless authorizer
+
+        resource = Jets::Resource.new(authorizer.definition, task.replacements)
+        logical_id = resource.logical_id
+        add_output(logical_id, value: "!Ref #{logical_id}")
+      end
+    end
+
+    def add_cognito_outputs
+      @app_class.cognito_authorizers.each do |authorizer|
+        resource = Jets::Resource.new(authorizer[:definition], authorizer[:replacements])
+        logical_id = resource.logical_id
+        add_output(logical_id, value: "!Ref #{logical_id}")
+      end
+    end
+
+    def add_api_gateway_parameters
+      return if Jets::Router.routes.empty?
+
+      add_parameter("RestApi", Description: "RestApi")
+    end
+
+    def template_path
+      Jets::Naming.authorizer_template_path(@path)
+    end
+  end
+end

data/lib/jets/cfn/builders/base_child_builder.rb

@@ -0,0 +1,69 @@
+# Implements:
+#
+#   * template_path
+#
+# FYI
+#
+#   * compose implemented by the classes that include this
+module Jets::Cfn::Builders
+  class BaseChildBuilder
+    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
+
+    # template_path is an interface method for Interface module
+    def template_path
+      Jets::Naming.app_template_path(@app_class)
+    end
+
+    def add_common_parameters
+      common_parameters = Jets::Resource::ChildStack::CommonParameters.common_parameters
+      common_parameters.each do |k,_|
+        add_parameter(k, Description: k.to_s)
+      end
+
+      depends_on_params.each do |output_key, output_value|
+        desc = output_value.gsub("!GetAtt ", "") # desc doesnt allow !GetAtt
+        add_parameter(output_key, Description: desc)
+      end
+    end
+
+    def depends_on_params
+      return {} unless @app_class.depends_on
+      depends = Jets::Stack::Depends.new(@app_class.depends_on)
+      depends.params
+    end
+
+    def add_functions
+      add_class_iam_policy
+      @app_class.tasks.each do |task|
+        add_function(task)
+        add_function_iam_policy(task)
+      end
+    end
+
+    def add_function(task)
+      resource = Jets::Resource::Lambda::Function.new(task)
+      add_resource(resource)
+    end
+
+    def add_class_iam_policy
+      return unless @app_class.build_class_iam?
+
+      resource = Jets::Resource::Iam::ClassRole.new(@app_class)
+      add_resource(resource)
+    end
+
+    def add_function_iam_policy(task)
+      return unless task.build_function_iam?
+
+      resource = Jets::Resource::Iam::FunctionRole.new(task)
+      add_resource(resource)
+    end
+  end
+end

data/lib/jets/cfn/builders/controller_builder.rb

@@ -0,0 +1,50 @@
+# Implements:
+#
+#   compose
+#   template_path
+#
+module Jets::Cfn::Builders
+  class ControllerBuilder < BaseChildBuilder
+    # compose is an interface method for Interface module
+    def compose
+      add_common_parameters
+      add_api_gateway_parameters
+      add_functions
+      add_routes
+      add_resources
+    end
+
+    def add_api_gateway_parameters
+      return if Jets::Router.routes.empty?
+
+      add_parameter("RestApi", Description: "RestApi")
+      scoped_routes.each do |route|
+        resource = Jets::Resource::ApiGateway::Resource.new(route.path)
+        add_parameter(resource.logical_id, description: resource.desc)
+        if route.authorizer
+          add_parameter(route.authorizer_id, description: route.authorizer_metadata)
+        end
+      end
+
+      if @app_class.authorizer
+        add_parameter(@app_class.authorizer_id, description: @app_class.authorizer_metadata)
+      end
+    end
+
+    def add_routes
+      scoped_routes.each_with_index do |route, i|
+        method = Jets::Resource::ApiGateway::Method.new(route)
+        add_resource(method)
+        add_resource(method.permission)
+        add_resource(method.cors) if Jets.config.cors
+      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
+  end
+end

data/lib/jets/cfn/builders/function_builder.rb

@@ -0,0 +1,14 @@
+# Implements:
+#
+#   compose
+#   template_path
+#
+module Jets::Cfn::Builders
+  class FunctionBuilder < BaseChildBuilder
+    # compose is an interface method for Interface module
+    def compose
+      add_common_parameters
+      add_functions
+    end
+  end
+end

data/lib/jets/cfn/builders/interface.rb

@@ -0,0 +1,133 @@
+# The class including this module should implement these methods:
+#
+#   * compose
+#   * template_path
+module Jets::Cfn::Builders
+  module Interface
+    extend Memoist
+
+    def build(parent=false)
+      # Do not bother building or writing the template unless there are functions defined
+      return if @app_class && !@app_class.build?
+
+      if @options.nil? || @options[:templates] || @options[:stack_type] != :minimal || parent
+        compose # must be implemented by subclass
+      end
+      write
+    end
+
+    def write
+      FileUtils.mkdir_p(File.dirname(template_path))
+      IO.write(template_path, text)
+    end
+
+    def template
+      # need the to_hash or the YAML dump has
+      #  !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+      @template.to_hash
+    end
+
+    def text
+      text = YAML.dump(template)
+      post_process_template(text)
+    end
+
+    # post process the text so that
+    # "!Ref IamRole" => !Ref IamRole
+    # We strip the surrounding quotes
+    def post_process_template(text)
+      results = text.split("\n").map do |line|
+        if line.include?(': "!') # IE: IamRole: "!Ref IamRole",
+           # IamRole: "!Ref IamRole" => IamRole: !Ref IamRole
+          line.sub(/: "(.*)"/, ': \1')
+        elsif line.include?('- "!') # IE: - "!GetAtt Foo.Arn"
+           # IamRole: - "!GetAtt Foo.Arn" => - !GetAtt Foo.Arn
+          line.sub(/- "(.*)"/, '- \1')
+        else
+          line
+        end
+      end
+      results.join("\n") + "\n"
+    end
+
+    def add_description(desc)
+      @template[:Description] = desc
+    end
+
+    def add_parameters(attributes)
+      attributes.each do |name,value|
+        add_parameter(name.to_s.camelize, Description: value)
+      end
+    end
+
+    def add_parameter(name, options={})
+      defaults = { Type: "String" }
+      options = defaults.merge(options)
+      @template[:Parameters] ||= {}
+      @template[:Parameters][name.to_s.camelize] = Jets::Camelizer.transform(options)
+    end
+
+    def add_outputs(attributes)
+      attributes.each do |name,value|
+        add_output(name.to_s.camelize, Value: value)
+      end
+    end
+
+    def add_output(name, options={})
+      @template[:Outputs] ||= {}
+      @template[:Outputs][name.camelize] = Jets::Camelizer.transform(options)
+    end
+
+    def add_resources
+      @app_class.tasks.each do |task|
+        task.associated_resources.each do |associated|
+          resource = Jets::Resource.new(associated.definition, task.replacements)
+          add_resource(resource)
+          add_resource(resource.permission)
+        end
+      end
+    end
+
+    def add_resource(resource)
+      add_template_resource(resource.logical_id, resource.type, resource.attributes)
+    end
+
+    # The add_resource method can take an options Hash with both with either
+    # top level attributes or properties.
+    #
+    # Example:
+    #
+    # Top level options:
+    #
+    #   add_template_resource("MyId", "AWS::ApiGateway::RestApi",
+    #     type: "AWS::ApiGateway::RestApi",
+    #     properties: {
+    #       name: "my-api"
+    #     },
+    #     depends_on: ["AnotherResource"]
+    #   )
+    #
+    # Simple options with properties only:
+    #
+    #   add_template_resource("MyId", "AWS::CloudFormationStack",
+    #     template_url: "template_url",
+    #     parameters: {},
+    #   )
+    #
+    def add_template_resource(logical_id, type, options)
+      options = Jets::Camelizer.transform(options)
+
+      attributes = if options.include?('Type')
+                     base = { 'Type' => type }
+                     base.merge(options) # options are top-level attributes
+                   else
+                     {
+                       'Type' => type,
+                       'Properties' => options # options are properties
+                     }
+                   end
+
+      @template['Resources'][logical_id] = attributes
+    end
+  end
+end

data/lib/jets/cfn/builders/job_builder.rb

@@ -0,0 +1,14 @@
+# Implements:
+#
+#   compose
+#   template_path
+#
+module Jets::Cfn::Builders
+  class JobBuilder < BaseChildBuilder
+    def compose
+      add_common_parameters
+      add_functions
+      add_resources
+    end
+  end
+end

data/lib/jets/cfn/builders/parent_builder/stagger.rb

@@ -0,0 +1,34 @@
+class Jets::Cfn::Builders::ParentBuilder
+  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/builders/parent_builder.rb

@@ -0,0 +1,130 @@
+require 'erb'
+
+module Jets::Cfn::Builders
+  class ParentBuilder
+    include Interface
+    include Jets::AwsServices
+    include Stagger
+
+    def initialize(options={})
+      @options = options
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+
+    # compose is an interface method
+    def compose
+      build_minimal_resources
+      build_child_resources if full?
+    end
+
+    # template_path is an interface method
+    def template_path
+      Jets::Naming.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
+      resource = Jets::Resource::S3::Bucket.new(logical_id: "s3_bucket",
+        bucket_encryption: {
+          server_side_encryption_configuration: [
+            server_side_encryption_by_default: {
+              sse_algorithm: "AES256"
+          }]}
+      )
+      add_resource(resource)
+      add_outputs(resource.outputs)
+
+      return unless full?
+      # Add application-wide IAM policy from Jets.config.iam_role
+      resource = Jets::Resource::Iam::ApplicationRole.new
+      add_resource(resource)
+      add_outputs(resource.outputs)
+
+      return if Jets.poly_only?
+      resource = Jets::Resource::Lambda::GemLayer.new
+      add_resource(resource)
+      add_outputs(resource.outputs)
+    end
+
+    def build_child_resources
+      for_each_path(:app) do |path|
+        add_app_class_stack(path)
+      end
+      for_each_path(:shared) do |path|
+        add_shared_resources(path)
+      end
+
+      if full? and !Jets::Router.routes.empty?
+        for_each_path(:authorizers) do |path|
+          add_authorizer_resources(path)
+        end
+        add_api_gateway
+        add_api_resources
+        add_api_deployment
+      end
+    end
+
+    # Example paths:
+    #    #{Jets.build_root}/templates/demo-dev-2-shared-resources.yml
+    #    #{Jets.build_root}/templates/demo-dev-2-app-comments_controller.yml
+    #    #{Jets.build_root}/templates/demo-dev-2-authorizers-main_authorizer.yml
+    def for_each_path(type)
+      expression = "#{Jets::Naming.template_path_prefix}-#{type}-*"
+      Dir.glob(expression).each do |path|
+        next unless File.file?(path)
+        yield(path)
+      end
+    end
+
+    def full?
+      @options[:templates] || @options[:stack_type] == :full
+    end
+
+    def add_app_class_stack(path)
+      resource = Jets::Resource::ChildStack::AppClass.new(@options[:s3_bucket], path: path)
+      add_stagger(resource)
+      add_child_resources(resource)
+    end
+
+    def add_authorizer_resources(path)
+      resource = Jets::Resource::ChildStack::Authorizer.new(@options[:s3_bucket], path: path)
+      add_child_resources(resource)
+    end
+
+    def add_shared_resources(path)
+      resource = Jets::Resource::ChildStack::Shared.new(@options[:s3_bucket], path: path)
+      add_child_resources(resource) if resource.resources?
+    end
+
+    def add_api_gateway
+      resource = Jets::Resource::ChildStack::ApiGateway.new(@options[:s3_bucket])
+      add_child_resources(resource)
+    end
+
+    def add_api_resources
+      expression = "#{Jets::Naming.template_path_prefix}-api-resources-*"
+      # IE: path: #{Jets.build_root}/templates/demo-dev-2-api-resources-1.yml"
+      Dir.glob(expression).sort.each do |path|
+        next unless File.file?(path)
+
+        regexp = Regexp.new("#{Jets.config.project_namespace}-api-resources-(\\d+).yml") # tricky to escape \d pattern
+        md = path.match(regexp)
+        page = md[1]
+        resource = Jets::Resource::ChildStack::ApiResource.new(@options[:s3_bucket], page: page)
+        add_child_resources(resource)
+      end
+    end
+
+    def add_api_deployment
+      resource = Jets::Resource::ChildStack::ApiDeployment.new(@options[:s3_bucket])
+      add_child_resources(resource)
+    end
+
+    def add_child_resources(resource)
+      add_resource(resource)
+      add_outputs(resource.outputs)
+    end
+  end
+end