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

data/lib/jets/mega/request/source.rb

@@ -0,0 +1,21 @@
+class Jets::Mega::Request
+  class Source
+    def initialize(event)
+      @event = event
+      env = Jets::Controller::Rack::Env.new(@event, {}).convert # convert to Rack env
+      @source_request = Rack::Request.new(env)
+    end
+
+    def body
+      if @source_request.body.respond_to?(:read)
+        body = @source_request.body.read
+        @source_request.body.rewind
+      end
+      body
+    end
+
+    def content_length
+      @source_request.content_length.to_i
+    end
+  end
+end

data/lib/jets/mega/request.rb

@@ -0,0 +1,163 @@
+require 'net/http'
+require 'rack'
+
+module Jets::Mega
+  class Request
+    JETS_OUTPUT = "/tmp/jets-output.log"
+
+    extend Memoist
+
+    def initialize(event, controller)
+      @event = event
+      @controller = controller # Jets::Controller instance
+    end
+
+    def proxy
+      http_method = @event['httpMethod'] # GET, POST, PUT, DELETE, etc
+      params = @controller.params(raw: true, path_parameters: false)
+
+      uri = get_uri
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      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
+      http_class = params['_method'] || http_method || 'GET'
+      http_class.capitalize!
+
+      request_class = "Net::HTTP::#{http_class}".constantize # IE: Net::HTTP::Get
+      request = request_class.new(uri)
+
+      # Set form data
+      if %w[Post Patch Put].include?(http_class)
+        params = HashConverter.encode(params)
+        request.set_form_data(params)
+      end
+
+      # Set body info
+      request.body = source.body
+      request.content_length = source.content_length
+
+      # Need to set headers after body and form_data for some reason
+      request = set_headers!(request)
+
+      # Make request
+      response = send_request(http, request)
+
+      puts_rack_output
+
+      status = response.code.to_i
+      headers = response.each_header.to_h
+      encoding = get_encoding(headers['content-type'])
+      body = response.body&.force_encoding(encoding)
+      {
+        status: status,
+        headers: headers,
+        body: body,
+      }
+    end
+
+    # Adds error handling in case the rack server has gone down. Will try to start the server back up if needed.
+    # Search CloudWatch logs for 'Unable to send request' to find for indication of this.
+    def send_request(http, request)
+      retries = 0
+      max_retries = 30 # 15 seconds at a delay of 0.5s
+      delay = 0.5
+
+      begin
+        http.request(request) # response
+      rescue Errno::ECONNREFUSED, Errno::EAFNOSUPPORT
+        puts "Unable to send request to localhost:9292. Will try to start the server with a delay of #{delay} and try again."
+        Jets.start_rack_server
+
+        sleep(delay)
+        retries += 1
+        if retries < max_retries
+          retry
+        else
+          puts "Giving up on trying to send request to localhost:9292"
+          raise # re-raise error
+        end
+      end
+    end
+
+    def get_encoding(content_type)
+      default = Jets.config.encoding.default
+      return default unless content_type
+
+      md = content_type.match(/charset=(.+)/)
+      return default unless md
+
+      md[1]
+    end
+
+    # Grab the rack output from the /tmp/jets-output.log and puts it back in the
+    # main process' stdout
+    def puts_rack_output
+      return unless File.exist?(JETS_OUTPUT)
+      puts IO.readlines(JETS_OUTPUT)
+      File.truncate(JETS_OUTPUT, 0)
+    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)
+      headers = @event['headers'] # from api gateway
+      if headers # remote API Gateway
+        # Forward headers from API Gateway over to the sub http request.
+        # It's important to forward the headers. Here are some examples:
+        #
+        #   "Turbolinks-Referrer"=>"http://localhost:8888/posts/122",
+        #   "Referer"=>"http://localhost:8888/posts/122",
+        #   "Accept-Encoding"=>"gzip, deflate",
+        #   "Accept-Language"=>"en-US,en;q=0.9,pt;q=0.8",
+        #   "Cookie"=>"_demo_session=...",
+        #   "If-None-Match"=>"W/\"9fa479205fc6d24ca826d46f1f6cf461\"",
+        headers.each do |k,v|
+          request[k] = v
+        end
+
+        # Note by the time headers get to rack later in the they get changed to:
+        #
+        #   request['X-Forwarded-Host'] vs env['HTTP_X_FORWARDED_HOST']
+        #
+        request['X-Forwarded-For'] = headers['X-Forwarded-For'] # "1.1.1.1, 2.2.2.2" # can be comma separated list
+        request['X-Forwarded-Host'] = headers['Host'] # uhghn8z6t1.execute-api.us-east-1.amazonaws.com
+        request['X-Forwarded-Port'] = headers['X-Forwarded-Port'] # 443
+        request['X-Forwarded-Proto'] = headers['X-Forwarded-Proto'] # https # scheme
+      end
+
+      request
+    end
+  end
+end

