jets_bb_fork 0.0.4

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

@@ -0,0 +1,63 @@
+module Jets::Cfn::Builders
+  class ApiDeploymentBuilder
+    include Interface
+    include Jets::AwsServices
+
+    def initialize(options={})
+      @options = options
+      @template = ActiveSupport::HashWithIndifferentAccess.new(Resources: {})
+    end
+
+    # template is an interface method
+    def template 
+      @template
+    end
+        
+    # compose is an interface method
+    def compose
+      return unless @options[:templates] || @options[:stack_type] != :minimal
+
+      deployment = Jets::Resource::ApiGateway::Deployment.new
+      add_resource(deployment)
+      add_parameters(deployment.parameters)
+      add_outputs(deployment.outputs)
+
+      add_base_path_mapping
+    end
+
+    # Because Jets generates a new timestamped logical id for the API Deployment
+    # resource it also creates a new root base path mapping and fails.  Additionally,
+    # the base path mapping depends on the API Deploy for the stage name.
+    #
+    # We resolve this by using a custom resource that does an in-place update.
+    #
+    # Note, also tried to change the domain name of to something like demo-dev-[random].mydomain.com
+    # but that does not work because the domain name has to match the route53 record exactly.
+    #
+    def add_base_path_mapping
+      return unless Jets.custom_domain?
+
+      function = Jets::Resource::ApiGateway::BasePath::Function.new
+      add_resource(function)
+      add_outputs(function.outputs)
+
+      mapping = Jets::Resource::ApiGateway::BasePath::Mapping.new
+      add_resource(mapping)
+      add_outputs(mapping.outputs)
+
+      iam_role = Jets::Resource::ApiGateway::BasePath::Role.new
+      add_resource(iam_role)
+      add_outputs(iam_role.outputs)
+    end
+
+    # template_path is an interface method
+    def template_path
+      Jets::Naming.api_deployment_template_path
+    end
+
+    # do not bother writing a template if routes are empty
+    def write
+      super unless Jets::Router.routes.empty?
+    end
+  end
+end

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

@@ -0,0 +1,157 @@
+module Jets::Cfn::Builders
+  class ApiGatewayBuilder
+    extend Memoist  
+    include Interface
+    include Paged
+    include Jets::AwsServices
+
+    AWS_OUTPUT_LIMIT = 60
+
+    def initialize(options={})
+      @options = options
+      push(ActiveSupport::HashWithIndifferentAccess.new(Resources: {}))
+    end
+
+    # template is an interface method
+    def template 
+      current_page
+    end
+
+    # compose is an interface method
+    def compose
+      return unless @options[:templates] || @options[:stack_type] != :minimal
+
+      populate_base_template
+      add_gateway_routes
+    end
+
+    # template_path is an interface method
+    def template_path
+      Jets::Naming.api_gateway_template_path("-#{current_page_number}")
+    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
+
+    # The base template holds RestApi, DomainName, and DnsRecord
+    # The base template will be added to the parent template as "ApiGateway"
+    # Giving the original name will limit the number of changes required for
+    # the AWS 60 output limit change.
+    def populate_base_template
+      add_gateway_rest_api
+      add_custom_domain
+    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   
+      indexed_paths.each do |path, page_number|
+        homepage = path == ''
+        next if homepage # handled by RootResourceId output already
+        turn_to_page(page_number)
+        resource = Jets::Resource::ApiGateway::Resource.new(path, internal: true, indexed_paths: indexed_paths)
+        add_resource(resource)
+        add_outputs_and_exports(resource.outputs)
+        add_gateway_routes_parameters(resource, page_number)
+      end
+    end
+
+    # TODO : consider refactoring this to make intent more clear
+    def add_gateway_routes_parameters(resource, page_number)
+      add_parameter('RestApi', Description: 'RestApi') 
+      add_parameter('RootResourceId', Description: 'RootResourceId')
+      resource.required_resources_from_parameters.each do |required_resource|
+        add_parameter(required_resource[:logical_id], Description: required_resource[:logical_id])
+        required_parameters_for_page = required_parameters[page_number] ||= []
+        required_parameters_for_page.push required_resource
+      end
+    end
+
+    # required_parameters will be used by the Parent Builder to know what parameters need to be passed
+    # to gateway template
+    def required_parameters
+      @required_parameters ||= []
+    end
+
+    def add_outputs_and_exports(attributes) 
+      attributes.each do |name,value|
+        camelized_name = name.to_s.camelize
+        add_output(camelized_name, value)
+      end
+    end
+    
+    # Gateway routes are split across multiple CloudFormation templates because of a 60 Output limit by AWS.
+    # Having a resource and its corresponding parent resource ( :ParentId ) in the same template is not guaranteed
+    # so routes are indexed up front to allow us to determine how to find :ParentId ( !Ref vs !ImportValue )
+    def indexed_paths
+      # indexed_paths is a Hash with key => path and value => page_number.  Each page number represents a separate 
+      # template for the routes contained in it.
+      # The reason for making the hash is we need to pass these indexed_paths to Jets::Resource::ApiGateway::Resource so it can
+      # easily determine what page a parent path is in.
+      # NOTE: that we are trying to keep Outputs to 60 and below, however, we are indexing "paths" here.  Currently there 
+      # is a one to one relationship to paths and outputs for Jets::Resource::ApiGateway::Resource.  If that one to one changes
+      # this solution will not work
+      indexed_paths = Hash.new
+      # root path == RootResource which comes off RestApi and is in ApiGateway0
+      indexed_paths[''] = 0
+      starting_index = 0
+      page = 1
+      loop do
+        new_template # create new template here since we know we will need this page later
+        Jets::Router.all_paths[starting_index, AWS_OUTPUT_LIMIT].each do |path|
+          next if path.empty?
+          indexed_paths[path] = page
+        end
+        starting_index += AWS_OUTPUT_LIMIT
+        page += 1
+        break if starting_index >= Jets::Router.all_paths.length
+      end
+
+      indexed_paths
+    end
+    memoize :indexed_paths
+
+    def new_template
+      push(ActiveSupport::HashWithIndifferentAccess.new(Resources: {}))
+    end
+  end
+end

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

@@ -0,0 +1,75 @@
+# 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 is an interface method
+    def template 
+      @template
+    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 |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,42 @@
+# 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
+    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
+#
+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,137 @@
+# The class including this module should implement these methods:
+#
+#   * compose
+#   * template_path
+#   * template
+module 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
+      self
+    end
+
+    def write
+      if  self.is_a? Paged
+        range.each do |page_num|
+          turn_to_page(page_num)
+          FileUtils.mkdir_p(File.dirname(template_path))
+          IO.write(template_path, text)    
+        end
+      else
+        FileUtils.mkdir_p(File.dirname(template_path))
+        IO.write(template_path, text)          
+      end
+    end
+
+    def cook_template
+      # need the to_hash or the YAML dump has
+      #  !ruby/hash:ActiveSupport::HashWithIndifferentAccess
+      template.to_hash
+    end
+
+    def text
+      text = YAML.dump(cook_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