jets 1.1.5 → 1.2.0

data/lib/jets/controller/rack/adapter.rb

@@ -1,3 +1,5 @@
+require 'base64'
+
 module Jets::Controller::Rack
   class Adapter
     extend Memoist
@@ -21,15 +23,16 @@ module Jets::Controller::Rack
     end
 
     def env
-      Env.new(@event, @context).convert # convert to Rack env
+      Env.new(@event, @context, adapter: true).convert # convert to Rack env
     end
     memoize :env
 
     # Transform the structure to AWS_PROXY compatiable structure
     # http://docs.aws.amazon.com/apigateway/latest/developerguide/set-up-lambda-proxy-integrations.html#api-gateway-simple-proxy-for-lambda-output-format
     def convert_to_api_gateway(status, headers, body)
-      base64 = headers["x-jets-base64"] == 'true'
+      base64 = headers["x-jets-base64"] == 'yes'
       body = body.respond_to?(:read) ? body.read : body
+      body = Base64.encode64(body) if base64
       {
         "statusCode" => status,
         "headers" => headers,

data/lib/jets/controller/rack/env.rb

@@ -1,11 +1,12 @@
 require 'rack'
+require 'base64'
 
 # Takes an ApiGateway event and converts it to an Rack env that can be used for
 # rack.call(env).
 module Jets::Controller::Rack
   class Env
-    def initialize(event, context)
-      @event, @context = event, context
+    def initialize(event, context, options={})
+      @event, @context, @options = event, context, options
     end
 
     def convert
@@ -13,7 +14,12 @@ module Jets::Controller::Rack
       options = add_top_level(options)
       options = add_http_headers(options)
       path = @event['path'] || '/' # always set by API Gateway but might not be when testing shim, so setting it to make testing easier
-      Rack::MockRequest.env_for(path, options)
+      env = Rack::MockRequest.env_for(path, options)
+      if @options[:adapter]
+        env['adapter.event'] = @event
+        env['adapter.context'] = @context
+      end
+      env
     end
 
   private
@@ -35,10 +41,7 @@ module Jets::Controller::Rack
 
       map['CONTENT_LENGTH'] = content_length if content_length
       # Even if not set, Rack always assigns an StringIO to "rack.input"
-      map[:input] = StringIO.new(body) if body
-
-      # TODO: handle decoding base64 encoded body from API Gateaway
-      # Will need to make sure that pass the base64 info via a request header
+      map['rack.input'] = StringIO.new(body) if body
 
       options.merge(map)
     end
@@ -52,8 +55,14 @@ module Jets::Controller::Rack
       headers['Content-Length'] || bytesize
     end
 
+    # Decoding base64 from API Gateaway if necessary
+    # Rack will be none the wiser
     def body
-      @event['body']
+      if @event['isBase64Encoded']
+        Base64.decode64(@event['body'])
+      else
+        @event['body']
+      end
     end
 
     def add_http_headers(options)

data/lib/jets/controller/renderers/rack_renderer.rb

@@ -17,7 +17,7 @@ module Jets::Controller::Renderers
       headers = cors_headers.merge(headers)
       headers["Content-Type"] ||= @options[:content_type] || Jets::Controller::DEFAULT_CONTENT_TYPE
       # x-jets-base64 to convert this Rack triplet to a API Gateway hash structure later
-      headers["x-jets-base64"] = base64 ? "true" : "false"
+      headers["x-jets-base64"] = base64 ? 'yes' : 'no' # headers values must be Strings
       body = StringIO.new(body)
       [status, headers, body] # triplet
     end

data/lib/jets/controller/rendering.rb

@@ -71,7 +71,10 @@ class Jets::Controller
     end
 
     def url_for(url)
-      add_stage_name(url)
+      # No longer need to add stage name, think this is due to rack middleware support
+      # Leaving in as comment for now just in case.
+      # add_stage_name(url)
+      url
     end
 
     def actual_host

data/lib/jets/core.rb

@@ -1,22 +1,9 @@
-require 'active_support/dependencies'
-require 'memoist'
-
 module Jets::Core
   extend Memoist
 
-  # Calling application triggers load of configs.
-  # Jets' the default config/application.rb is loaded,
-  # then the project's config/application.rb is loaded.
-  @@application = nil
   def application
-    return @@application if @@application
-
-    @@application = Jets::Application.instance
-    @@application.setup!
-    @@application
+    Jets::Application.instance
   end
-  # For some reason memoize doesnt work with application, think there's
-  # some circular dependency issue. Figure this out later.
 
   def config
     application.config
@@ -123,7 +110,7 @@ module Jets::Core
   def eager_load_app
     Dir.glob("#{Jets.root}app/**/*.rb").select do |path|
       next if !File.file?(path) or path =~ %r{/javascript/} or path =~ %r{/views/}
-      next if path.include?('app/functions') || path.include?('app/shared/functions')
+      next if path.include?('app/functions') || path.include?('app/shared/functions') || path.include?('app/internal/functions')
 
       class_name = path
                     .sub(/\.rb$/,'') # remove .rb
@@ -177,9 +164,14 @@ module Jets::Core
 
   def report_exception(exception)
     Jets::Turbine.subclasses.each do |subclass|
-      subclass.exception_reporters.each do |label, block|
+      reporters = subclass.exception_reporters || []
+      reporters.each do |label, block|
         block.call(exception)
       end
     end
   end
+
+  def custom_domain?
+    Jets.config.domain.hosted_zone_name
+  end
 end

data/lib/jets/internal/app/functions/jets/base_path.rb

@@ -0,0 +1,153 @@
+require 'aws-sdk-apigateway'
+require 'aws-sdk-cloudformation'
+
+STAGE_NAME = "<%= @stage_name %>"
+
+def lambda_handler(event:, context:)
+  puts("event['RequestType'] #{event['RequestType']}")
+  puts("event: #{JSON.dump(event)}")
+  puts("context: #{JSON.dump(context)}")
+  puts("context.log_stream_name #{context.log_stream_name.inspect}")
+
+  mimic = event['ResourceProperties']['Mimic']
+  physical_id = event['ResourceProperties']['PhysicalId'] || "PhysicalId"
+
+  puts "mimic: #{mimic}"
+  puts "physical_id: #{physical_id}"
+
+  if event['RequestType'] == 'Delete'
+    if mimic == 'FAILED'
+      send_response(event, context, "FAILED")
+    else
+      mapping = BasePathMapping.new(event)
+      mapping.delete(true) if mapping.should_delete?
+      send_response(event, context, "SUCCESS")
+    end
+    return # early return
+  end
+
+  mapping = BasePathMapping.new(event)
+  mapping.update
+
+  response_status = mimic == "FAILED" ? "FAILED" : "SUCCESS"
+  response_data = { "Hello" => "World" }
+
+  send_response(event, context, response_status, response_data, physical_id)
+
+# We rescue all exceptions and send an message to CloudFormation so we dont have to
+# wait for over an hour for the stack operation to timeout and rollback.
+rescue Exception => e
+  puts e.message
+  puts e.backtrace
+  sleep 10 # provide delete to make sure that the log gets sent to CloudWatch
+  send_response(event, context, "FAILED")
+end
+
+def send_response(event, context, response_status, response_data={}, physical_id="PhysicalId")
+  response_body = JSON.dump(
+    Status: response_status,
+    Reason: "See the details in CloudWatch Log Stream: #{context.log_stream_name.inspect}",
+    PhysicalResourceId: physical_id,
+    StackId: event['StackId'],
+    RequestId: event['RequestId'],
+    LogicalResourceId: event['LogicalResourceId'],
+    Data: response_data
+  )
+
+  puts "RESPONSE BODY:\n"
+  puts response_body
+
+  url = event['ResponseURL']
+  uri = URI(url)
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.open_timeout = http.read_timeout = 30
+  http.use_ssl = true if uri.scheme == 'https'
+
+
+  # must used url to include the AWSAccessKeyId and Signature
+  req = Net::HTTP::Put.new(url) # url includes query string and uri.path does not, must used url t
+  req.body = response_body
+  req.content_length = response_body.bytesize
+
+  # set headers
+  req['content-type'] = ''
+  req['content-length'] = response_body.bytesize
+
+  res = http.request(req)
+  puts "status code: #{res.code}"
+  puts "headers: #{res.each_header.to_h.inspect}"
+  puts "body: #{res.body}"
+end
+
+
+class BasePathMapping
+  def initialize(event)
+    @event = event
+    @rest_api_id = get_rest_api_id
+    @domain_name = get_domain_name
+    @base_path = ''
+  end
+
+  def update
+    # Cannot use update_base_path_mapping to update the base_mapping because it doesnt
+    # allow us to change the rest_api_id. So we delete and create.
+    delete(true)
+    create
+  end
+
+  # Dont delete the newly created base path mapping unless this is an operation
+  # where we're fully deleting the stack
+  def should_delete?
+    deleting_parent?
+  end
+
+  def delete(fail_silently=false)
+    apigateway.delete_base_path_mapping(
+      domain_name: @domain_name, # required
+      base_path: '(none)',
+    )
+  rescue Aws::APIGateway::Errors::NotFoundException => e
+    raise(e) unless fail_silently
+  end
+
+  def create
+    apigateway.create_base_path_mapping(
+      domain_name: @domain_name, # required
+      base_path: @base_path,
+      rest_api_id: @rest_api_id, # required
+      stage: STAGE_NAME,
+    )
+  end
+
+  def get_domain_name
+    param = deployment_stack[:parameters].find { |p| p.parameter_key == 'DomainName' }
+    param.parameter_value
+  end
+
+  def deployment_stack
+    @deployment_stack ||= cfn.describe_stacks(stack_name: @event['StackId']).stacks.first
+  end
+
+  def get_rest_api_id
+    param = deployment_stack[:parameters].find { |p| p.parameter_key == 'RestApi' }
+    param.parameter_value
+  end
+
+  def deleting_parent?
+    stack = cfn.describe_stacks(stack_name: parent_stack_name).stacks.first
+    stack.stack_status == 'DELETE_IN_PROGRESS'
+  end
+
+  def parent_stack_name
+    deployment_stack[:root_id]
+  end
+
+private
+  def apigateway
+    @apigateway ||= Aws::APIGateway::Client.new
+  end
+
+  def cfn
+    @cfn ||= Aws::CloudFormation::Client.new
+  end
+end

data/lib/jets/klass.rb

@@ -28,12 +28,12 @@ class Jets::Klass
     # app/controllers, app/jobs, and app/functions.
     def from_path(path)
       class_name = class_name(path)
-
       if path.include?("/functions/") # simple function
-        load_anonymous_class(class_name, path)
+        class_name = load_anonymous_class(class_name, path)
+        class_name.constantize # removed :: for anonymous classes
+      else
+        class_name.constantize # autoload
       end
-
-      class_name.constantize # autoload or nothing if load_anonymous_class called
     end
 
     # app/controllers/posts_controller.rb => PostsController
@@ -61,15 +61,48 @@ class Jets::Klass
 
     @@loaded_anonymous_classes = []
     def load_anonymous_class(class_name, path)
+      parent_mod = modularize(class_name)
+
       constructor = Jets::Lambda::FunctionConstructor.new(path)
       # Dont load anonyomous class more than once to avoid these warnings:
       #   warning: already initialized constant Hello
       #   warning: previous definition of Hello was here
       unless @@loaded_anonymous_classes.include?(class_name)
         # use class_name as the variable name for prettier class name.
-        Object.const_set(class_name, constructor.build)
+        leaf_class_name = class_name.split('::').last
+        parent_mod.const_set(leaf_class_name, constructor.build)
         @@loaded_anonymous_classes << class_name
       end
+
+      class_name
+    end
+
+    # Ensures the parent namespace modules are defined. Example:
+    #
+    #   modularize("Foo::Bar::Test")
+    #   => Foo::Bar # is a now defined as a module if it wasnt before
+    #
+    # Also returns the parent module, so we can use it to do a const_set if needed. IE:
+    #
+    #   parent_mod = modularize("Foo::Bar::Test")
+    #   parent_mod.const_set("Test")
+    def modularize(class_name)
+      leaves = []
+      mods = class_name.split('::')[0..-2] # drop the last word
+      # puts "mods: #{mods}"
+      return Object if mods.empty?
+
+      leaves = []
+      mods.each do |leaf_mod|
+        leaves += [leaf_mod]
+        namespace = leaves.join('::')
+        previous_namespace = leaves[0..-2].join('::')
+        previous_namespace = "Object" if previous_namespace.empty?
+        previous_namespace = previous_namespace.constantize
+        previous_namespace.const_set(leaf_mod, Module.new) unless Object.const_defined?(namespace)
+      end
+
+      mods.join('::').constantize
     end
 
   end

data/lib/jets/lambda/dsl.rb

@@ -1,5 +1,3 @@
-require 'active_support/concern'
-
 # Other dsl that rely on this must implement
 #
 #   default_associated_resource_definition

data/lib/jets/mega/request.rb

@@ -3,6 +3,10 @@ require 'rack'
 
 module Jets::Mega
   class Request
+    autoload :Source, 'jets/mega/request/source'
+
+    extend Memoist
+
     def initialize(event, controller)
       @event = event
       @controller = controller # Jets::Controller instance
@@ -12,10 +16,10 @@ module Jets::Mega
       http_method = @event['httpMethod'] # GET, POST, PUT, DELETE, etc
       params = @controller.params(raw: true, path_parameters: false)
 
-      uri = URI("http://localhost:9292#{@controller.request.path}") # local rack server
+      uri = get_uri
+
       http = Net::HTTP.new(uri.host, uri.port)
-      http.open_timeout = 60
-      http.read_timeout = 60
+      http.open_timeout = http.read_timeout = 60
 
       # Rails sets _method=patch or _method=put as workaround
       # Falls back to GET when testing in lambda console
@@ -24,25 +28,23 @@ module Jets::Mega
 
       request_class = "Net::HTTP::#{http_class}".constantize # IE: Net::HTTP::Get
       request = request_class.new(uri.path)
+
+      # Set form data
       if %w[Post Patch Put].include?(http_class)
         params = HashConverter.encode(params)
         request.set_form_data(params)
       end
 
-      request = set_headers!(request)
+      # Set body info
+      request.body = source.body
+      request.content_length = source.content_length
 
-      # Setup body
-      env = Jets::Controller::Rack::Env.new(@event, {}).convert # convert to Rack env
-      source_request = Rack::Request.new(env)
-      if source_request.body.respond_to?(:read)
-        request.body = source_request.body.read
-        request.content_length = source_request.content_length.to_i
-        source_request.body.rewind
-      end
+      # Need to set headers after body and form_data for some reason
+      request = set_headers!(request)
 
+      # Make request
       response = http.request(request)
 
-      # TODO: handle binary
       {
         status: response.code.to_i,
         headers: response.each_header.to_h,
@@ -50,6 +52,35 @@ module Jets::Mega
       }
     end
 
+    def get_uri
+      url = "http://localhost:9292#{@controller.request.path}" # local rack server
+      unless @controller.query_parameters.empty?
+        # Thanks: https://stackoverflow.com/questions/798710/ruby-how-to-turn-a-hash-into-http-parameters
+        query_string = Rack::Utils.build_nested_query(@controller.query_parameters)
+        url += "?#{query_string}"
+      end
+      URI(url)
+    end
+
+    def source
+      Source.new(@event)
+    end
+    memoize :source
+
+    # Rails sets _method=patch or _method=put as workaround
+    # Falls back to GET when testing in lambda console
+    # @event['httpMethod'] is GET, POST, PUT, DELETE, etc
+    def http_class
+      http_class = params['_method'] || @event['httpMethod'] || 'GET'
+      http_class.capitalize!
+      http_class
+    end
+
+    def params
+      @controller.params(raw: true, path_parameters: false, body_parameters: true)
+    end
+    memoize :params
+
     # Set request headers. Forwards original request info from remote API gateway.
     # By this time, the server/api_gateway.rb middleware.
     def set_headers!(request)