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

data/lib/jets/resource/lambda/function.rb

@@ -0,0 +1,221 @@
+module Jets::Resource::Lambda
+  class Function < Jets::Resource::Base
+    include Environment
+
+    def initialize(task)
+      @task = task
+      @app_class = task.class_name.to_s
+    end
+
+    def definition
+      {
+        function_logical_id => {
+          type: "AWS::Lambda::Function",
+          properties: combined_properties
+        }
+      }
+    end
+
+    def function_logical_id
+      "{namespace}_lambda_function".underscore
+    end
+
+    def replacements
+      @task.replacements # has namespace replacement
+    end
+
+    def combined_properties
+      props = env_properties
+        .deep_merge(global_properties)
+        .deep_merge(class_properties)
+        .deep_merge(function_properties)
+      finalize_properties!(props)
+    end
+
+    # Global properties example:
+    # jets defaults are in jets/default/application.rb.
+    # Your application's default config/application.rb then get used. Example:
+    #
+    #   Jets.application.configure do
+    #     config.function = ActiveSupport::OrderedOptions.new
+    #     config.function.timeout = 30
+    #     config.function.runtime = "nodejs8.10"
+    #     config.function.memory_size = 1536
+    #   end
+    def global_properties
+      baseline = {
+        code: {
+          s3_bucket: "!Ref S3Bucket",
+          s3_key: code_s3_key
+        },
+        role: "!Ref IamRole",
+        environment: { variables: environment },
+      }
+
+      application_config = Jets.application.config.function.to_h
+      baseline.merge(application_config)
+    end
+
+    # Class properties example:
+    #
+    #   class PostsController < ApplicationController
+    #     class_timeout 22
+    #     ...
+    #   end
+    #
+    # Also handles iam policy override at the class level. Example:
+    #
+    #   class_iam_policy("logs:*")
+    #
+    def class_properties
+      # klass is PostsController, HardJob, GameRule, Hello or HelloFunction
+      klass = Jets::Klass.from_task(@task)
+
+      class_properties = lookup_class_properties(klass)
+      if klass.build_class_iam?
+        iam_policy = Jets::Resource::Iam::ClassRole.new(klass)
+        class_properties[:role] = "!GetAtt #{iam_policy.logical_id}.Arn"
+      end
+
+      class_properties
+    end
+
+    # Accounts for inherited class_properties
+    def lookup_class_properties(klass)
+      all_classes = []
+      while klass != Object
+        all_classes << klass
+        klass = klass.superclass
+      end
+      class_properties = {}
+      # Go back down class heirachry top to down
+      all_classes.reverse.each do |k|
+        class_properties.merge!(k.class_properties)
+      end
+      class_properties
+    end
+
+    # Function properties example:
+    #
+    # class PostsController < ApplicationController
+    #   timeout 18
+    #   def index
+    #     ...
+    #   end
+    #
+    # Also handles iam policy override at the function level. Example:
+    #
+    #   iam_policy("ec2:*")
+    #   def new
+    #     render json: params.merge(action: "new")
+    #   end
+    #
+    def function_properties
+      properties = @task.properties
+      if @task.build_function_iam?
+        iam_policy = Jets::Resource::Iam::FunctionRole.new(@task)
+        properties[:role] = "!GetAtt #{iam_policy.logical_id}.Arn"
+      end
+      properties
+    end
+
+    # Properties managed by Jets with merged with finality.
+    def finalize_properties!(props)
+      handler = full_handler(props)
+      runtime = get_runtime(props)
+      description = get_descripton(props)
+      managed = {
+        handler: handler,
+        runtime: runtime,
+        description: description,
+      }
+      managed[:function_name] = function_name if function_name
+      layers = get_layers(runtime)
+      managed[:layers] = layers if layers
+      props.merge!(managed)
+    end
+
+    def get_layers(runtime)
+      return nil unless runtime =~ /^ruby/
+      return Jets.config.lambda.layers if Jets.config.gems.disable
+      
+      ["!Ref GemLayer"] + Jets.config.lambda.layers
+    end
+
+    def get_runtime(props)
+      props[:runtime] || default_runtime
+    end
+
+    def default_runtime
+      map = {
+        node: "nodejs8.10",
+        python: "python3.6",
+        ruby: Jets.ruby_runtime,
+      }
+      map[@task.lang]
+    end
+
+    def default_handler
+      map = {
+        node: @task.full_handler(:handler), # IE: handlers/controllers/posts/show.handler
+        python: @task.full_handler(:lambda_handler), # IE: handlers/controllers/posts/show.lambda_handler
+        ruby: handler, # IE: handlers/controllers/posts_controllers.index
+      }
+      map[@task.lang]
+    end
+
+    def handler
+      handler_value(@task.meth)  # IE: handlers/controllers/posts_controllers.index
+    end
+
+    # Used for node-shim also
+    def handler_value(meth)
+      "handlers/#{@task.type.pluralize}/#{@app_class.underscore}.#{meth}"
+    end
+
+    # Ensure that the handler path is normalized.
+    def full_handler(props)
+      if props[:handler]
+        handler_value(props[:handler])
+      else
+        default_handler
+      end
+    end
+
+    def code_s3_key
+      checksum = Jets::Builders::Md5.checksums["stage/code"]
+      "jets/code/code-#{checksum}.zip" # s3_key
+    end
+
+    # Examples:
+    #   "#{Jets.config.project_namespace}-sleep_job-perform"
+    #   "demo-dev-sleep_job-perform"
+    def function_name
+      # Example values:
+      #   @app_class: admin/pages_controller
+      #   @task.meth: index
+      #   method: admin/pages_controller
+      #   method: admin-pages_controller-index
+      method = @app_class.underscore
+      method = method.gsub('/','-').gsub(/[^0-9a-z\-_]/i, '') + "-#{@task.meth}"
+      function_name = "#{Jets.config.project_namespace}-#{method}"
+      # Returns nil if function name is too long.
+      # CloudFormation will managed the the function name in this case.
+      # A pretty function name won't be generated but the deploy will be successful.
+      function_name.size > Jets::MAX_FUNCTION_NAME_SIZE ? nil : function_name
+    end
+
+    def get_descripton(props)
+      props[:description] || default_description
+    end
+      
+    def default_description
+      # Example values:
+      #   @app_class: Admin/PagesController
+      #   @task.meth: index
+      # Returns:
+      #   Admin/PagesController#index
+      "#{@app_class}##{@task.meth}"
+    end
+  end
+end

