jets 0.7.1 → 0.8.0

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

@@ -0,0 +1,18 @@
+# Overrides
+#   replace_core_values
+module Jets::Resource::Replacer
+  class ConfigRule < Base
+    def core_replacements
+      {
+        config_rule_name: config_rule_name
+      }
+    end
+
+    # Conventional config rule name
+    # Similar logic in Rule::Dsl.managed_rule
+    def config_rule_name
+      name_without_rule = @app_class.underscore.gsub(/_rule$/,'')
+      "#{name_without_rule}_#{@task.meth}".dasherize
+    end
+  end
+end

data/lib/jets/resource/route.rb

@@ -0,0 +1,67 @@
+# Converts a Jets::Route to a CloudFormation resource
+module Jets::Resource
+  class Route
+    autoload :Attributes, 'jets/resource/route/attributes'
+    autoload :Cors, 'jets/resource/route/cors'
+
+    extend Memoist
+
+    # route - Jets::Route
+    def initialize(route)
+      @route = route
+    end
+
+    def attributes
+      attributes = {
+        "#{method_logical_id}ApiMethod" => {
+          type: "AWS::ApiGateway::Method",
+          properties: {
+            resource_id: "!Ref #{resource_id}",
+            rest_api_id: "!Ref RestApi",
+            http_method: @route.method,
+            request_parameters: {},
+            authorization_type: "NONE",
+            integration: {
+              integration_http_method: "POST",
+              type: "AWS_PROXY",
+              uri: "!Sub arn:aws:apigateway:${AWS::Region}:lambda:path/2015-03-31/functions/${{namespace}LambdaFunction.Arn}/invocations"
+            },
+            method_responses: []
+          }
+        }
+      }
+
+      definitions = attributes # to emphasize that its the same thing
+      task = Jets::Lambda::Task.new(@route.controller_name, @route.action_name,
+               resources: definitions)
+      Attributes.new(attributes, task)
+    end
+    alias_method :resource, :attributes
+    memoize :attributes
+
+  private
+    # Similar path_logical_id method in template_mappers/gateway_resource_mapper.rb
+    # Example: PostsGet
+    def method_logical_id
+      path = camelized_path
+      path + "#{@route.method.to_s.downcase.camelize}"
+    end
+
+    def resource_id
+      @route.path == '' ?
+       "RootResourceId" :
+       "#{resource_logical_id}ApiResource"
+    end
+
+    # Example: Posts
+    def resource_logical_id
+      camelized_path
+    end
+
+    def camelized_path
+      path = @route.path
+      path = "homepage" if path == ''
+      path.gsub('/','_').gsub(':','').gsub('*','').camelize
+    end
+  end
+end

data/lib/jets/resource/route/attributes.rb

@@ -0,0 +1,8 @@
+class Jets::Resource::Route
+  class Attributes < Jets::Resource::Attributes
+    def cors(route)
+      Cors.new(route)
+    end
+    memoize :cors
+  end
+end

data/lib/jets/resource/route/cors.rb