data/lib/jets/middleware/configurator.rb

@@ -0,0 +1,84 @@
+# Based on Rails MiddlewareStackProxy
+#
+# Configurator is a recorder for the Jets middleware stack that allows
+# you to configure middlewares in your application. It works basically as a
+# command recorder, saving each command to be applied after initialization
+# over the default middleware stack, so you can add, swap, or remove any
+# middleware in Jets.
+#
+# You can add your own middlewares by using the +config.middleware.use+ method:
+#
+#     config.middleware.use Magical::Unicorns
+#
+# This will put the <tt>Magical::Unicorns</tt> middleware on the end of the stack.
+# You can use +insert_before+ if you wish to add a middleware before another:
+#
+#     config.middleware.insert_before Rack::Head, Magical::Unicorns
+#
+# There's also +insert_after+ which will insert a middleware after another:
+#
+#     config.middleware.insert_after Rack::Head, Magical::Unicorns
+#
+# Middlewares can also be completely swapped out and replaced with others:
+#
+#     config.middleware.swap ActionDispatch::Flash, Magical::Unicorns
+#
+# And finally they can also be removed from the stack completely:
+#
+#     config.middleware.delete ActionDispatch::Flash
+#
+module Jets::Middleware
+  class Configurator
+    def initialize(operations = [], delete_operations = [])
+      @operations = operations
+      @delete_operations = delete_operations
+    end
+
+    def insert_before(*args, &block)
+      @operations << [__method__, args, block]
+    end
+
+    alias :insert :insert_before
+
+    def insert_after(*args, &block)
+      @operations << [__method__, args, block]
+    end
+
+    def swap(*args, &block)
+      @operations << [__method__, args, block]
+    end
+
+    def use(*args, &block)
+      @operations << [__method__, args, block]
+    end
+
+    def delete(*args, &block)
+      @delete_operations << [__method__, args, block]
+    end
+
+    def unshift(*args, &block)
+      @operations << [__method__, args, block]
+    end
+
+    def merge_into(other) #:nodoc:
+      (@operations + @delete_operations).each do |operation, args, block|
+        other.send(operation, *args, &block)
+      end
+
+      other
+    end
+
+    def +(other) # :nodoc:
+      Configurator.new(@operations + other.operations, @delete_operations + other.delete_operations)
+    end
+
+    protected
+      def operations
+        @operations
+      end
+
+      def delete_operations
+        @delete_operations
+      end
+  end
+end

data/lib/jets/middleware/default_stack.rb

@@ -0,0 +1,53 @@
+require "shotgun"
+
+module Jets::Middleware
+  class DefaultStack
+    attr_reader :config, :app
+    def initialize(app, config)
+      @app = app
+      @config = config
+    end
+
+    def build_stack
+      Stack.new do |middleware|
+        middleware.use Shotgun::Static
+        middleware.use Rack::Runtime
+        middleware.use Jets::Controller::Middleware::Cors if cors_enabled?
+        middleware.use Rack::MethodOverride # must come before Middleware::Local for multipart post forms to work
+        middleware.use Jets::Controller::Middleware::Reloader if Jets.config.hot_reload
+        middleware.use Jets::Controller::Middleware::Local # mimics AWS Lambda for local server only
+        middleware.use session_store, session_options
+        middleware.use Rack::Head
+        middleware.use Rack::ConditionalGet
+        middleware.use Rack::ETag
+        use_webpacker(middleware)
+      end
+    end
+
+  private
+    def cors_enabled?
+      Jets.config.cors
+    end
+
+    # Written as method to easily not include webpacker for case when either
+    # webpacker not installed at all or disabled upon `jets deploy`.
+    def use_webpacker(middleware)
+      return unless Jets.webpacker? # checks for local development if webpacker installed
+      # Different check for middleware because we need webpacker helpers for url helpers.
+      # But we dont want to actually serve via webpacker middleware when running on AWS.
+      # By this time the url helpers are serving assets out of s3.
+      return if File.exist?("#{Jets.root}/config/disable-webpacker-middleware.txt") # created as part of `jets deploy`
+      require "jets/controller/middleware/webpacker_setup"
+      middleware.use Webpacker::DevServerProxy
+    end
+
+    def session_store
+      Jets.config.session[:store] # do not use dot notation. session.store is a method on ActiveSupport::OrderedOptions.new
+    end
+
+    def session_options
+      defaults = { secret: ENV['SECRET_KEY_BASE'] }
+      defaults.merge(Jets.config.session.options)
+    end
+  end
+end

