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

data/lib/jets/internal/app/controllers/jets/bare_controller.rb

@@ -0,0 +1,16 @@
+# Parent class for MountController and RackController
+class Jets::BareController < Jets::Controller::Base
+  layout false
+  internal true
+  skip_forgery_protection
+
+private
+  # Override process! so it doesnt go through the complete Jets project middleware stack which could interfer with
+  # the mounted Rack app.
+  def process!
+    status, headers, body = dispatch!
+    # Use the adapter only to convert the Rack triplet to a API Gateway hash structure
+    adapter = Jets::Controller::Rack::Adapter.new(event, context, meth)
+    adapter.convert_to_api_gateway(status, headers, body)
+  end
+end

data/lib/jets/internal/app/controllers/jets/mailers_controller.rb

@@ -0,0 +1,97 @@
+# frozen_string_literal: true
+
+class Jets::MailersController < Jets::Controller::Base # :nodoc:
+  before_action :find_preview, only: [:preview]
+  before_action :set_locale, only: [:preview]
+  # TODO: allow multiple actions
+  # before_action :find_preview, :set_locale, only: :preview
+
+  # TODO: add helper_method support
+  # helper_method :part_query, :locale_query
+
+  # TODO: content_security_policy
+  # content_security_policy(false)
+
+  def index
+    @previews = ActionMailer::Preview.all
+    @page_title = "Mailer Previews"
+  end
+
+  def preview
+    if params[:path] == @preview.preview_name
+      @page_title = "Mailer Previews for #{@preview.preview_name}"
+      render :mailer
+    else
+      @email_action = File.basename(params[:path])
+
+      if @preview.email_exists?(@email_action)
+        @email = @preview.call(@email_action, params)
+
+        if params[:part]
+          part_type = Mime::Type.lookup(params[:part])
+
+          if part = find_part(part_type)
+            response.headers["Content-Type"] = params[:part]
+            render plain: part.respond_to?(:decoded) ? part.decoded : part
+          else
+            raise AbstractController::ActionNotFound, "Email part '#{part_type}' not found in #{@preview.name}##{@email_action}"
+          end
+        else
+          @part = find_preferred_part(Mime[:html], Mime[:text])
+          render :email, layout: false, formats: %w[html]
+        end
+      else
+        raise AbstractController::ActionNotFound, "Email '#{@email_action}' not found in #{@preview.name}"
+      end
+    end
+  end
+
+  private
+    def show_previews? # :doc:
+      ActionMailer::Base.show_previews
+    end
+
+    def find_preview # :doc:
+      candidates = []
+      params[:path].to_s.scan(%r{/|$}) { candidates << $` } # ` # hack to fix syntax highlighting
+      preview = candidates.detect { |candidate| ActionMailer::Preview.exists?(candidate) }
+
+      if preview
+        @preview = ActionMailer::Preview.find(preview)
+      else
+        raise AbstractController::ActionNotFound, "Mailer preview '#{params[:path]}' not found"
+      end
+    end
+
+    def find_preferred_part(*formats) # :doc:
+      formats.each do |format|
+        if part = @email.find_first_mime_type(format)
+          return part
+        end
+      end
+
+      if formats.any? { |f| @email.mime_type == f }
+        @email
+      end
+    end
+
+    def find_part(format) # :doc:
+      if part = @email.find_first_mime_type(format)
+        part
+      elsif @email.mime_type == format
+        @email
+      end
+    end
+
+    def part_query(mime_type)
+      request.query_parameters.merge(part: mime_type).to_query
+    end
+
+    def locale_query(locale)
+      request.query_parameters.merge(locale: locale).to_query
+    end
+
+    def set_locale
+      I18n.locale = params[:locale] || I18n.default_locale
+    end
+end

data/lib/jets/internal/app/controllers/jets/mount_controller.rb

@@ -0,0 +1,63 @@
+# routes mount support
+class Jets::MountController < Jets::BareController
+  def call
+    route = find_route
+    # On Lambda, the route should always be found so this check on lambda is not needed.
+    # But this is useful when we're testing locally with the shim directly.
+    unless route
+      render json: {status: "route not found"}, status: 404
+      return
+    end
+
+    # The reason we look up the route is because it contains mounted class info
+    mount_class = route.mount_class # IE: RackApp
+    env = build_env(route.path)
+
+    status, headers, io = mount_class.call(env)
+    body = read_body(io)
+    render(
+      status: status,
+      headers: headers,
+      body: body,
+    )
+  end
+
+private
+  # Rack response will return an IO object that responds to each. Sometimes this a Rack::BodyProxy
+  # Found this to be the case in Rails and Grape.
+  # Doing an IO#read may not work. So we'll always use the IO#each method
+  def read_body(io)
+    result = []
+    io.each { |body| result << body }
+    result.join
+  end
+
+  # Locally Jets::Router::Finder gets called twice because it also gets called in Jets::Controller::Middleware::Local
+  # On Lambda, Jets::Router::Finder only gets called once.
+  # TODO: Maybe add caching improvement.
+  def find_route
+    Jets::Router::Finder.new(event["path"], "ANY").run
+  end
+
+  def build_env(path)
+    env = Jets::Controller::Rack::Env.new(event, context, adapter: true).convert
+    # remap path info
+    mount_at = mount_at(path)
+    path_info = env["PATH_INFO"]
+    env["SCRIPT_NAME"] = script_name(mount_at)
+    env["PATH_INFO"] = path_info.sub(mount_at,'')
+    env["ORIGINAL_PATH_INFO"] = path_info
+    env
+  end
+
+  # Removes the wildcard: rack/*path => rack
+  def mount_at(path)
+    path.gsub(/\*.*/,'')
+  end
+
+  # Adding forward slash to script name, to generate proper path.
+  # First remove all the occurance of forward slash at the begining and then add one.
+  def script_name(path)
+    '/' + path.gsub(/^\/*/,'')
+  end
+end

data/lib/jets/internal/app/controllers/jets/public_controller.rb

@@ -0,0 +1,31 @@
+require "rack/mime"
+require "mini_mime"
+
+class Jets::PublicController < Jets::Controller::Base
+  layout false
+  internal true
+
+  def show
+    catchall = params[:catchall].blank? ? 'index.html' : params[:catchall]
+    public_path = Jets.root + "public"
+    catchall_path = "#{public_path}/#{catchall}"
+
+    if File.exist?(catchall_path)
+      content_type = Rack::Mime.mime_type(File.extname(catchall_path))
+      binary = !MiniMime.lookup_by_filename(catchall_path).content_type.include?("text")
+
+      # For binary support to work, the client also has to send the right Accept header.
+      # And the media type has been to added to api gateway.
+      # Cavaet: adding * to as the media type breaks regular form submission.
+      # All form submission gets treated as binary.
+      if binary
+        encoded_content = Base64.encode64(IO.read(catchall_path))
+        render plain: encoded_content, content_type: content_type, base64: true
+      else
+        render file: catchall_path, content_type: content_type
+      end
+    else
+      render file: "#{public_path}/404", status: 404
+    end
+  end
+end

data/lib/jets/internal/app/controllers/jets/rack_controller.rb

@@ -0,0 +1,12 @@
+class Jets::RackController < Jets::BareController
+  # Megamode
+  def process
+    resp = mega_request
+    render(resp)
+  end
+
+private
+  def mega_request
+    Jets::Mega::Request.new(event, self).proxy
+  end
+end

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

@@ -0,0 +1,18 @@
+require 'bundler/setup'
+require 'cfn_response'
+require 'jets/internal/app/functions/jets/base_path_mapping'
+
+STAGE_NAME = "<%= @stage_name %>"
+
+def lambda_handler(event:, context:)
+  cfn = CfnResponse.new(event, context)
+  cfn.response do
+    mapping = BasePathMapping.new(event, STAGE_NAME)
+    case event['RequestType']
+    when "Create", "Update"
+      mapping.update
+    when "Delete"
+      mapping.delete(true) if mapping.should_delete?
+    end
+  end
+end

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

@@ -0,0 +1,100 @@
+require 'aws-sdk-apigateway'
+require 'aws-sdk-cloudformation'
+
+class BasePathMapping
+  def initialize(event, stage_name)
+    @event, @stage_name = event, stage_name
+    aws_config_update!
+  end
+
+  # Override the AWS retry settings. The aws-sdk-core has expondential backup with this formula:
+  #
+  #   2 ** c.retries * c.config.retry_base_delay
+  #
+  # So the max delay will be 2 ** 7 * 0.6 = 76.8s
+  #
+  # Useful links:
+  #
+  #   https://github.com/aws/aws-sdk-ruby/blob/master/gems/aws-sdk-core/lib/aws-sdk-core/plugins/retry_errors.rb
+  #   https://docs.aws.amazon.com/apigateway/latest/developerguide/limits.html
+  #
+  def aws_config_update!
+    Aws.config.update(
+      retry_limit: 7, # default: 3
+      retry_base_delay: 0.6, # default: 0.3
+    )
+  end
+
+  # 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.
+  def update
+    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: base_path.empty? ? '(none)' : base_path,
+    )
+  # https://github.com/tongueroo/jets/issues/255
+  # Used to return: Aws::APIGateway::Errors::NotFoundException
+  # Now returns: Aws::APIGateway::Errors::InternalFailure
+  # So we'll use a more generic error
+  rescue Aws::APIGateway::Errors::ServiceError => 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 deployment_stack
+    @deployment_stack ||= cfn.describe_stacks(stack_name: @event['StackId']).stacks.first
+  end
+
+  def rest_api_id
+    @rest_api_id ||= parameter_value('RestApi')
+  end
+
+  def domain_name
+    @domain_name ||= parameter_value('DomainName')
+  end
+
+  def base_path
+    @base_path ||= parameter_value('BasePath') || ''
+  end
+
+  def parameter_value(parameter_key)
+    param = deployment_stack[:parameters].find { |p| p.parameter_key == parameter_key }
+    param&.parameter_value # possible for this to be nil when removing the config: IE: config.domain.name = nil
+  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
+
+  def apigateway
+    @apigateway ||= Aws::APIGateway::Client.new
+  end
+
+  def cfn
+    @cfn ||= Aws::CloudFormation::Client.new
+  end
+end

data/lib/jets/internal/app/helpers/jets/mailers_helper.rb

@@ -0,0 +1,9 @@
+module Jets::MailersHelper
+  def part_query(mime_type)
+    mime_type
+  end
+
+  def locale_query(locale)
+    locale
+  end
+end

data/lib/jets/internal/app/jobs/jets/preheat_job.rb

@@ -0,0 +1,70 @@
+class Jets::PreheatJob < ApplicationJob
+  ENABLED = Jets.config.prewarm.enable
+  CONCURRENCY = Jets.config.prewarm.concurrency
+  PREWARM_RATE = Jets.config.prewarm.rate
+  torching = ENABLED && CONCURRENCY > 1
+  warming = ENABLED && CONCURRENCY == 1
+
+  class_timeout 30
+  class_memory 1024
+  class_iam_policy(
+    {
+      sid: "Statement1",
+      action: ["logs:*"],
+      effect: "Allow",
+      resource: "arn:aws:logs:#{Jets.aws.region}:#{Jets.aws.account}:log-group:#{Jets.config.project_namespace}-*",
+    },
+    {
+      sid: "Statement2",
+      action: ["lambda:InvokeFunction", "lambda:InvokeAsync"],
+      effect: "Allow",
+      resource: "arn:aws:lambda:#{Jets.aws.region}:#{Jets.aws.account}:function:#{Jets.config.project_namespace}-*",
+    }
+  )
+
+  rate(PREWARM_RATE) if torching
+  def torch
+    threads = []
+    CONCURRENCY.times do
+      threads << Thread.new do
+        # intentionally calling remote lambda for concurrency
+        # avoid passing the _prewarm=1 flag because we want the PreheatJob#warm
+        # to run it's normal workload.
+        # Do not use Jets::Preheat.warm(function_name) here as that passes the _prewarm=1.
+        function_name = "jets-preheat_job-warm"
+        event_json = JSON.dump(event)
+        options = call_options(event[:quiet])
+        Jets::Commands::Call.new(function_name, event_json, options).run unless Jets.env.test?
+      end
+    end
+    threads.each { |t| t.join }
+    "Finished prewarming your application with a concurrency of #{CONCURRENCY}."
+  end
+
+  rate(PREWARM_RATE) if warming
+  def warm
+    options = call_options(event[:quiet])
+    Jets::Preheat.warm_all(options)
+    "Finished prewarming your application."
+  end
+
+  class << self
+    # Can use this to prewarm post deploy
+    def prewarm!
+      meth = CONCURRENCY > 1 ? :torch : :warm
+      perform_now(meth, quiet: true)
+    end
+  end
+
+private
+  def call_options(quiet)
+    options = {}
+    options.merge!(mute: true, mute_output: true) if quiet
+    # All the methods in this Job class leads to Jets::Commands::Call.
+    # This is true for the Jets::Preheat.warm_all also.
+    # These jobs delegate out to Lambda function calls. We do not need/want
+    # the invocation type: RequestResponse in this case.
+    options.merge!(invocation_type: "Event")
+    options
+  end
+end

data/lib/jets/internal/app/shared/functions/jets/s3_bucket_config.rb

@@ -0,0 +1,33 @@
+require 'bundler/setup'
+require 'active_support/core_ext/hash'
+require 'cfn_response'
+
+def lambda_handler(event:, context:)
+  cfn = CfnResponse.new(event, context)
+  cfn.response do
+    case event['RequestType']
+    when "Create", "Update"
+      properties = event["ResourceProperties"].dup
+      # After deleting ServiceToken, the rest of the values are the bucket configuration properties.
+      properties.delete("ServiceToken")
+      configurator = BucketConfigurator.new
+      configurator.put(properties)
+    end
+  end
+end
+
+########################################################
+require "aws-sdk-s3"
+
+class BucketConfigurator
+  def put(props={})
+    # all props including bucket gets passed from the Custom::S3BucketConfiguration resource
+    props = props.deep_transform_keys { |k| k.to_s.underscore.to_sym }
+    puts "props: #{JSON.dump(props)}"
+    s3.put_bucket_notification_configuration(props)
+  end
+
+  def s3
+    @s3 ||= Aws::S3::Client.new
+  end
+end

data/lib/jets/internal/app/views/jets/mailers/email.html.erb

@@ -0,0 +1,145 @@
+<!DOCTYPE html>
+<html><head>
+<meta name="viewport" content="width=device-width" />
+<style type="text/css">
+  html, body, iframe {
+    height: 100%;
+  }
+
+  body {
+    margin: 0;
+  }
+
+  header {
+    width: 100%;
+    padding: 10px 0 0 0;
+    margin: 0;
+    background: white;
+    font: 12px "Lucida Grande", sans-serif;
+    border-bottom: 1px solid #dedede;
+    overflow: hidden;
+  }
+
+  dl {
+    margin: 0 0 10px 0;
+    padding: 0;
+  }
+
+  dt {
+    width: 80px;
+    padding: 1px;
+    float: left;
+    clear: left;
+    text-align: right;
+    color: #7f7f7f;
+  }
+
+  dd {
+    margin-left: 90px; /* 80px + 10px */
+    padding: 1px;
+  }
+
+  dd:empty:before {
+    content: "\00a0"; // &nbsp;
+  }
+
+  iframe {
+    border: 0;
+    width: 100%;
+  }
+</style>
+</head>
+
+<body>
+<header>
+  <dl>
+    <% if @email.respond_to?(:smtp_envelope_from) && Array(@email.from) != Array(@email.smtp_envelope_from) %>
+      <dt>SMTP-From:</dt>
+      <dd><%= @email.smtp_envelope_from %></dd>
+    <% end %>
+
+    <% if @email.respond_to?(:smtp_envelope_to) && @email.to != @email.smtp_envelope_to %>
+      <dt>SMTP-To:</dt>
+      <dd><%= @email.smtp_envelope_to %></dd>
+    <% end %>
+
+    <dt>From:</dt>
+    <dd><%= @email.header['from'] %></dd>
+
+    <% if @email.reply_to %>
+      <dt>Reply-To:</dt>
+      <dd><%= @email.header['reply-to'] %></dd>
+    <% end %>
+
+    <dt>To:</dt>
+    <dd><%= @email.header['to'] %></dd>
+
+    <% if @email.cc %>
+      <dt>CC:</dt>
+      <dd><%= @email.header['cc'] %></dd>
+    <% end %>
+
+    <dt>Date:</dt>
+    <dd><%= Time.current.rfc2822 %></dd>
+
+    <dt>Subject:</dt>
+    <dd><strong><%= @email.subject %></strong></dd>
+
+    <% unless @email.attachments.nil? || @email.attachments.empty? %>
+      <dt>Attachments:</dt>
+      <dd>
+        <% @email.attachments.each do |a| %>
+          <% filename = a.respond_to?(:original_filename) ? a.original_filename : a.filename %>
+          <%= link_to filename, "data:application/octet-stream;charset=utf-8;base64,#{Base64.encode64(a.body.to_s)}", download: filename %>
+        <% end %>
+      </dd>
+    <% end %>
+
+    <dt>Format:</dt>
+    <% if @email.multipart? %>
+      <dd>
+        <select id="part" onchange="refreshBody(false);">
+          <option <%= request.format == Mime[:html] ? 'selected' : '' %> value="<%= part_query('text/html') %>">View as HTML email</option>
+          <option <%= request.format == Mime[:text] ? 'selected' : '' %> value="<%= part_query('text/plain') %>">View as plain-text email</option>
+        </select>
+      </dd>
+    <% else %>
+      <dd id="mime_type" data-mime-type="<%= part_query(@email.mime_type) %>"><%= @email.mime_type == 'text/html' ? 'HTML email' : 'plain-text email' %></dd>
+    <% end %>
+
+    <% if I18n.available_locales.count > 1 %>
+      <dt>Locale:</dt>
+      <dd>
+        <select id="locale" onchange="refreshBody(true);">
+          <% I18n.available_locales.each do |locale| %>
+            <option <%= I18n.locale == locale ? 'selected' : '' %> value="<%= locale_query(locale) %>"><%= locale %></option>
+          <% end %>
+        </select>
+      </dd>
+    <% end %>
+  </dl>
+</header>
+
+<iframe seamless name="messageBody" src="?part=<%= part_query(@part.mime_type) %>"></iframe>
+
+<script>
+  function refreshBody(reload) {
+    var part_select = document.querySelector('select#part');
+    var locale_select = document.querySelector('select#locale');
+    var iframe = document.getElementsByName('messageBody')[0];
+    var part_param = part_select ?
+      part_select.options[part_select.selectedIndex].value :
+      document.querySelector('#mime_type').dataset.mimeType;
+    var fresh_location = '?part=' + part_param;
+    var doc = iframe.contentWindow.document;
+
+    doc.open();
+    doc.write("Loading...");
+    doc.close();
+
+    iframe.contentWindow.location = fresh_location;
+  }
+</script>
+
+</body>
+</html>

data/lib/jets/internal/app/views/jets/mailers/index.html.erb

@@ -0,0 +1,8 @@
+<% @previews.each do |preview| %>
+<h3><%= link_to(preview.preview_name.titleize, "/jets/mailers/#{preview.preview_name}") %></h3>
+<ul>
+<% preview.emails.each do |email| %>
+<li><%= link_to(email, "/jets/mailers/#{preview.preview_name}/#{email}") %></li>
+<% end %>
+</ul>
+<% end %>

data/lib/jets/internal/app/views/jets/mailers/mailer.html.erb

@@ -0,0 +1,6 @@
+<h3><%= @preview.preview_name.titleize %></h3>
+<ul>
+<% @preview.emails.each do |email| %>
+<li><%= link_to(email, "/jets/mailers/#{@preview.preview_name}/#{email}") %></li>
+<% end %>
+</ul>

data/lib/jets/internal/turbines/jets/mailer.rb

@@ -0,0 +1,52 @@
+module Jets
+  # Reference: https://github.com/rails/rails/blob/master/actionmailer/lib/action_mailer/railtie.rb
+  class Mailer < ::Jets::Turbine
+    config.action_mailer = ActiveSupport::OrderedOptions.new
+
+    initializer "action_mailer.logger" do
+      ActiveSupport.on_load(:action_mailer) { self.logger ||= Jets.logger }
+    end
+
+    initializer "action_mailer.set_configs" do |app|
+      app.config.action_mailer ||= ActiveSupport::OrderedOptions.new # TODO: temp fix. only happens sometimes?
+      options = app.config.action_mailer
+      options.default_url_options ||= {}
+      options.default_url_options[:protocol] ||= "https"
+      options.show_previews = false if options.show_previews.nil?
+      options.preview_path ||= "#{Jets.root}/app/previews" if options.show_previews
+      options.view_paths ||= "#{Jets.root}/app/views"
+
+      # TODO: Dont think Jets sets asset_host the same way
+      # make sure readers methods get compiled
+      # options.asset_host          ||= app.config.asset_host
+      # options.relative_url_root   ||= app.config.relative_url_root
+
+      ActiveSupport.on_load(:action_mailer) do
+        include AbstractController::UrlFor
+        # TODO: figure out rest of the helpers
+        # extend ::AbstractController::Railties::RoutesHelpers.with(app.routes, false)
+        # include app.routes.mounted_helpers
+
+        register_interceptors(options.delete(:interceptors))
+        register_preview_interceptors(options.delete(:preview_interceptors))
+        register_observers(options.delete(:observers))
+
+        options.each { |k, v| send("#{k}=", v) }
+      end
+    end
+
+    after_initializer "action_mailer.routes" do |app|
+      if app.config.action_mailer.show_previews
+        app.routes.draw do
+          get "jets/mailers", to: "jets/mailers#index"
+          get "jets/mailers/*path", to: "jets/mailers#preview"
+        end
+
+        ActiveSupport.on_load :action_controller do
+          internal_views = File.expand_path("internal/app/views", File.dirname(__FILE__))
+          ActionController::Base.append_view_path(internal_views)
+        end
+      end
+    end
+  end
+end