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

data/lib/jets/processors/main_processor.rb

@@ -0,0 +1,61 @@
+require 'json'
+require 'stringio'
+
+# Node shim calls this class to process both controllers and jobs
+class Jets::Processors::MainProcessor
+  attr_reader :event, :context, :handler
+  def initialize(event, context, handler)
+    @event = event
+    @context = context
+    @handler = handler
+  end
+
+  def run
+    # Use the handler to deduce app code to run.
+    # Example handlers: handlers/controllers/posts.create, handlers/jobs/sleep.perform
+    #
+    #   deducer = Jets::Processors::Deducer.new("handlers/controllers/posts.create")
+    #
+    deducer = Jets::Processors::Deducer.new(handler)
+    begin
+      # Examples:
+      #   deducer.code => PostsController.process(event, context, "show")
+      #   deducer.path => app/controllers/posts_controller.rb
+      #
+      #   deducer.code => HardJob.process(event, context, "dig")
+      #   deducer.path => app/jobs/hard_job.rb
+      #
+      #   deducer.code => HelloFunction.process(event, context, "world")
+      #   deducer.path => app/functions/hello.rb
+      deducer.load_class
+      # result = PostsController.process(event, context, "create")
+      result = instance_eval(deducer.code, deducer.path)
+      result = HashWithIndifferentAccess.new(result) if result.is_a?(Hash)
+
+      Jets.increase_call_count
+
+      if result.is_a?(Hash) && result["headers"]
+        # API Gateway is okay with the header values as Integers but
+        # ELBs are more strict about this and require the header values to be Strings
+        result["headers"]["x-jets-call-count"] = Jets.call_count.to_s
+        result["headers"]["x-jets-prewarm-count"] = Jets.prewarm_count.to_s
+      end
+
+      result
+    rescue Exception => e
+      unless Jets.env.test?
+        # Customize error message slightly so nodejs shim can process the
+        # returned error message.
+        # The "RubyError: " is a marker that the javascript shim scans for.
+        $stderr.puts("RubyError: #{e.class}: #{e.message}") # js needs this as the first line
+        backtrace = e.backtrace.map {|l| "  #{l}" }
+        $stderr.puts(backtrace)
+        # No need to having error in stderr above anymore because errors are handled in memory
+        # at ruby_server.rb but keeping around for posterity.
+      end
+
+      Jets.on_exception(e)
+      raise(e) # raise error to ruby_server.rb to rescue and handle
+    end
+  end
+end

data/lib/jets/rack_server.rb

@@ -0,0 +1,86 @@
+module Jets
+  class RackServer
+    def self.start(options={})
+      new(options).start
+    end
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def start
+      return unless File.exist?("#{rack_project}/config.ru")
+      puts "Starting additional rack server for the project under the rack subfolder..." if ENV['JETS_DEBUG']
+
+      if ENV['FOREGROUND']
+        serve
+        return
+      end
+
+      # Reaching here means we'll run the server in the background.
+      # Handle daemonzing ourselves because it keeps the stdout of the 2nd
+      # rack server. The rackup --daemonize option ends up hiding the output.
+      pid = Process.fork
+      if pid.nil?
+        # we're in the child process
+        serve
+      else
+        # we're in the parent process
+        Process.detach(pid) # dettached but still in the "foreground" since bin/rackup runs in the foreground
+      end
+    end
+
+    # Runs in the child process
+    def serve
+      # Note, looks like stopping jets server with Ctrl-C sends the TERM signal
+      # down to the sub bin/rackup command cleans up the child process fine.
+      Bundler.with_unbundled_env do
+        args = ''
+        # only forward the host option, port is always 9292 for simplicity
+        if @options[:host]
+          args << " --host #{@options[:host]}"
+        else
+          args << " --host 127.0.0.1" # using the default localhost is not starting up https://stackoverflow.com/questions/4356646/address-family-not-supported-by-protocol-family
+        end
+
+
+        command = "cd #{rack_project} && bin/rackup#{args}" # leads to the same wrapper rack scripts
+        puts "=> #{command}".color(:green)
+        system(command)
+      end
+    end
+
+    # blocks until rack server is up
+    def wait_for_socket
+      return unless Jets.rack?
+
+      retries = 0
+      max_retries = 30 # 15 seconds at a delay of 0.5s
+      delay = 0.5
+      if ENV['C9_USER'] # overrides for local testing
+        max_retries = 3
+        delay = 3
+      end
+      begin
+        server = TCPSocket.new('localhost', 9292)
+        server.close
+      rescue Errno::ECONNREFUSED, Errno::EAFNOSUPPORT
+        puts "Unable to connect to localhost:9292. Delay for #{delay} and will try to connect again."  if ENV['JETS_DEBUG']
+        sleep(delay)
+        retries += 1
+        if retries < max_retries
+          retry
+        else
+          puts "Giving up on trying to connect to localhost:9292"
+          return false
+        end
+      end
+      puts "Connected to localhost:9292 successfully"
+      true
+    end
+
+    def rack_project
+      "#{Jets.root}/rack"
+    end
+  end
+end