data/lib/jets/resource/lambda/gem_layer.rb

@@ -0,0 +1,17 @@
+module Jets::Resource::Lambda
+  class GemLayer < LayerVersion
+    def description
+      "Jets Ruby Gems"
+    end
+
+    def layer_name
+      # Do not include the Jets.extra_env to group the layers in same app together
+      "#{Jets.config.short_env}-#{Jets.config.project_name}-gems"
+    end
+
+    def code_s3_key
+      checksum = Jets::Builders::Md5.checksums["stage/opt"]
+      "jets/code/opt-#{checksum}.zip" # s3_key
+    end
+  end
+end

data/lib/jets/resource/lambda/layer_version.rb

@@ -0,0 +1,44 @@
+# Type: "AWS::Lambda::LayerVersion"
+# Properties:
+#   CompatibleRuntimes:
+#     - String
+#     - ...
+#   Content:
+#     Content
+#   Description: String
+#   LayerName: String
+#   LicenseInfo: String
+module Jets::Resource::Lambda
+  class LayerVersion < Jets::Resource::Base
+    def definition
+      {
+        layer_version_logical_id => {
+          type: "AWS::Lambda::LayerVersion",
+          properties: {
+            content: {
+              s3_bucket: s3_bucket,
+              s3_key: code_s3_key,
+            },
+            description: description,
+            layer_name: layer_name,
+            license_info: "MIT",
+          }
+        }
+      }
+    end
+
+    def s3_bucket
+      "!Ref S3Bucket"
+    end
+
+    def layer_version_logical_id
+      self.class.name.split('::').last
+    end
+
+    def outputs
+      {
+        logical_id => "!Ref #{logical_id}",
+      }
+    end
+  end
+end

data/lib/jets/resource/logs/subscription_filter.rb

