jets_bb_fork 0.0.4

data/lib/jets/resource/api_gateway/rest_api/routes/collision/variable_exception.rb

@@ -0,0 +1,7 @@
+class Jets::Resource::ApiGateway::RestApi::Routes::Collision
+  class VariableException < RuntimeError
+    def initialize(message="Route variable collisions")
+      super(message)
+    end
+  end
+end

data/lib/jets/resource/associated.rb

@@ -0,0 +1,37 @@
+# Does not do full expansion, mainly a container that holds the definition and
+# standardizes it without camelizing it.
+class Jets::Resource
+  class Associated
+    extend Memoist
+
+    attr_reader :definition
+    attr_accessor :multiple_resources
+    def initialize(*definition)
+      @definition = definition.flatten
+      # Some associated resources require multiple resources for a single Lambda function. For
+      # example `sqs_event` can create a `SQS::Queue` and `Lambda::EventSourceMapping`.  We set
+      # a `multiple` flag so `add_logical_id_counter` can use it to avoid adding counter ids to
+      # these type of resources. The `multiple` flag allows us to handle both:
+      #
+      #   1. Associated resources that contain multiple resources for a single Lambda function
+      #   2. A single Lambda function with multiple events.  In this case, a counter is added
+      #
+      # Setting `multiple` to true means the counter id will not be added.
+      @multiple_resources = false
+    end
+
+    def logical_id
+      standardized.keys.first
+    end
+
+    def attributes
+      standardized.values.first
+    end
+
+    def standardized
+      standardizer = Standardizer.new(definition)
+      standardizer.standarize(definition) # doesnt camelize keys yet
+    end
+    memoize :standardized
+  end
+end

data/lib/jets/resource/base.rb

@@ -0,0 +1,28 @@
+# Classes that inherit from this method should NOT define and override:
+#
+#   logical_id
+#   type
+#   properties
+#   attributes
+#
+# These are computed methods that derive their values from the resource definition itself.
+# Overriding these methods will remove the computed logical which handles things
+# like camelizing and replacements.
+#
+# The implementation of these methods are in `Jets::Resource`.
+class Jets::Resource
+  class Base
+    extend Memoist
+    delegate :logical_id, :type, :properties, :attributes, :parameters, :outputs,
+             to: :resource
+
+    def resource
+      Jets::Resource.new(definition, replacements)
+    end
+    memoize :resource
+
+    def replacements
+      @replacements || {}
+    end
+  end
+end

data/lib/jets/resource/child_stack/api_deployment.rb

@@ -0,0 +1,56 @@
+# Implements:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class ApiDeployment < Base
+    def definition
+      {
+        deployment_id => {
+          type: "AWS::CloudFormation::Stack",
+          properties: {
+            template_url: template_url,
+            parameters: parameters,
+          },
+          depends_on: depends_on,
+        }
+      }
+    end
+
+    def parameters
+      p = {
+        IamRole: "!GetAtt IamRole.Arn",
+        RestApi: "!GetAtt ApiGateway0.Outputs.RestApi",
+        S3Bucket: "!Ref S3Bucket",
+      }
+      p[:DomainName] = "!GetAtt ApiGateway0.Outputs.DomainName" if Jets.custom_domain?
+      p
+    end
+
+    def depends_on
+      expression = "#{Jets::Naming.template_path_prefix}-*_controller*"
+      controller_logical_ids = []
+      Dir.glob(expression).each do |path|
+        next unless File.file?(path)
+
+        # map the path to a camelized logical_id. Example:
+        #   /tmp/jets/demo/templates/demo-dev-2-posts_controller.yml to
+        #   PostsController
+        regexp = Regexp.new(".*#{Jets.config.project_namespace}-app-")
+        controller_name = path.sub(regexp, '').sub('.yml', '')
+        controller_logical_id = controller_name.underscore.camelize
+        controller_logical_ids << controller_logical_id
+      end
+      controller_logical_ids
+    end
+
+    def deployment_id
+      Jets::Resource::ApiGateway::Deployment.logical_id
+    end
+
+    def template_filename
+      "#{Jets.config.project_namespace}-api-deployment.yml"
+    end
+  end
+end

data/lib/jets/resource/child_stack/api_gateway.rb