data/lib/jets/rdoc.rb

@@ -0,0 +1,30 @@
+module Jets
+  module Rdoc
+    # Use for both jets.gemspec and rake rdoc task
+    def options
+      exclude = %w[
+        docs
+        spec
+        vendor
+        core.rb
+        .js
+        templates
+        commands
+        internal
+        support
+        Dockerfile
+        Dockerfile.base
+        Gemfile
+        Gemfile.lock
+        Guardfile
+        LICENSE
+        Procfile
+        Rakefile
+        bin
+      ]
+      exclude = exclude.map { |word| ['-x', word] }.flatten
+      ["-m", "README.md", "--markup", "tomdoc"] + exclude
+    end
+    extend self
+  end
+end

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

@@ -0,0 +1,82 @@
+module Jets::Resource::ApiGateway
+  class Authorizer < Jets::Resource::Base
+    def initialize(props={})
+      @props = props # associated_properties from dsl.rb
+    end
+
+    def definition
+      {
+        authorizer_logical_id => {
+          type: "AWS::ApiGateway::Authorizer",
+          properties: props,
+        }
+      }
+    end
+
+    def props
+      default = {
+        # authorizer_credentials: '',
+        # authorizer_result_ttl_in_seconds: '',
+        # auth_type: '',
+        # identity_source: '', # required
+        # identity_validation_expression: '',
+        # name: '',
+        # provider_arns: [],
+        rest_api_id: '!Ref RestApi', # Required: Yes
+        type: '', # Required: Yes
+      }
+
+      unless @props[:type].to_s.upcase == 'COGNITO_USER_POOLS'
+        @props[:authorizer_uri] = { # Required: Conditional
+          "Fn::Join" => ['', [
+            'arn:aws:apigateway:',
+            "!Ref 'AWS::Region'",
+            ':lambda:path/2015-03-31/functions/',
+            {"Fn::GetAtt" => ["{namespace}LambdaFunction", "Arn"]},
+            '/invocations'
+          ]]
+        }
+      end
+      @props[:authorizer_result_ttl_in_seconds] = @props.delete(:ttl) if @props[:ttl]
+
+      normalize_type!(@props)
+      normalize_identity_source!(@props)
+      default.merge(@props)
+    end
+
+    def authorizer_logical_id
+      "{namespace}_authorizer" # IE: protect_authorizer
+    end
+
+    def outputs
+      # IE: ProtectAuthorizer: !Ref ProtectAuthorizer
+      {
+        logical_id => "!Ref #{logical_id}",
+      }
+    end
+
+  private
+    # Also sets a default if it's not provided
+    def normalize_type!(props)
+      type = props[:type] || :request
+      @props[:type] = type.to_s.upcase
+    end
+
+    # Also sets a default if it's not provided
+    def normalize_identity_source!(props)
+      identity_source = props[:identity_source] || Jets.config.api.authorizers.default_token_source
+      # request authorizer type can have multiple identity sources.
+      # token authorizer type has only one identity source.
+      # We handle both cases.
+      identity_sources = identity_source.split(',') # to handle multipe
+      identity_sources.map! do |source|
+        if source.include?(".") # if '.' is detected assume full identify source provided
+          source
+        else
+          "method.request.header.#{source}" # convention
+        end
+      end
+      @props[:identity_source] = identity_sources.join(',')
+    end
+  end
+end

data/lib/jets/resource/api_gateway/base_path/function.rb