data/lib/jets/middleware/layer.rb

@@ -0,0 +1,34 @@
+module Jets::Middleware
+  class Layer
+    attr_reader :args, :block, :klass
+
+    def initialize(klass, args, block)
+      @klass = klass
+      @args  = args
+      @block = block
+    end
+
+    def name; klass.name; end
+
+    def ==(middleware)
+      case middleware
+      when Layer
+        klass == middleware.klass
+      when Class
+        klass == middleware
+      end
+    end
+
+    def inspect
+      if klass.is_a?(Class)
+        klass.to_s
+      else
+        klass.class.to_s
+      end
+    end
+
+    def build(app)
+      klass.new(app, *args, &block)
+    end
+  end
+end

data/lib/jets/middleware/stack.rb

@@ -0,0 +1,77 @@
+module Jets::Middleware
+  class Stack
+    include Enumerable
+
+    attr_accessor :middlewares
+    def initialize(*args)
+      @middlewares = []
+      yield(self) if block_given?
+    end
+
+    def each
+      @middlewares.each { |x| yield x }
+    end
+
+    def size
+      middlewares.size
+    end
+
+    def last
+      middlewares.last
+    end
+
+    def [](i)
+      middlewares[i]
+    end
+
+    def unshift(klass, *args, &block)
+      middlewares.unshift(build_middleware(klass, args, block))
+    end
+
+    def initialize_copy(other)
+      self.middlewares = other.middlewares.dup
+    end
+
+    def insert(index, klass, *args, &block)
+      index = assert_index(index, :before)
+      middlewares.insert(index, build_middleware(klass, args, block))
+    end
+
+    alias_method :insert_before, :insert
+
+    def insert_after(index, *args, &block)
+      index = assert_index(index, :after)
+      insert(index + 1, *args, &block)
+    end
+
+    def swap(target, *args, &block)
+      index = assert_index(target, :before)
+      insert(index, *args, &block)
+      middlewares.delete_at(index + 1)
+    end
+
+    def delete(target)
+      middlewares.delete_if { |m| m.klass == target }
+    end
+
+    def use(klass, *args, &block)
+      middlewares.push(build_middleware(klass, args, block))
+    end
+
+    def build(app = Proc.new)
+      middlewares.freeze.reverse.inject(app) { |a, e| e.build(a) }
+    end
+
+  private
+
+    def assert_index(index, where)
+      i = index.is_a?(Integer) ? index : middlewares.index { |m| m.klass == index }
+      raise "No such middleware to insert #{where}: #{index.inspect}" unless i
+      i
+    end
+
+    def build_middleware(klass, args, block)
+      Layer.new(klass, args, block)
+    end
+  end
+end

data/lib/jets/middleware.rb

@@ -0,0 +1,33 @@
+module Jets
+  module Middleware
+    extend Memoist
+
+    def call(env)
+      stack = middlewares.build(endpoint)
+      stack.call(env)
+    end
+
+    # Final middleware in the stack
+    def endpoint
+      Jets::Controller::Middleware::Main
+    end
+
+    # Called in Jets::Booter to build middleware stack only once during bootup
+    def build_stack
+      middlewares
+    end
+
+    def middlewares
+      config_middleware.merge_into(default_stack) # returns Jets::Middleware::Stack
+    end
+    memoize :middlewares
+
+    def default_stack
+      Jets::Middleware::DefaultStack.new(Jets.config, Jets.application).build_stack # returns Jets::Middleware::Stack
+    end
+
+    def config_middleware
+      Jets.config.middleware # returns Jets::Middleware::Configurator
+    end
+  end
+end

