jets_bb_fork 0.0.4

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

@@ -0,0 +1,31 @@
+require "rack/mime"
+require "mimemagic"
+
+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 = !MimeMagic.by_path(catchall_path).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,25 @@
+class Jets::RackController < Jets::Controller::Base
+  layout false
+  internal true
+
+  # Megamode
+  def process
+    resp = mega_request
+    render(resp)
+  end
+
+private
+  # Override process! so it doesnt go through middleware adapter and hits
+  # process logic directly. This handles the case for AWS Lambda.
+  # For local server, we adjust the Middleware::Local logic.
+  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
+
+  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,157 @@
+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)',
+    )
+  # 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 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/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 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,43 @@
+require "active_support/all"
+require "aws-sdk-s3"
+require "cfnresponse"
+include Cfnresponse
+
+def lambda_handler(event:, context:)
+  # Print out debugging info immediately just in case
+  puts "event: #{json_pretty(event)}"
+  puts "context: #{json_pretty(context)}"
+
+  if %w[Create Update].include?(event['RequestType'])
+    properties = event["ResourceProperties"].dup
+    # After deleting ServiceToken, the rest of the values is the bucket configuration properties.
+    properties.delete("ServiceToken")
+    configurator = BucketConfigurator.new
+    configurator.put(properties)
+  end
+
+  send_response(event, context, "SUCCESS")
+
+# 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 # a little time for logs to be sent to CloudWatch
+  send_response(event, context, "FAILED")
+end
+
+########################################################
+
+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>