@@ -0,0 +1,49 @@
+module Jets::Resource::ApiGateway::BasePath
+  class Function < Jets::Resource::Base
+    include Jets::Resource::Lambda::Function::Environment
+
+    def definition
+      {
+        base_path_function: {
+          type: "AWS::Lambda::Function",
+          properties: {
+            function_name: function_name,
+            code: {
+              s3_bucket: "!Ref S3Bucket",
+              s3_key: code_s3_key,
+            },
+            role: "!GetAtt BasePathRole.Arn",
+            handler: handler,
+            runtime: Jets.ruby_runtime,
+            timeout: 60,
+            memory_size: 1536,
+            environment: env_properties[:environment],
+            layers: layers,
+          }
+        }
+      }
+    end
+
+    def layers
+      return Jets.config.lambda.layers if Jets.config.gems.disable
+
+      ["!Ref GemLayer"] + Jets.config.lambda.layers
+    end
+
+    def function_name
+      method = "jets-base-path"
+      # need to add the deployment timestamp because or else function name collides between deploys
+      timestamp = Jets::Resource::ApiGateway::Deployment.timestamp
+      "#{Jets.config.project_namespace}-#{method}-#{timestamp}"
+    end
+
+    def handler
+      "handlers/functions/jets/base_path.lambda_handler"
+    end
+
+    def code_s3_key
+      checksum = Jets::Builders::Md5.checksums["stage/code"]
+      "jets/code/code-#{checksum}.zip" # s3_key
+    end
+  end
+end

data/lib/jets/resource/api_gateway/base_path/mapping.rb

@@ -0,0 +1,44 @@
+# CloudFormation Docs AWS::ApiGateway::DomainName: https://amzn.to/2BsrSqo
+#
+# Example:
+#
+#   Type: AWS::ApiGateway::BasePathMapping
+#   Properties:
+#     BasePath: String
+#     DomainName: String
+#     RestApiId: String
+#     Stage: String
+#
+# Currently unable to add base path mapping in-place with CloudFormation.
+# The workaround for this is to do it post deployment with raw API calls outside
+# of CloudFormation.  Leaving this around for now in case there's a workaround
+# to get this into CloudFormation instead of raw API calls. Some notes:
+#   * Also tried to change the domain name of to something like demo-dev-[random].mydomain.com
+#   That does not work because the domain name has to match the route53 record exactly.
+#
+module Jets::Resource::ApiGateway::BasePath
+  class Mapping < Jets::Resource::Base
+    def definition
+      function_logical_id = "BasePathFunction" # lambda function that supports custom resource
+      {
+        base_path_mapping: {
+          type: "Custom::BasePathMapping",
+          properties: {
+            service_token: "!GetAtt #{function_logical_id}.Arn",
+            # base_path: '', # empty path represents root
+            # domain_name: "!Ref DomainName",
+            # rest_api_id: "!Ref RestApi", # since this is in the Deployment template
+            # stage: Deployment.stage_name,
+          },
+          depends_on: Jets::Resource::ApiGateway::Deployment.logical_id,
+        }
+      }
+    end
+
+    def outputs
+      {
+        "BasePathMapping" => "!Ref BasePathMapping",
+      }
+    end
+  end
+end

data/lib/jets/resource/api_gateway/base_path/role.rb

@@ -0,0 +1,76 @@
+module Jets::Resource::ApiGateway::BasePath
+  class Role < Jets::Resource::Base
+    extend Memoist
+    include Jets::AwsServices
+
+    def definition
+      {
+        base_path_role: {
+          type: "AWS::IAM::Role",
+          properties: {
+            role_name: role_name,
+            path: "/",
+            assume_role_policy_document: {
+              version: "2012-10-17",
+              statement: [{
+                effect: "Allow",
+                principal: {service: ["lambda.amazonaws.com"]},
+                action: ["sts:AssumeRole"]}
+              ]
+            },
+            policies: [
+              policy_name: "#{role_name}-policy",
+              policy_document: policy_document,
+            ]
+          },
+        }
+      }
+    end
+
+    def policy_document
+      project_namespace = Jets.config.project_namespace
+      default_policy_statements = Jets::Application.default_iam_policy # Array of Hashes
+      apigateway = [{
+        action: [ "apigateway:*" ],
+        effect: "Allow",
+        resource: "arn:aws:apigateway:#{Jets.aws.region}::/restapis/*", # scoped to all restapis because this changes
+      },{
+        action: [ "apigateway:*" ],
+        effect: "Allow",
+        resource: "arn:aws:apigateway:#{Jets.aws.region}::/domainnames/*", # scoped to all restapis because this changes
+      }]
+      cloudformation = [{
+        action: ["cloudformation:DescribeStacks"],
+        effect: "Allow",
+        resource: "arn:aws:cloudformation:#{Jets.aws.region}:#{Jets.aws.account}:stack/#{project_namespace}*",
+      }]
+
+      # Combine the statements
+      {
+        version: '2012-10-17',
+        statement: default_policy_statements + apigateway + cloudformation
+      }
+    end
+
+    # Duplicated in rest_api/change_detection.rb, base_path/role.rb, rest_api/routes.rb
+    def rest_api_id
+      stack_name = Jets::Naming.parent_stack_name
+      return "RestApi" unless stack_exists?(stack_name)
+
+      stack = cfn.describe_stacks(stack_name: stack_name).stacks.first
+
+      api_gateway_stack_arn = lookup(stack[:outputs], "ApiGateway")
+
+      # resources = cfn.describe_stack_resources(stack_name: api_gateway_stack_arn).stack_resources
+      stack = cfn.describe_stacks(stack_name: api_gateway_stack_arn).stacks.first
+      rest_api_id = lookup(stack[:outputs], "RestApi")
+    end
+    memoize :rest_api_id
+
+    def role_name
+      # TODO: dont think we should change the role name every time but have to right now because the deployment logical id changes
+      timestamp = Jets::Resource::ApiGateway::Deployment.timestamp
+      "#{Jets.config.project_namespace}-base-path-mapping-#{timestamp}"
+    end
+  end
+end

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