data/lib/jets/naming.rb

@@ -0,0 +1,63 @@
+# This class groups the naming in one place.
+# Some naming is for CloudFormation
+# Some are for the Build process
+class Jets::Naming
+  # Mainly used by build.rb
+  class << self
+    extend Memoist
+
+    def app_template_path(app_class)
+      underscored = underscore(app_class)
+      "#{template_path_prefix}-app-#{underscored}.yml"
+    end
+
+    def shared_template_path(shared_class)
+      underscored = underscore(shared_class)
+      "#{template_path_prefix}-shared-#{underscored}.yml"
+    end
+
+    def template_path_prefix
+      "#{Jets.build_root}/templates/#{Jets.config.project_namespace}"
+    end
+
+    # consider moving these methods into cfn/builder/helpers.rb or that area.
+    def parent_template_path
+      "#{template_path_prefix}.yml"
+    end
+
+    # consider moving these methods into cfn/builder/helpers.rb or that area.
+    def api_gateway_template_path
+      "#{template_path_prefix}-api-gateway.yml"
+    end
+
+    def api_resources_template_path(page)
+      "#{template_path_prefix}-api-resources-#{page}.yml"
+    end
+
+    def api_deployment_template_path
+      "#{template_path_prefix}-api-deployment.yml"
+    end
+
+    def shared_resources_template_path
+      "#{template_path_prefix}-shared-resources.yml"
+    end
+
+    def parent_stack_name
+      File.basename(parent_template_path, ".yml")
+    end
+
+    def gateway_api_name
+      "#{Jets.config.project_namespace}"
+    end
+
+    def authorizer_template_path(path)
+      underscored = underscore(path)
+      underscored.sub!(/^app-/, '')
+      "#{template_path_prefix}-#{underscored}.yml"
+    end
+
+    def underscore(s)
+      s.to_s.underscore.sub(/\.rb$/,'').gsub('/','-')
+    end
+  end
+end

data/lib/jets/overrides/lambda/marshaller.rb

@@ -0,0 +1,31 @@
+require 'json'
+
+# Hack AwsLambda Ruby Runtime to fix .to_json issue collision with ActiveSupport.
+# To reproduce:
+#   Create a shared resource from the docs and call sns.publish
+#
+# Causes an infinite loop when calling sns.publish somehow.
+# Overriding with JSON.dump and follow up with AWS ticket.
+module AwsLambda
+  class Marshaller
+    class << self
+      # By default, just runs #to_json on the method's response value.
+      # This can be overwritten by users who know what they are doing.
+      # The response is an array of response, content-type.
+      # If returned without a content-type, it is assumed to be application/json
+      # Finally, StringIO/IO is used to signal a response that shouldn't be
+      # formatted as JSON, and should get a different content-type header.
+      def marshall_response(method_response)
+        case method_response
+        when StringIO, IO
+          [method_response, 'application/unknown']
+        else
+          # Orignal method calls .to_json but this collides with ActiveSupport's to_json
+          # method_response.to_json # application/json is assumed
+          JSON.dump(method_response)
+        end
+      end
+
+    end
+  end
+end

data/lib/jets/overrides/lambda.rb

@@ -0,0 +1 @@
+require "jets/overrides/lambda/marshaller"

data/lib/jets/overrides/rails/action_controller.rb

@@ -0,0 +1,13 @@
+ActiveSupport.on_load :action_controller do
+  class ActionController::Base
+    class << self
+      @@_prefixes = nil
+      def _prefixes
+        @@_prefixes
+      end
+      def _prefixes=(v)
+        @@_prefixes = v
+      end
+    end
+  end
+end

data/lib/jets/overrides/rails/asset_tag_helper.rb