@@ -0,0 +1,31 @@
+# CloudFormation Log Subscription docs: https://amzn.to/2SNiSpr
+module Jets::Resource::Logs
+  class SubscriptionFilter < Jets::Resource::Base
+    def initialize(props={})
+      @props = props # associated_properties from dsl.rb
+    end
+
+    def definition
+      {
+        log_logical_id => {
+          type: "AWS::Logs::SubscriptionFilter",
+          properties: merged_properties,
+        }
+      }
+    end
+
+    # Do not name this method properties, that is a computed method of `Jets::Resource::Base`
+    def merged_properties
+      {
+        destination_arn: "!GetAtt {namespace}LambdaFunction.Arn",
+        filter_pattern: "", # matches everything https://amzn.to/2N3b39I
+        # log_group_name: string # will be set by log_event
+        # role_arn: string # only required for kinensis, we dont use this for Lambda
+      }.deep_merge(@props)
+    end
+
+    def log_logical_id
+      "{namespace}_subscription_filter"
+    end
+  end
+end

data/lib/jets/resource/permission.rb

@@ -0,0 +1,45 @@
+class Jets::Resource
+  class Permission < Jets::Resource::Base
+    def initialize(replacements, associated_resource)
+      @replacements = replacements
+      @associated_resource = associated_resource
+    end
+
+    def definition
+      logical_id = permission_logical_id
+
+      definition = {
+        logical_id => {
+          type: "AWS::Lambda::Permission",
+          properties: {
+            function_name: "!GetAtt {namespace}LambdaFunction.Arn",
+            action: "lambda:InvokeFunction",
+            principal: principal
+          }
+        }
+      }
+
+      # From AWS docs: https://amzn.to/2N0QXQL
+      # source_arn is "not supported by all event sources"
+      definition[logical_id][:properties][:source_arn] = source_arn if source_arn
+
+      definition
+    end
+
+    def permission_logical_id
+      logical_id = "{namespace}_permission"
+      md = @associated_resource.logical_id.match(/(\d+)$/)
+      counter = md[1] if md
+      [logical_id, counter].compact.join('').underscore
+    end
+
+    # Auto-detect principal from the associated resources.
+    def principal
+      Replacer.principal_map(@associated_resource.type)
+    end
+
+    def source_arn
+      Replacer.source_arn_map(@associated_resource.type)
+    end
+  end
+end

data/lib/jets/resource/replacer.rb

@@ -0,0 +1,85 @@
+class Jets::Resource
+  class Replacer
+    extend Memoist
+
+    def initialize(replacements={})
+      @replacements = replacements
+    end
+
+    # Replace placeholder hash values with replacements.  This does a deep replacement
+    # to the hash values.  The replacement "key" is the string value within the value.
+    #
+    # Example:
+    #
+    #   attributes = {whatever: "foo REPLACE_KEY bar" }
+    #   replace_placeholders(attributes, REPLACE_KEY: "blah:arn")
+    #   => {whatever: "foo blah:arn bar" }
+    #
+    # Also, we always replace the special {namespace} value in the hash values. Example:
+    #
+    #   attributes = {whatever: "{namespace}LambdaFunction" }
+    #   replace_placeholders(attributes, {})
+    #   => {whatever: "foo PostsControllerIndexLambdaFunction bar" }
+    #
+    def replace_placeholders(attributes)
+      update_values(attributes)
+    end
+
+    def update_values(original)
+      case original
+      when Array
+        original.map { |v| update_values(v) }
+      when Hash
+        initializer = original.map do |k, v|
+          [k, update_values(v)]
+        end
+        Hash[initializer]
+      else
+        replace_value(original)
+      end
+    end
+
+    def replace_value(value)
+      # Dont perform replacement on Integers
+      return value if value.is_a?(Integer)
+      # return value unless value.is_a?(String) or value.is_a?(Symbol)
+
+      value = value.to_s # normalize to String
+      @replacements.each do |k,v|
+        # IE: Replaces {namespace} => SecurityJobCheck
+        value = value.gsub("{#{k}}", v)
+      end
+      value
+    end
+
+    class << self
+      # Examples:
+      #   "AWS::Events::Rule" => "events.amazonaws.com",
+      #   "AWS::Config::ConfigRule" => "config.amazonaws.com",
+      #   "AWS::ApiGateway::Method" => "apigateway.amazonaws.com"
+      def principal_map(type)
+        service = type.split('::')[1].downcase
+        service = special_principal_map(service)
+        "#{service}.amazonaws.com"
+      end
+
+      def special_principal_map(service)
+        # special map
+        # s3_event actually uses sns topic events to trigger a Lambda function
+        map = { "s3" => "sns" }
+        map[service] || service
+      end
+
+      # From AWS docs: https://amzn.to/2N0QXQL
+      # source_arn is "not supported by all event sources"
+      #
+      # When it is not available the resource definition should add it.
+      def source_arn_map(type)
+        map = {
+          "AWS::ApiGateway::Method" => "!Sub arn:aws:execute-api:${AWS::Region}:${AWS::AccountId}:${RestApi}/*/*",
+        }
+        map[type]
+      end
+    end
+  end
+end