@@ -0,0 +1,61 @@
+module Jets::Resource::ApiGateway
+  # Might be weird inheriting from Method because Method has Method#cors also
+  # but Cors is essentially a Method class.
+  class Cors < Method
+    def definition
+      {
+        cors_logical_id => {
+          type: "AWS::ApiGateway::Method",
+
+          properties: {
+            resource_id: "!Ref #{resource_id}",
+            rest_api_id: "!Ref #{RestApi.logical_id}",
+            authorization_type: cors_authorization_type,
+            http_method: "OPTIONS",
+            method_responses: [{
+              status_code: '200',
+              response_parameters: response_parameters(true),
+              response_models: {},
+            }],
+            request_parameters: {},
+            integration: {
+              type: "MOCK",
+              request_templates: {
+                "application/json": "{statusCode:200}",
+              },
+              integration_responses: [{
+                status_code: '200',
+                response_parameters: response_parameters,
+                response_templates: {
+                  "application/json": '',
+                },
+              }] # closes integration_responses
+            } # closes integration
+          } # closes properties
+        } # closes logical id
+      } # closes definition
+    end
+
+    def response_parameters(method_response=false)
+      cors_headers.map do |k,v|
+        k = "method.response.header.#{k}"
+        v = method_response ? true : "'#{v}'" # surround value with single quotes
+        [k,v]
+      end.to_h
+    end
+
+    # Always the pre-flight headers in this case
+    def cors_headers
+      rack = Jets::Controller::Middleware::Cors.new(Jets.application)
+      rack.cors_headers(true)
+    end
+
+    def cors_authorization_type
+      Jets.config.api.cors_authorization_type || @route.authorization_type || "NONE"
+    end
+
+    def cors_logical_id
+      "#{resource_logical_id}_cors_api_method"
+    end
+  end
+end

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

@@ -0,0 +1,80 @@
+module Jets::Resource::ApiGateway
+  class Deployment < Jets::Resource::Base
+    def definition
+      {
+        deployment_logical_id => {
+          type: "AWS::ApiGateway::Deployment",
+          properties: {
+            description: "Version #{timestamp} deployed by jets",
+            rest_api_id: "!Ref #{RestApi.logical_id}",
+            stage_name: stage_name,
+          }
+        }
+      }
+    end
+
+    def parameters
+      p = {
+        "GemLayer" => "GemLayer",
+        "IamRole" => "IamRole",
+        "RestApi" => "RestApi",
+        "S3Bucket" => "S3Bucket",
+      }
+      p[:DomainName] = "DomainName" if Jets.custom_domain?
+      p[:BasePath] = "BasePath" unless Jets.config.domain.base_path.nil?
+      p
+    end
+
+    def outputs(internal=false)
+      rest_api = internal ? RestApi.internal_logical_id : "RestApi"
+      {
+        "RestApiUrl" => "!Sub 'https://${#{rest_api}}.execute-api.${AWS::Region}.amazonaws.com/#{stage_name}/'",
+      }
+    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)
+
+        regexp = Regexp.new(".*#{Jets.config.project_namespace}-")
+        controller_name = path.sub(regexp, '').sub('.yml', '')
+        # map the path to a camelized logical_id. Example:
+        #   /tmp/jets/demo/templates/demo-dev-2-posts_controller.yml to
+        #   PostsController
+        controller_logical_id = controller_name.underscore.camelize
+
+        controller_logical_ids << controller_logical_id
+      end
+      controller_logical_ids
+    end
+
+    # stage_name: dev, dev-1, dev-2, etc
+    def stage_name
+      self.class.stage_name
+    end
+
+    def self.stage_name
+      # Stage name only allows a-zA-Z0-9_
+      [Jets.config.short_env, Jets.config.env_extra].compact.join('_').gsub('-','_')
+    end
+
+    def timestamp
+      self.class.timestamp
+    end
+
+    @@timestamp = nil
+    def self.timestamp
+      @@timestamp ||= Time.now.strftime("%Y%m%d%H%M%S")
+    end
+
+    def deployment_logical_id
+      self.class.logical_id.underscore
+    end
+
+    def self.logical_id
+      "ApiDeployment#{timestamp}"
+    end
+  end
+end

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

