jets-fs 1.6.10

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

@@ -0,0 +1,80 @@
+class Jets::Cfn::Builders
+  class ApiGatewayBuilder
+    include Interface
+    include Jets::AwsServices
+
+    def initialize(options={})
+      @options = options
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+
+    # compose is an interface method
+    def compose
+      return unless @options[:templates] || @options[:stack_type] != :minimal
+
+      add_gateway_rest_api
+      add_custom_domain
+      add_gateway_routes
+    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
+      domain_name = Jets::Resource::ApiGateway::DomainName.new
+      add_resource(domain_name)
+      add_outputs(domain_name.outputs)
+    end
+
+    def add_route53_dns
+      dns = Jets::Resource::Route53::RecordSet.new
+      add_resource(dns)
+      add_outputs(dns.outputs)
+    end
+
+    # Adds route related Resources and Outputs
+    def add_gateway_routes
+      # The routes required a Gateway Resource to contain them.
+      # TODO: Support more routes. Right now outputing all routes in 1 template will hit the 60 routes limit.
+      # Will have to either output them as a joined string or break this up to multiple templates.
+      # http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/cloudformation-limits.html
+      # Outputs: Maximum number of outputs that you can declare in your AWS CloudFormation template. 60 outputs
+      # Output name: Maximum size of an output name. 255 characters.
+      #
+      # Note we must use .all_paths, not .routes here because we need to
+      # build the parent ApiGateway::Resource nodes also
+      Jets::Router.all_paths.each do |path|
+        homepage = path == ''
+        next if homepage # handled by RootResourceId output already
+
+        resource = Jets::Resource::ApiGateway::Resource.new(path, internal: true)
+        add_resource(resource)
+        add_outputs(resource.outputs)
+      end
+    end
+  end
+end

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

@@ -0,0 +1,82 @@
+# Implements:
+#
+#   * template_path
+#
+# FYI
+#
+#   * compose implemented by the classes that include this
+class 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::AppClass.common_parameters
+      common_parameters.each do |k,_|
+        add_parameter(k, Description: k)
+      end
+
+      depends_on_params.each do |logical_id, desc|
+        add_parameter(logical_id, Description: desc)
+      end
+    end
+
+    def depends_on_params
+      return {} unless @app_class.depends_on
+
+      params = {}
+      @app_class.depends_on.each do |shared_stack|
+        dependency = shared_stack.to_s.camelize # logical_id
+        dependency_outputs(dependency).each do |output|
+          dependency_class = dependency.to_s.classify
+          desc = "From #{dependency_class}.Outputs.#{output}"
+          # key: logical_id , value: description
+          params[output] = desc
+        end
+      end
+      params
+    end
+
+    def dependency_outputs(dependency)
+      dependency.to_s.classify.constantize.output_keys
+    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,42 @@
+# Implements:
+#
+#   compose
+#   template_path
+#
+class 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
+    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)
+      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
+#
+class 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,127 @@
+# The class including this module should implement these methods:
+#
+#   * compose
+#   * template_path
+class Jets::Cfn::Builders
+  module Interface
+    extend Memoist
+
+    def build
+      # Do not bother building or writing the template unless there are functions defined
+      return if @app_class && !@app_class.build?
+
+      compose # must be implemented by subclass
+      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_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] = 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] = 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
+#
+class 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.rb

@@ -0,0 +1,93 @@
+require 'erb'
+
+class Jets::Cfn::Builders
+  class ParentBuilder
+    include Interface
+    include Jets::AwsServices
+
+    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
+      # Initial s3 bucket, used to store code zipfile and templates Jets generates
+      resource = Jets::Resource::S3.new
+      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
+      expression = "#{Jets::Naming.template_path_prefix}-app-*"
+      # IE: path: #{Jets.build_root}/templates/demo-dev-2-comments_controller.yml
+      Dir.glob(expression).each do |path|
+        next unless File.file?(path)
+        add_app_class_stack(path)
+      end
+
+      expression = "#{Jets::Naming.template_path_prefix}-shared-*"
+      # IE: path: #{Jets.build_root}/templates/demo-dev-2-shared-resources.yml
+      Dir.glob(expression).each do |path|
+        next unless File.file?(path)
+
+        add_shared_resources(path)
+      end
+
+      if full? and !Jets::Router.routes.empty?
+        add_api_gateway
+        add_api_deployment
+      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_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_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