data/lib/jets/resource/route53/record_set.rb

@@ -0,0 +1,98 @@
+# CloudFormation Docs AWS::Route53::RecordSet: https://amzn.to/2BtP9s5
+#
+# Example:
+#
+#   DnsRecord:
+#     Type: AWS::Route53::RecordSet
+#     Properties:
+#       HostedZoneName: !Ref 'HostedZoneResource'
+#       Comment: DNS name for my instance.
+#       Name: !Join ['', [!Ref 'Ec2Instance', ., !Ref 'AWS::Region', ., !Ref 'HostedZone', .]]
+#       Type: A
+#       TTL: '900'
+#       ResourceRecords:
+#       - !GetAtt Ec2Instance.PublicIp
+module Jets::Resource::Route53
+  class RecordSet < Jets::Resource::Base
+    def definition
+      {
+        dns_record: {
+          type: "AWS::Route53::RecordSet",
+          properties: record_set_properties
+        }
+      }
+    end
+
+    def record_set_properties
+      base = {
+        comment: "DNS record managed by Jets",
+        name: name,
+      }
+      hosted_zone_id = Jets.config.domain.hosted_zone_id
+      if hosted_zone_id
+        base[:hosted_zone_id] = hosted_zone_id
+      else
+        base[:hosted_zone_name] = hosted_zone_name
+      end
+
+      if Jets.config.domain.apex
+        base.merge(
+          alias_target: {
+            dns_name: cname,
+            hosted_zone_id: domain_name_hosted_zone,
+          },
+          type: "A",
+        )
+      else
+        base.merge({
+          type: "CNAME",
+          ttl: "60",
+          resource_records: [cname],
+        })
+      end
+    end
+
+    def domain_name_hosted_zone
+      if endpoint_types.include?("REGIONAL")
+        "!GetAtt DomainName.RegionalHostedZoneId"
+      else
+        "!GetAtt DomainName.DistributionHostedZoneId"
+      end
+    end
+
+    def cname
+      if endpoint_types.include?("REGIONAL")
+        "!GetAtt DomainName.RegionalDomainName"
+      else
+        "!GetAtt DomainName.DistributionDomainName"
+      end
+    end
+
+    def domain_name
+      Jets::Resource::ApiGateway::DomainName.new
+    end
+    memoize :domain_name
+
+    def endpoint_types
+      domain_name.endpoint_types
+    end
+
+    # IE: demo-dev.mydomain.com
+    def name
+      # Weird looking but correct: domain_name is object and domain_name is also method
+      domain_name.domain_name
+    end
+
+    # IE: mydomain.com
+    def hosted_zone_name
+      name = Jets.config.domain.hosted_zone_name
+      name.ends_with?('.') ? name : "#{name}." # add trailing period if missing
+    end
+
+    def outputs
+      {
+        "DnsRecord" => "!Ref DnsRecord",
+      }
+    end
+  end
+end

data/lib/jets/resource/s3/bucket.rb

@@ -0,0 +1,24 @@
+module Jets::Resource::S3
+  class Bucket < Jets::Resource::Base
+    attr_reader :bucket_logical_id
+    def initialize(props={})
+      @props = props # associated_properties from dsl.rb
+      @bucket_logical_id = props.delete(:logical_id) || "{namespace}_s3_bucket"
+    end
+
+    def definition
+      {
+        bucket_logical_id => {
+          type: "AWS::S3::Bucket",
+          properties: @props,
+        }
+      }
+    end
+
+    def outputs
+      {
+        bucket_logical_id => "!Ref #{bucket_logical_id.to_s.camelize}",
+      }
+    end
+  end
+end