@@ -0,0 +1,65 @@
+# CloudFormation Docs AWS::ApiGateway::DomainName: https://amzn.to/2Bsnmbq
+#
+# Example:
+#
+#   MyDomainName:
+#     Type: 'AWS::ApiGateway::DomainName'
+#     Properties:
+#       DomainName: api.mydomain.com
+#       CertificateArn: arn:aws:acm:us-east-1:111122223333:certificate/fb1b9770-a305-495d-aefb-27e5e101ff3
+#
+module Jets::Resource::ApiGateway
+  class DomainName < Jets::Resource::Base
+    def definition
+      properties = {
+        domain_name: domain_name,
+        endpoint_configuration: {
+          types: endpoint_types
+        }
+      }
+      # Can really only be REGIONAL or EDGE
+      if endpoint_types.include?("REGIONAL")
+        properties[:regional_certificate_arn] = cert_arn
+      end
+      if endpoint_types.include?("EDGE")
+        properties[:certificate_arn] = cert_arn
+      end
+
+      {
+        domain_name: {
+          type: "AWS::ApiGateway::DomainName",
+          properties: properties
+        }
+      }
+    end
+
+    def outputs
+      {
+        "DomainName" => "!Ref DomainName",
+      }
+    end
+
+    def domain_name
+      name = Jets.config.domain.name
+      if Jets.config.domain.apex
+        name ||= Jets.config.domain.hosted_zone_name
+      else
+        subdomain = Jets.project_namespace
+        managed_domain_name = "#{subdomain}.#{Jets.config.domain.hosted_zone_name}"
+        name ||= managed_domain_name
+      end
+
+      # Strip trailing period if there is one set accidentally or else get this error
+      #   Trailing period should be omitted from domain name (Service: AmazonApiGateway; Status Code: 400; Error Code: BadRequestException
+      name.sub(/\.$/,'')
+    end
+
+    def endpoint_types
+      [Jets.config.domain.endpoint_type].flatten
+    end
+
+    def cert_arn
+      Jets.config.domain.cert_arn
+    end
+  end
+end

data/lib/jets/resource/api_gateway/method/authorization.rb

@@ -0,0 +1,41 @@
+class Jets::Resource::ApiGateway::Method
+  module Authorization
+  private
+    def authorizer_id
+      if @route.authorizer
+        logical_id = @route.authorizer_id
+      elsif controller_klass.authorizer
+        logical_id = controller_klass.authorizer_logical_id_for(@route.action_name)
+      end
+
+      "!Ref #{logical_id}" if logical_id
+    end
+
+    def authorization_type
+      type = @route.authorization_type ||
+             controller_klass.authorization_type || # Already handles inheritance via class_attribute, applies controller-wide
+             controller_klass.infer_authorization_type_for(@route.action_name) || # Applies specifically to route
+             Jets.config.api.authorization_type
+      type.to_s.upcase
+    end
+
+    def api_key_required?
+      api_key_required == true
+    end
+
+    def api_key_required
+      @route.api_key_required ||
+        controller_klass.api_key_required ||
+        Jets.config.api.api_key_required
+    end
+
+    def authorization_scopes
+      if @route.authorization_scopes
+        authorization_scopes = @route.authorization_scopes
+      elsif controller_klass.authorization_scopes
+        authorization_scopes = controller_klass.authorization_scopes
+      end
+      authorization_scopes
+    end
+  end
+end