@@ -0,0 +1,53 @@
+# Implements:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class ApiGateway < Base
+    def initialize(s3_bucket, options={})
+      super
+      @page = options[:page]
+      @page_range = options[:page_range]
+      @required_parameters = options[:required_parameters]
+    end
+    
+    def definition
+
+      properties = {
+        template_url: template_url,
+      }
+      properties["parameters"] = parameters unless @page == 0
+
+      Hash["api_gateway_#{@page}" => {
+        type: "AWS::CloudFormation::Stack",
+        properties: properties
+      }]
+
+
+    end
+
+    def parameters
+      p = {
+        RestApi: "!GetAtt ApiGateway0.Outputs.RestApi",
+        RootResourceId: "!GetAtt ApiGateway0.Outputs.RootResourceId",
+      } 
+
+      @required_parameters.each do |required_parameter|
+        p[required_parameter[:logical_id]] = "!GetAtt #{required_parameter[:location]}"
+      end unless @required_parameters.nil?
+
+      p
+    end
+
+    def outputs
+      {
+        logical_id => "!Ref #{logical_id}",
+      }
+    end
+
+    def template_filename
+      "#{Jets.config.project_namespace}-api-gateway-#{@page}.yml"
+    end
+  end
+end

data/lib/jets/resource/child_stack/app_class.rb

@@ -0,0 +1,107 @@
+# Implements:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class AppClass < Base
+    def initialize(s3_bucket, options={})
+      super
+      @path = options[:path]
+    end
+
+    def definition
+      logical_id = app_logical_id
+      defintion = {
+        logical_id => {
+          type: "AWS::CloudFormation::Stack",
+          properties: {
+            template_url: template_url,
+            parameters: parameters,
+          }
+        }
+      }
+      defintion[logical_id][:depends_on] = depends_on if depends_on
+      defintion
+    end
+
+    def depends_on
+      klass = current_app_class.constantize
+      return unless klass.depends_on
+
+      depends = Jets::Stack::Depends.new(klass.depends_on)
+      depends.stack_list
+    end
+
+    def depends_on_params
+      klass = current_app_class.constantize
+      return unless klass.depends_on
+      depends = Jets::Stack::Depends.new(klass.depends_on)
+      depends.params
+    end
+
+    def parameters
+      common = self.class.common_parameters
+      common.merge!(controller_params) if controller?
+      common.merge!(depends_on_params) if depends_on
+      common
+    end
+
+    def self.common_parameters
+      parameters = {
+        IamRole: "!GetAtt IamRole.Arn",
+        S3Bucket: "!Ref S3Bucket",
+      }
+      parameters[:GemLayer] = "!Ref GemLayer" unless Jets.poly_only?
+      parameters
+    end
+
+    def controller_params
+      return {} if Jets::Router.routes.empty?
+
+      params = {
+        RestApi: "!GetAtt ApiGateway0.Outputs.RestApi",
+      }
+      scoped_routes.each do |route|
+        resource = Jets::Resource::ApiGateway::Resource.new(route.path)
+        params[resource.logical_id] = "!GetAtt ApiGateway#{path_index(route.path)}.Outputs.#{resource.logical_id}"
+      end
+      params
+    end
+
+    def path_index(path)
+      @options[:indexed_paths].fetch(path) 
+    end
+
+    def controller?
+      @path.include?('_controller.yml')
+    end
+
+    def scoped_routes
+      @routes ||= Jets::Router.routes.select do |route|
+        route.controller_name == current_app_class
+      end
+    end
+
+    def current_app_class
+      templates_prefix = "#{Jets::Naming.template_path_prefix}-app-"
+      @path.sub(templates_prefix, '')
+        .sub(/\.yml$/,'')
+        .gsub('-','/')
+        .camelize
+    end
+
+    # map the path to a camelized logical_id. Example:
+    #   /tmp/jets/demo/templates/demo-dev-2-posts_controller.yml to
+    #   PostsController
+    def app_logical_id
+      regexp = Regexp.new(".*#{Jets.config.project_namespace}-app-")
+      controller_name = @path.sub(regexp, '').sub('.yml', '')
+      controller_name.underscore.camelize
+    end
+
+    def template_filename
+      @path
+    end
+  end
+end

data/lib/jets/resource/child_stack/base.rb

@@ -0,0 +1,24 @@
+# Inheriting classes should implement:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class Base < Jets::Resource::Base
+    def initialize(s3_bucket, options={})
+      @s3_bucket = s3_bucket
+      @options = options
+    end
+
+    def outputs
+      {
+        logical_id => "!Ref #{logical_id}",
+      }
+    end
+
+    def template_url
+      basename = File.basename(template_filename)
+      "https://s3.amazonaws.com/#{@s3_bucket}/jets/cfn-templates/#{basename}"
+    end
+  end
+end

data/lib/jets/resource/child_stack/shared.rb