@@ -0,0 +1,60 @@
+class Jets::Resource::Route
+  class Cors < Jets::Resource::Route
+    def attributes
+      attributes = {
+        "#{resource_logical_id}CorsApiMethod" => {
+          type: "AWS::ApiGateway::Method",
+
+          properties: {
+            resource_id: "!Ref #{resource_id}",
+            rest_api_id: "!Ref RestApi",
+            authorization_type: "NONE",
+            http_method: "OPTIONS",
+            method_responses: [{
+              status_code: '200',
+              response_parameters: {
+                "method.response.header.Access-Control-AllowOrigin": true,
+                "method.response.header.Access-Control-AllowHeaders": true,
+                "method.response.header.Access-Control-AllowMethods": true,
+                "method.response.header.Access-Control-AllowCredentials": true,
+              },
+              response_models: {},
+            }],
+            request_parameters: {},
+            integration: {
+              type: "MOCK",
+              request_templates: {
+                "application/json": "{statusCode:200}",
+              },
+              integration_responses: [{
+                status_code: '200',
+                response_parameters: {
+                  "method.response.header.Access-Control-AllowOrigin": "'#{allow_origin}'",
+                  "method.response.header.Access-Control-AllowHeaders": "'Content-Type,X-Amz-Date,Authorization,X-Api-Key,X-Amz-Security-Token,X-Amz-User-Agent'",
+                  "method.response.header.Access-Control-AllowMethods": "'OPTIONS,GET'",
+                  "method.response.header.Access-Control-AllowCredentials": "'false'",
+                },
+                response_templates: {
+                  "application/json": '',
+                },
+              }] # closes integration_responses
+            } # closes integration
+          } # closes properties
+        } # closes logical id
+      } # closes attributes
+
+      definitions = attributes # to emphasize that its the same thing
+      task = Jets::Lambda::Task.new(@route.controller_name, @route.action_name,
+               resources: definitions)
+      Attributes.new(attributes, task)
+    end
+
+    def allow_origin
+      if Jets.config.cors == true
+        '*'
+      elsif Jets.config.cors
+        Jets.config.cors
+      end
+    end
+  end
+end

data/lib/jets/rule.rb

@@ -1,6 +1,4 @@
 class Jets::Rule
-  autoload :AwsManagedRule, "jets/rule/aws_managed_rule"
   autoload :Base, "jets/rule/base"
   autoload :Dsl, "jets/rule/dsl"
-  autoload :Task, "jets/rule/task"
 end

data/lib/jets/rule/dsl.rb

@@ -1,6 +1,9 @@
 # Jets::Rule::Base < Jets::Lambda::Functions
 # Both Jets::Rule::Base and Jets::Lambda::Functions have Dsl modules included.
 # So the Jets::Rule::Dsl overrides some of the Jets::Lambda::Functions behavior.
+#
+# Implements:
+#   default_associated_resource: must return @resources
 module Jets::Rule::Dsl
   extend ActiveSupport::Concern
 
@@ -14,59 +17,103 @@ module Jets::Rule::Dsl
       def scope(value)
         scope = case value
           when String
-            {"ComplianceResourceTypes" => [value]}
+            {compliance_resource_types: [value]}
           when Array
-            {"ComplianceResourceTypes" => value}
+            {compliance_resource_types: value}
           else # default to hash
             value
           end
-
-        config_rule(scope: scope)
+        update_properties(scope: scope)
       end
 
       def config_rule_name(value)
-        config_rule(config_rule_name: value)
+        update_properties(config_rule_name: value)
       end
 
       def description(value)
-        config_rule(description: value)
+        update_properties(description: value)
       end
       alias_method :desc, :description
 
       def input_parameters(value)
-        config_rule(input_parameters: value)
+        update_properties(input_parameters: value)
       end
 
       def maximum_execution_frequency(value)
-        config_rule(maximum_execution_frequency: value)
+        update_properties(maximum_execution_frequency: value)
       end
 
       def source(value)
-        config_rule(source: value)
+        update_properties(source: value)
       end
 
-      def config_rule(options={})
-        @config_rule ||= {}
-        @config_rule.deep_merge!(options)
+      def default_associated_resource
+        config_rule
       end
 
-      # Override register_task.
-      # Creates instances of Rule::Task instead of a Lambda::Task
-      # Also adds the config_rule option that is specific to Rule classes
-      def register_task(meth, lang=:ruby)
-        all_tasks[meth] = Jets::Rule::Task.new(self.name, meth,
-          properties: @properties, config_rule: @config_rule, lang: lang)
-        clear_properties
-        true
+      def config_rule(props={})
+        default_props = {
+          config_rule_name: "{config_rule_name}",
+          source: {
+            owner: "CUSTOM_LAMBDA",
+            source_identifier: "{namespace}LambdaFunction.Arn",
+            source_details: [
+              {
+                event_source: "aws.config",
+                message_type: "ConfigurationItemChangeNotification"
+              },
+              {
+                event_source: "aws.config",
+                message_type: "OversizedConfigurationItemChangeNotification"
+              }
+            ]
+          }
+        }
+        properties = default_props.deep_merge(props)
+
+        resource("{namespace}ConfigRule" => {
+          type: "AWS::Config::ConfigRule",
+          properties: properties
+        })
+        @resources # must return @resoures for update_properties
       end
 