@@ -0,0 +1,114 @@
+# Override to prepend stage name when on AWS.
+module Jets::AssetTagHelper
+  extend Memoist
+  include Jets::CommonMethods
+  include Jets::AwsServices
+
+  def javascript_include_tag(*sources, **options)
+    sources = sources.map { |s| s3_public_url(s, :javascripts) }
+    super
+  end
+
+  def stylesheet_link_tag(*sources, **options)
+    sources = sources.map { |s| s3_public_url(s, :stylesheets) }
+    super
+  end
+
+  # Locally:
+  #
+  #   image_tag("jets.png") => /images/jets.png
+  #   image_tag("/images/jets.png") => /images/jets.png
+  #
+  # Remotely:
+  #
+  #   image_tag("jets.png") => https://s3-us-west-2.amazonaws.com/demo-dev-s3bucket-1kih4n2te0n66/jets/public/images/jets.png
+  def image_tag(source, options = {})
+    source = source.to_s # convert to String because passing a posts.photo object to results in failure to resolve the immage to a URL since we haven't defined polymorphic_url yet
+
+    # mimic original behavior to get /images in source
+    source = "/images/#{source}" unless source.starts_with?('/') || source.starts_with?('http')
+    if on_aws? && !source.starts_with?('http')
+      source = "#{s3_public}#{source}"
+    end
+
+    super
+  end
+
+  def asset_path(source, options = {})
+    source = source.to_s # convert to String because passing a posts.photo object to results in failure to resolve the immage to a URL since we haven't defined polymorphic_url yet
+    # mimic original behavior to get /images in source
+    source = "/images/#{source}" unless source.starts_with?('/') || source.starts_with?('http')
+
+    # Examples to help understand:
+    #
+    #   puts "AssetTagHelper#asset_path source #{source}"
+    #   puts "AssetTagHelper#asset_path asset_folder?(source) #{asset_folder?(source).inspect}"
+    #   AssetTagHelper#asset_path source /packs/images/myimage-e5f675d1ba26865fd65e919beb5bb86b.png
+    #   AssetTagHelper#asset_path asset_folder?(source) "images"
+    #
+    if on_aws? && asset_folder?(source) && !source.starts_with?('http')
+      source = "#{s3_public}#{source}"
+    end
+
+    super
+  end
+
+  # Serves favicon out of s3 when on API gateway.
+  #
+  # Useful helper for API Gateway since serving binary data like images without
+  # an Accept header doesnt work well. You can changed Media Types to '*/*'
+  # but then that messes up form data.
+  def favicon_path(path='favicon.ico')
+    on_aws? ? "#{s3_public}/#{path}" : "/#{path}"
+  end
+
+private
+  # Whatever is configured in Jets.config.assets.folders
+  # Example: packs, images, assets
+  def asset_folder?(url)
+    Jets.config.assets.folders.detect do |folder|
+      url.include?(folder)
+    end
+  end
+
+  # User can use:
+  #  javascript_include_tag "assets/test"
+  #
+  # Rails automatically adds "javscript" in front, to become:
+  #
+  #   /javascripts/assets/test
+  #
+  # We want to add the API Gateway stage name in front for this:
+  #
+  #   /stag/javascript/asset/test
+  #
+  # But adding it in front results in this:
+  #
+  #   /javascript/stag/asset/test
+  #
+  # If there's a / in front then rails will not add the "javascript":
+  # So we can add the javascript ourselves and then add the stag with a
+  # / in front.
+  def s3_public_url(url, asset_type)
+    unless url.starts_with?('/') or url.starts_with?('http')
+      url = "/#{asset_type}/#{url}" # /javascript/asset/test
+    end
+    add_s3_public(url)
+  end
+
+  # Example:
+  # Url: /packs/application-e7654c50abd78161b641.js
+  # Returns: https://s3-us-west-2.amazonaws.com/demo-dev-s3bucket-1jg5o076egkk4/jets/public/packs/application-e7654c50abd78161b641.js
+  def add_s3_public(url)
+    return url unless on_aws?
+    "#{s3_public}#{url}"
+  end
+
+  def s3_public
+    # s3_base_url.txt is created as part of the build process
+    s3_base_url = IO.read("#{Jets.root}/config/s3_base_url.txt").strip
+    "#{s3_base_url}/public"
+  end
+  memoize :s3_public
+end
+ActionView::Helpers.send(:include, Jets::AssetTagHelper)