@@ -0,0 +1,92 @@
+# Implements:
+#
+#   definition
+#   template_filename
+#
+module Jets::Resource::ChildStack
+  class Shared < AppClass
+    def initialize(s3_bucket, options={})
+      super
+      @path = options[:path]
+    end
+
+    def definition
+      logical_id = shared_logical_id
+      definition = {
+        logical_id => {
+          type: "AWS::CloudFormation::Stack",
+          properties: child_properties
+        }
+      }
+      definition[logical_id][:depends_on] = depends_on if depends_on
+      definition
+    end
+
+    def child_properties
+      props = {
+        template_url: template_url,
+      }
+
+      props[:parameters] = common_parameters # common child parameters
+      # add depends on parameters
+      depends_on.each do |dependency|
+        dependency_outputs(dependency).each do |output|
+          dependency_class = dependency.to_s.camelize
+          props[:parameters][output] = "!GetAtt #{dependency_class}.Outputs.#{output}"
+        end
+      end if depends_on
+
+      props
+    end
+
+    def common_parameters
+      parameters = {
+        IamRole: "!GetAtt IamRole.Arn",
+        S3Bucket: "!Ref S3Bucket",
+      }
+      parameters[:GemLayer] = "!Ref GemLayer" unless Jets.poly_only?
+      parameters
+    end
+
+    # Returns output keys associated with the stack.  They are the resource logical ids.
+    def dependency_outputs(dependency)
+      dependency.to_s.camelize.constantize.output_keys
+    end
+
+    def depends_on
+      return unless current_shared_class.depends_on
+      current_shared_class.depends_on.map { |x| x.to_s.camelize }
+    end
+
+    # map the path to a camelized logical_id. Example:
+    #   /tmp/jets/demo/templates/demo-dev-2-shared-resources.yml to
+    #   PostsController
+    def shared_logical_id
+      regexp = Regexp.new(".*#{Jets.config.project_namespace}-shared-") # remove the shared
+      shared_name = @path.sub(regexp, '').sub('.yml', '')
+      shared_name.underscore.camelize
+    end
+
+    # IE: app/resource.rb => Resource
+    # Returns Resource class object in the example
+    def current_shared_class
+      templates_prefix = "#{Jets::Naming.template_path_prefix}-shared-"
+      @path.sub(templates_prefix, '')
+        .sub(/\.yml$/,'')
+        .gsub('-','/')
+        .camelize
+        .constantize # returns actual class
+    end
+
+    # Tells us if there are any resources defined in the shared class.
+    #
+    # Returns: Boolean
+    def resources?
+      current_shared_class.build?
+    end
+
+    def template_filename
+      "#{Jets.config.project_namespace}-shared-#{current_shared_class.to_s.underscore}.yml"
+    end
+  end
+end

data/lib/jets/resource/config/config_rule.rb

@@ -0,0 +1,74 @@
+module Jets::Resource::Config
+  class ConfigRule < Jets::Resource::Base
+    def initialize(app_class, meth, props={})
+      @app_class = app_class.to_s
+      @meth = meth
+      @props = props # associated_properties from dsl.rb
+    end
+
+    def definition
+      base = {
+        config_rule_logical_id => {
+          type: "AWS::Config::ConfigRule",
+          properties: definition_properties
+        }
+      }
+
+      # Explicitly set depends_on to help with CloudFormation random race condition.
+      # Seems to be a new CloudFormation and AWS Config resource issue.
+      if definition_properties[:source][:owner] == 'CUSTOM_LAMBDA'
+        base[config_rule_logical_id][:depends_on] = "{namespace}Permission"
+      end
+
+      base
+    end
+
+    # Do not name this method properties, that is a computed method of `Jets::Resource::Base`
+    def definition_properties
+      {
+        config_rule_name: config_rule_name,
+        source: {
+          owner: "CUSTOM_LAMBDA",
+          source_identifier: "!GetAtt {namespace}LambdaFunction.Arn",
+          source_details: [
+            {
+              event_source: "aws.config",
+              message_type: "ConfigurationItemChangeNotification"
+            },
+            {
+              event_source: "aws.config",
+              message_type: "OversizedConfigurationItemChangeNotification"
+            }
+          ]
+        },
+      }.deep_merge(@props)
+    end
+
+    def config_rule_logical_id
+      "{namespace}_config_rule"
+    end
+
+    def config_rule_name
+      app_class = @app_class.underscore.gsub(/_rule$/,'')
+      ns = namespace
+      ns = nil if ns == false # for compact
+      [ns, "#{app_class}_#{@meth}"].compact.join('_').dasherize
+    end
+
+    def namespace
+      namespace = nil
+      klass = @app_class.constantize
+      while klass != Jets::Lambda::Functions
+        namespace = klass.rule_namespace
+        break if namespace or namespace == false
+        klass = klass.superclass
+      end
+
+      if namespace.nil?
+        Jets.config.project_namespace
+      else
+        namespace
+      end
+    end
+  end
+end