data/lib/jets/resource/sns/subscription.rb

@@ -0,0 +1,29 @@
+# CloudFormation SNS Subscription docs: https://amzn.to/2SJtN3C
+module Jets::Resource::Sns
+  class Subscription < Jets::Resource::Base
+    def initialize(props={})
+      @props = props # associated_properties from dsl.rb
+    end
+
+    def definition
+      {
+        subscription_logical_id => {
+          type: "AWS::SNS::Subscription",
+          properties: merged_properties,
+        }
+      }
+    end
+
+    # Do not name this method properties, that is a computed method of `Jets::Resource::Base`
+    def merged_properties
+      {
+        endpoint: "!GetAtt {namespace}LambdaFunction.Arn",
+        protocol: "lambda",
+      }.deep_merge(@props)
+    end
+
+    def subscription_logical_id
+      "{namespace}_sns_subscription"
+    end
+  end
+end

data/lib/jets/resource/sns/topic.rb

@@ -0,0 +1,35 @@
+# CloudFormation SNS Topic docs: https://amzn.to/2MYbUZc
+module Jets::Resource::Sns
+  class Topic < Jets::Resource::Base
+    def initialize(props={})
+      @props = props # associated_properties from dsl.rb
+    end
+
+    def definition
+      {
+        topic_logical_id => {
+          type: "AWS::SNS::Topic",
+          properties: merged_properties,
+        }
+      }
+    end
+
+    # Do not name this method properties, that is a computed method of `Jets::Resource::Base`
+    def merged_properties
+      display_name = "{namespace} Topic"[0..99] # limit is 100 chars
+      {
+        display_name: display_name,
+        # Not setting subscription this way but instead with a SNS::Subscription resource so the interface
+        # is consistent. Leaving comment in here to remind me and in case decide to change this.
+        # subscription: [
+        #   endpoint: "!GetAtt {namespace}LambdaFunction.Arn",
+        #   protocol: "lambda"
+        # ]
+      }.deep_merge(@props)
+    end
+
+    def topic_logical_id
+      "{namespace}_sns_topic"
+    end
+  end
+end

data/lib/jets/resource/sns/topic_policy.rb

@@ -0,0 +1,40 @@
+# CloudFormation SNS TopicPolicy docs: https://amzn.to/2SBMq9v
+module Jets::Resource::Sns
+  class TopicPolicy < Jets::Resource::Base
+    def initialize(props={})
+      @props = props # associated_properties from dsl.rb
+    end
+
+    def definition
+      {
+        policy_logical_id => {
+          type: "AWS::SNS::TopicPolicy",
+          properties: merged_properties,
+        }
+      }
+    end
+
+    # Do not name this method properties, that is a computed method of `Jets::Resource::Base`
+    def merged_properties
+      {
+        policy_document: {
+          version: "2012-10-17",
+          statement: {
+            effect: "Allow",
+            principal: { service: "s3.amazonaws.com"},
+            action: "sns:Publish",
+            resource: "*", # TODO: figure out good syntax to limit easily
+            # Condition:
+            #   ArnLike:
+            #     aws:SourceArn: arn:aws:s3:::aa-test-95872017
+          }
+        },
+        topics: ["!Ref {namespace}SnsTopic"],
+      }.deep_merge(@props)
+    end
+
+    def policy_logical_id
+      "{namespace}_sns_topic_policy"
+    end
+  end
+end

data/lib/jets/resource/sqs/queue.rb

@@ -0,0 +1,21 @@
+# CloudFormation SQS Queue docs: https://amzn.to/2MVWk0j
+module Jets::Resource::Sqs
+  class Queue < Jets::Resource::Base
+    def initialize(props={})
+      @props = props # associated_properties from dsl.rb
+    end
+
+    def definition
+      {
+        queue_logical_id => {
+          type: "AWS::SQS::Queue",
+          properties: @props,
+        }
+      }
+    end
+
+    def queue_logical_id
+      "{namespace}_sqs_queue"
+    end
+  end
+end