jets 4.0.12 → 5.0.0.beta1

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

@@ -1,52 +0,0 @@
-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(Jets::Application.preheat_job_iam_policy)
-
-  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
-    options
-  end
-end

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

@@ -1,8 +0,0 @@
-<% @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

@@ -1,6 +0,0 @@
-<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

@@ -1,52 +0,0 @@
-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

data/lib/jets/lambda/task.rb

@@ -1,111 +0,0 @@
-class Jets::Lambda::Task
-  attr_accessor :class_name, :type
-  attr_reader :meth, :properties, :iam_policy, :managed_iam_policy, :lang, :associated_resources
-  def initialize(class_name, meth, options={})
-    @class_name = class_name.to_s
-    @meth = meth
-    @options = options
-    @type = options[:type] || get_type  # controller, job, or function
-    @properties = options[:properties] || {}
-    @iam_policy = options[:iam_policy]
-    @managed_iam_policy = options[:managed_iam_policy]
-    @lang = options[:lang] || :ruby
-    @associated_resources = options[:associated_resources] || {}
-    @replacements = options[:replacements] || {} # added to baseline replacements
-  end
-
-  def name
-    @meth
-  end
-
-  def public_meth?
-    # For anonymous classes (app/functions/hello.rb) the class name will be blank.
-    # These types of classes are treated specially and has only one handler method
-    # that is registered. So we know it is public.
-    return true if @class_name.nil? || @class_name == ''
-
-    # Consider all polymorphic methods public for now
-    return true if @lang != :ruby
-
-    klass = @class_name.constantize
-    public_methods = klass.public_instance_methods
-    public_methods.include?(meth.to_sym)
-  end
-
-  def build_function_iam?
-    !!(@iam_policy || @managed_iam_policy)
-  end
-
-  @@lang_exts = {
-    ruby: '.rb',
-    python: '.py',
-    node: '.js',
-  }
-  def lang_ext
-    @@lang_exts[@lang]
-  end
-
-  # The get_type method works for controller and job classes.
-  #
-  # Usually able to get the type from the class name. Examples:
-  #
-  #   PostsController => controller
-  #   HardJob => job
-  #
-  # However, for function types, we are not able to get the type for multiple of
-  # reasons.  First, function types are allowed to be named with or without
-  # _function.  Examples:
-  #
-  #   path => class => type
-  #   app/functions/hello.rb => Hello => function
-  #   app/functions/hello_function.rb => HelloFunction => function
-  #
-  # The second reason is that functions are not regular ruby classes. Instead they
-  # are anonymous classes created with Class.new.  When classes are created with
-  # Class.new the method_added hook has "" (blank string) as the self class name.
-  # We add the class_type to the task later on as we are constructing the class
-  # as part of the Class.new logic.
-  #
-  # For controller and job standard ruby classes though it can easily be
-  # determinated as part of initialization. So we get the type for convenience then.
-  #
-  # For anonymous function classes, we just set to nil and will later fix in
-  # FunctionConstructor.
-  #
-  # Returns: "controller", "job" or nil
-  def get_type
-    unless @class_name.empty? # when anonymous class is created with Class.new
-      @class_name.underscore.split('_').last # controller, job or rule
-    end
-  end
-
-  def full_handler(handler_function)
-    "#{handler_base}.#{handler_function}"
-  end
-
-  def handler_path
-    "#{handler_base}#{lang_ext}"
-  end
-
-  def handler_base
-    base = "handlers/#{@type.pluralize}/#{@class_name.underscore}"
-    base += "/#{@lang}" if @lang != :ruby
-    base += "/#{@meth}"
-  end
-
-  def poly_src_path
-    handler_path.sub("handlers/", "app/")
-  end
-
-  def replacements
-    # Merge in the custom replacements specific to each app class: ConfigRule, Job, etc.
-    baseline_replacements.merge(@replacements)
-  end
-
-  def baseline_replacements
-    {
-      # camelized because used in not just keys but common used in values
-      namespace: @meth.to_s.camelize,
-    }
-  end
-end

data/lib/jets/logger.rb

@@ -1,21 +0,0 @@
-require 'logger'
-
-module Jets
-  class Logger < ::Logger
-    # Only need to override the add method as the other calls all lead to it.
-    def add(severity, message = nil, progname = nil)
-      # Taken from Logger#add source
-      # https://ruby-doc.org/stdlib-2.5.1/libdoc/logger/rdoc/Logger.html#method-i-add
-      if message.nil?
-        if block_given?
-          message = yield
-        else
-          message = progname
-          progname = @progname
-        end
-      end
-
-      super # original logical
-    end
-  end
-end

data/lib/jets/middleware/configurator.rb

@@ -1,84 +0,0 @@
-# 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

@@ -1,53 +0,0 @@
-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 unless ENV['JETS_RACK_METHOD_OVERRIDE'] == '0' # 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

@@ -1,34 +0,0 @@
-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

@@ -1,77 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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/overrides/rails/action_controller.rb

@@ -1,13 +0,0 @@
-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

@@ -1,114 +0,0 @@
-# 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)

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

@@ -1,13 +0,0 @@
-module Jets::CommonMethods
-  extend Memoist
-  # Add API Gateway Stage Name
-  def add_stage_name(url)
-    Jets::Controller::Stage.add(request.host, url) if request.present?
-  end
-
-  def on_aws?
-    on_cloud9 = Jets::Controller::Stage.on_cloud9?(request.headers['HTTP_HOST'])
-    !request.headers['HTTP_X_AMZN_TRACE_ID'].nil? && !on_cloud9
-  end
-  memoize :on_aws?
-end