-      def clear_properties
-        super
-        @config_rule = nil
+      def managed_rule(name, props={})
+        name = name.to_s
+
+        # Similar logic in Replacer::ConfigRule#config_rule_name
+        name_without_rule = self.name.underscore.gsub(/_rule$/,'')
+        config_rule_name = "#{name_without_rule}_#{name}".dasherize
+        source_identifier = name.upcase
+
+        default_props = {
+          config_rule_name: config_rule_name,
+          source: {
+            owner: "AWS",
+            source_identifier: source_identifier,
+          }
+        }
+        properties = default_props.deep_merge(props)
+        # The key is to use update_properties to update the current resource and maintain
+        # the added properties from the convenience methods like scope and description.
+        # At the same time, we do not register the task to all_tasks to avoid creating a Lambda function.
+        # Instead we store it in all_managed_rules.
+        update_properties(properties)
+        definition = @resources.first
+
+        register_managed_rule(name, definition)
       end
 
-      ## aws managed rules work different enough to merit their own storage
+      # Creates a task but registers it to all_managed_rules instead of all_tasks
+      # because we do not want Lambda functions to be created.
+      def register_managed_rule(name, definition)
+        # A task object is needed to build {namespace} for later replacing.
+        task = Jets::Lambda::Task.new(self.name, name, resources: @resources)
+        all_managed_rules[name] = { definition: definition, task: task }
+        clear_properties
+      end
 
+      # AWS managed rules are not actual Lambda functions and require their own storage.
       def all_managed_rules
         @all_managed_rules ||= ActiveSupport::OrderedHash.new
       end
@@ -75,13 +122,6 @@ module Jets::Rule::Dsl
         all_managed_rules.values
       end
 
-      def managed_rule(meth)
-        all_managed_rules[meth] = Jets::Rule::AwsManagedRule.new(self.name, meth,
-          properties: @properties, config_rule: @config_rule)
-        clear_properties
-        true
-      end
-
       # Override Lambda::Dsl.build? to account of possible managed_rules
       def build?
         !tasks.empty? || !managed_rules.empty?

data/lib/jets/version.rb

@@ -1,3 +1,3 @@
 module Jets
-  VERSION = "0.7.1"
+  VERSION = "0.8.0"
 end

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: jets
 version: !ruby/object:Gem::Version
-  version: 0.7.1
+  version: 0.8.0
 platform: ruby
 authors:
 - Tung Nguyen
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2018-08-30 00:00:00.000000000 Z
+date: 2018-09-03 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: thor
@@ -458,11 +458,8 @@ files:
 - lib/jets/cfn/template_mappers/api_gateway_deployment_mapper.rb
 - lib/jets/cfn/template_mappers/api_gateway_mapper.rb
 - lib/jets/cfn/template_mappers/child_mapper.rb
-- lib/jets/cfn/template_mappers/config_rule_mapper.rb
 - lib/jets/cfn/template_mappers/controller_mapper.rb
-- lib/jets/cfn/template_mappers/events_rule_mapper.rb
 - lib/jets/cfn/template_mappers/function_mapper.rb
-- lib/jets/cfn/template_mappers/gateway_method_mapper.rb
 - lib/jets/cfn/template_mappers/gateway_resource_mapper.rb
 - lib/jets/cfn/template_mappers/iam_policy.rb
 - lib/jets/cfn/template_mappers/iam_policy/application_policy_mapper.rb
