jets-fs 1.6.10

data/lib/jets/middleware/default_stack.rb

@@ -0,0 +1,49 @@
+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 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::Local # mimics AWS Lambda for local server only
+        middleware.use session_store, session_options # 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/naming.rb

@@ -0,0 +1,49 @@
+# 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 = app_class.to_s.underscore.gsub('/','-')
+      "#{template_path_prefix}-app-#{underscored}.yml"
+    end
+
+    def shared_template_path(shared_class)
+      underscored = shared_class.to_s.underscore.gsub('/','-')
+      "#{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_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
+  end
+end

data/lib/jets/overrides/lambda.rb

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

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/rails.rb

@@ -0,0 +1,4 @@
+require "jets/overrides/rails/common_methods"
+require "jets/overrides/rails/url_helper"
+require "jets/overrides/rails/rendering_helper"
+require "jets/overrides/rails/asset_tag_helper"

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)

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

@@ -0,0 +1,20 @@
+module Jets::CommonMethods
+  extend Memoist
+  # Add API Gateway Stage Name
+  def add_stage_name(url)
+    return url unless add_stage?(url)
+
+    stage_name = Jets::Resource::ApiGateway::Deployment.stage_name
+    "/#{stage_name}#{url}"
+  end
+
+  def add_stage?(url)
+    request.host.include?("amazonaws.com") && url.starts_with?('/')
+  end
+  memoize :add_stage?
+
+  def on_aws?
+    !request.headers['HTTP_X_AMZN_TRACE_ID'].nil?
+  end
+  memoize :on_aws?
+end

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

@@ -0,0 +1,26 @@
+module Jets::RenderingHelper
+  # ensure that we always add the controller view name. So when rendering
+  # a partial:
+  #   <%= render "mypartial" %>
+  # gets turned into:
+  #   <%= render "articles/mypartial" %>
+  def render(options = {}, locals = {}, &block)
+    if options.is_a?(String) && !options.include?('/')
+      folder = _get_containing_folder(caller[0])
+      partial_name = options # happens to be the partial name
+      partial_name = "#{folder}/#{partial_name}"
+      options = partial_name
+    end
+
+    super(options, locals, &block)
+  end
+
+  # Ugly, going back up the caller stack to find out what view path
+  # we are in
+  def _get_containing_folder(caller_line)
+    text = caller_line.split(':').first
+    # .../fixtures/apps/demo/app/views/posts/index.html.erb
+    text.split('/')[-2] # posts
+  end
+end
+ActionView::Helpers.send(:include, Jets::RenderingHelper)

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

@@ -0,0 +1,25 @@
+require "action_view"
+
+# hackety hack
+module Jets::UrlHelper
+  include Jets::CommonMethods
+
+  # Basic implementation of url_for to allow use helpers without routes existence
+  def url_for(options = nil) # :nodoc:
+    url = case options
+          when String
+            options
+          when :back
+            _back_url
+          # TODO: hook this up to Jets implmentation of config/routes.rb
+          # when ActiveRecord::Base
+          #   record = options
+          #   record.id
+          else
+            raise ArgumentError, "Please provided a String to link_to as the the second argument. The Jets link_to helper takes as the second argument."
+          end
+
+    add_stage_name(url)
+  end
+end # UrlHelper
+ActionView::Helpers.send(:include, Jets::UrlHelper)

data/lib/jets/poly_fun.rb

@@ -0,0 +1,82 @@
+module Jets
+  class PolyFun
+    autoload :LambdaExecutor, 'jets/poly_fun/lambda_executor' # main class delegates to other classes
+
+    autoload :BaseExecutor, 'jets/poly_fun/base_executor'
+    autoload :PythonExecutor, 'jets/poly_fun/python_executor'
+    autoload :NodeExecutor, 'jets/poly_fun/node_executor'
+
+    autoload :PythonError, 'jets/poly_fun/python_error'
+    autoload :NodeError, 'jets/poly_fun/node_error'
+
+    extend Memoist
+
+    def initialize(app_class, app_meth)
+      @app_class = app_class # already a Constant, IE: PostController
+      @app_meth = app_meth.to_sym
+    end
+
+    def run(event, context={})
+      check_private_method!
+
+      if task.lang == :ruby
+        # controller = PostsController.new(event, content)
+        # resp = controller.edit
+        run_ruby_code(event, context)
+      else
+        executor = LambdaExecutor.new(task)
+        resp = executor.run(event, context)
+        if resp["errorMessage"]
+          raise_error(resp)
+        end
+        resp
+      end
+    end
+
+    def run_ruby_code(event, context)
+      @app_class.process(event, context, @app_meth)
+    rescue Exception => e
+      Jets.on_exception(e)
+      raise(e)
+    end
+
+    def raise_error(resp)
+      backtrace = resp["stackTrace"] + caller
+      backtrace = backtrace.map { |l| l.sub(/^\s+/,'') }
+      # Adjust the paths from the tmp path to the app path to improve user debugging
+      # experience. Example:
+      # From:
+      #   File "/tmp/jets/lite/executor/20180917-16777-43a9e48/app/controllers/jets/public_controller/python/show.py", line 32
+      # To:
+      #   File "app/controllers/jets/public_controller/python/show.py", line 32      backtrace =
+      backtrace = backtrace.map do |l|
+        if l.include?(Jets.build_root) && !l.include?("lambda_executor.")
+          l.sub(/\/tmp\/jets.*executor\/\d{8}-+.*?\//, '')
+        else
+          l
+        end
+      end
+
+      # IE: Jets::PolyFun::PythonError
+      error_class = "Jets::PolyFun::#{task.lang.to_s.classify}Error".constantize
+      raise error_class.new(resp["errorMessage"], backtrace)
+    end
+
+    def task
+      task = @app_class.all_public_tasks[@app_meth]
+      # Provider user a better error message to user than a nil failure.
+      unless task
+        raise "Unable to find #{@app_class}##{@app_meth}"
+      end
+      task
+    end
+    memoize :task
+
+    def check_private_method!
+      private_detected = @app_class.all_private_tasks.keys.include?(@app_meth)
+      return unless private_detected # Ok to continue
+
+      raise "The #{@app_class}##{@app_meth} is a private method.  Unable to call it unless it is public"
+    end
+  end
+end