@@ -602,7 +599,6 @@ files:
 - lib/jets/job.rb
 - lib/jets/job/base.rb
 - lib/jets/job/dsl.rb
-- lib/jets/job/task.rb
 - lib/jets/klass.rb
 - lib/jets/lambda.rb
 - lib/jets/lambda/dsl.rb
@@ -629,14 +625,22 @@ files:
 - lib/jets/rails_overrides/common_methods.rb
 - lib/jets/rails_overrides/rendering_helper.rb
 - lib/jets/rails_overrides/url_helper.rb
+- lib/jets/resource.rb
+- lib/jets/resource/attributes.rb
+- lib/jets/resource/creator.rb
+- lib/jets/resource/permission.rb
+- lib/jets/resource/replacer.rb
+- lib/jets/resource/replacer/base.rb
+- lib/jets/resource/replacer/config_rule.rb
+- lib/jets/resource/route.rb
+- lib/jets/resource/route/attributes.rb
+- lib/jets/resource/route/cors.rb
 - lib/jets/route.rb
 - lib/jets/router.rb
 - lib/jets/ruby_server.rb
 - lib/jets/rule.rb
-- lib/jets/rule/aws_managed_rule.rb
 - lib/jets/rule/base.rb
 - lib/jets/rule/dsl.rb
-- lib/jets/rule/task.rb
 - lib/jets/server.rb
 - lib/jets/server/api_gateway.rb
 - lib/jets/server/lambda_aws_proxy.rb

data/lib/jets/cfn/template_mappers/config_rule_mapper.rb

@@ -1,34 +0,0 @@
-# Used in cfn/template_builders/rule_builder.rb to build AWS::Config::ConfigRule
-class Jets::Cfn::TemplateMappers
-  class ConfigRuleMapper
-    # task is a Jets::Job::Task
-    def initialize(task)
-      @task = task
-    end
-
-    # Example: "ConfigRuleGameRuleProtect"
-    def logical_id
-      "#{full_task_name}ConfigRule"
-    end
-
-    # Example: "GameRuleProtectLambdaFunction"
-    def lambda_function_logical_id
-      "#{full_task_name}LambdaFunction"
-    end
-
-    # Example: GameRuleProtectConfigRulePermission
-    def permission_logical_id
-      "#{full_task_name}ConfigRulePermission"
-    end
-
-  private
-    # Full camelized task name including the class
-    # Example: GameRuleProtect
-    def full_task_name
-      class_name = @task.class_name
-      task_name = @task.meth.to_s.camelize
-      "#{class_name}#{task_name}"
-    end
-  end
-end
-

data/lib/jets/cfn/template_mappers/events_rule_mapper.rb

@@ -1,40 +0,0 @@
-class Jets::Cfn::TemplateMappers
-  class EventsRuleMapper
-    # task is a Jets::Job::Task
-    def initialize(task)
-      @task = task
-    end
-
-    # Example: "HardJobDigScheduledEvent"
-    def logical_id
-      "#{full_task_name}ScheduledEvent"
-    end
-
-    # Example: "HardJobDigLambdaFunction"
-    def lambda_function_logical_id
-      "#{full_task_name}LambdaFunction"
-    end
-
-    # Target Id: A unique, user-defined identifier for the target. Acceptable values include alphanumeric characters, periods (.), hyphens (-), and underscores (_).
-    #
-    # Example: RuleTargetHardJobDig
-    def rule_target_id
-      "#{full_task_name}RuleTarget"
-    end
-
-    # Example: HardJobDigEventsRulePermission
-    def permission_logical_id
-      "#{full_task_name}EventsRulePermission"
-    end
-
-  private
-    # Full camelized task name including the class
-    # Example: HardJobDig
-    def full_task_name
-      class_name = @task.class_name.gsub('::','')
-      task_name = @task.meth.to_s.camelize
-      "#{class_name}#{task_name}"
-    end
-  end
-end
-