jets_bb_fork 0.0.4

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

@@ -0,0 +1,13 @@
+module Jets::CommonMethods
+  extend Memoist
+  # Add API Gateway Stage Name
+  def add_stage_name(url)
+    Jets::Controller::Stage.add(request.host, url)
+  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

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,73 @@
+module Jets
+  class PolyFun
+    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.camelize}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

data/lib/jets/poly_fun/base_executor.rb

@@ -0,0 +1,125 @@
+require 'open3'
+require 'tmpdir'
+
+class Jets::PolyFun
+  class BaseExecutor
+    extend Memoist
+
+    def initialize(task)
+      @task = task
+    end
+
+    # Handler is in properties:
+    # 1. copy lambda function into tmp folder
+    # 2. generate Lang wrapper script
+    # 3. call wrapper script from ruby. Handle stdout and stderr and result. Pass info back to ruby
+    def run(event, context)
+      @temp_dir = create_tmpdir
+      copy_src_to_temp
+      write(code)
+      result = run_lambda_executor(event, context)
+      cleanup
+      result
+    end
+
+    def write(code)
+      puts "lambda_executor_script #{lambda_executor_script}" if ENV['KEEP_LAMBDA_WRAPPER']
+      IO.write(lambda_executor_script, code)
+    end
+
+    # Mimic Dir.mktmpdir randomness, not using Dir.mktmpdir because that generates
+    # the folder at the /tmp level only.
+    def create_tmpdir
+      random = "#{Time.now.strftime("%Y%d%H")}-#{Process.pid}-#{SecureRandom.hex[0..6]}"
+      tmpdir = "#{Jets.build_root}/executor/#{random}"
+      FileUtils.mkdir_p(tmpdir)
+      tmpdir
+    end
+
+    def copy_src_to_temp
+      app_class = @task.class_name.constantize
+      internal = app_class.respond_to?(:internal) && app_class.internal
+      src = internal ?
+        "#{File.expand_path("../internal", File.dirname(__FILE__))}/#{@task.poly_src_path}" :
+        "#{Jets.root}/#{@task.poly_src_path}"
+      dest = "#{@temp_dir}/#{@task.poly_src_path}"
+
+      FileUtils.mkdir_p(File.dirname(dest))
+      FileUtils.cp(src, dest)
+    end
+
+    def lambda_executor_script
+      File.dirname("#{@temp_dir}/#{@task.poly_src_path}") + "/lambda_executor" + @task.lang_ext
+    end
+
+    # When polymorphic method errors, this method reproduces an error in the lambda format
+    # Here's some examples to help example:
+    #
+    # Example of what the raw python prints out to stderr:
+    #
+    #   Traceback (most recent call last):
+    #     File "/tmp/jets/lite/executor/20180804-10727-mcs6qk/lambda_executor.py", line 6, in <module>
+    #       resp = handle(event, context)
+    #     File "/tmp/jets/lite/executor/20180804-10727-mcs6qk/index.py", line 22, in handle
+    #       return response({'message': e.message}, 400)
+    #     File "/tmp/jets/lite/executor/20180804-10727-mcs6qk/index.py", line 5, in response
+    #       badcode
+    #   NameError: global name 'badcode' is not defined
+    #
+    # So last line has the error summary info.  Other lines have stack trace after the Traceback indicator.
+    #
+    # Example of the reproduced lambda error format:
+    #
+    #   {
+    #     "errorMessage": "'NameError' object has no attribute 'message'",
+    #     "errorType": "AttributeError",
+    #     "stackTrace": [
+    #       [
+    #         "/var/task/handlers/controllers/posts_controller/python/index.py",
+    #         22,
+    #         "handle",
+    #         "return response({'message': e.message}, 400)"
+    #       ]
+    #     ]
+    #   }
+    #
+    def run_lambda_executor(event, context)
+      interpreter = @task.lang
+      command = %Q|#{interpreter} #{lambda_executor_script} '#{JSON.dump(event)}' '#{JSON.dump(context)}'|
+      stdout, stderr, status = Open3.capture3(command)
+      # puts "=> #{command}".color(:green)
+      # puts "stdout #{stdout}"
+      # puts "stderr #{stderr}"
+      # puts "status #{status}"
+      if status.success?
+        stdout
+      else
+        # We'll mimic the way lambda displays an error.
+        # $stderr.puts(stderr) # uncomment to debug
+        error_lines = stderr.split("\n")
+        error_message = error_lines.pop
+        error_type = error_message.split(':').first
+        error_lines.shift # remove first line that has the Traceback
+        stack_trace = error_lines.reverse # python shows stack trace in opposite order from ruby
+        JSON.dump(
+          "errorMessage" => error_message,
+          "errorType" => error_type, # hardcode
+          "stackTrace" => stack_trace
+        )
+      end
+    end
+
+    def cleanup
+      FileUtils.rm_rf(@temp_dir) unless ENV['KEEP_LAMBDA_WRAPPER']
+    end
+
+    def handler
+      # Must use the generated CloudFormation template to get the handler because
+      # the handler is derived from mutiple sources.
+      resource = Jets::Resource::Lambda::Function.new(@task)
+      full_handler = resource.properties["Handler"] # full handler here
+      File.extname(full_handler).sub(/^./,'') # the extension of the full handler is the handler
+    end
+    memoize :handler
+  end
+end

data/lib/jets/poly_fun/lambda_executor.rb

@@ -0,0 +1,16 @@
+require 'json'
+
+class Jets::PolyFun
+  class LambdaExecutor
+    def initialize(task)
+      @task = task
+    end
+
+    def run(event, context)
+      executor_class = "Jets::PolyFun::#{@task.lang.capitalize}Executor".constantize
+      executor = executor_class.new(@task)
+      text = executor.run(event, context)
+      JSON.load(text)
+    end
+  end
+end

data/lib/jets/poly_fun/node_error.rb

@@ -0,0 +1,8 @@
+class Jets::PolyFun
+  class NodeError < StandardError
+    def initialize(message, backtrace)
+      super(message)
+      set_backtrace(backtrace)
+    end
+  end
+end

data/lib/jets/poly_fun/node_executor.rb

@@ -0,0 +1,54 @@
+class Jets::PolyFun
+  class NodeExecutor < BaseExecutor
+    # Code for wrapper script that mimics lambda execution. Wrapper script usage:
+    #
+    #   node WRAPPER_SCRIPT EVENT
+    #
+    # Example:
+    #
+    #   node /tmp/jets/demo/executor/20180804-12816-imqb9/lambda_executor.js '{}'
+    #
+    def code
+      if async_syntax?
+        async_code
+      else
+        callback_code
+      end
+    end
+
+    # https://docs.aws.amazon.com/lambda/latest/dg/nodejs-prog-model-handler.html
+    def async_syntax?
+      app_path = "#{Jets.root}/" + @task.handler_path.sub('handlers/', 'app/')
+      source_code = IO.read(app_path)
+      source_code.match(/=\s*async.*\(/)
+    end
+
+    def async_code
+      <<-EOL
+var event = process.argv[2]
+event = JSON.parse(event)
+var context = {}
+
+var app = require("./#{@task.meth}.js")
+app.#{handler}(event, context).then(resp => console.log(JSON.stringify(resp)))
+EOL
+    end
+
+
+    def callback_code
+      <<-EOL
+function callback(error, response) {
+  var text = JSON.stringify(response)
+  console.log(text)
+}
+
+var event = process.argv[2]
+event = JSON.parse(event)
+var context = {}
+
+var app = require("./#{@task.meth}.js")
+var resp = app.#{handler}(event, context, callback)
+EOL
+    end
+  end
+end

data/lib/jets/poly_fun/python_error.rb

@@ -0,0 +1,8 @@
+class Jets::PolyFun
+  class PythonError < StandardError
+    def initialize(message, backtrace)
+      super(message)
+      set_backtrace(backtrace)
+    end
+  end
+end

data/lib/jets/poly_fun/python_executor.rb

@@ -0,0 +1,23 @@
+class Jets::PolyFun
+  class PythonExecutor < BaseExecutor
+    # Code for wrapper script that mimics lambda execution. Wrapper script usage:
+    #
+    #   python WRAPPER_SCRIPT EVENT
+    #
+    # Example:
+    #
+    #   python /tmp/jets/demo/executor/20180804-12816-imqb9/lambda_executor.py '{}'
+    def code
+      <<-EOL
+import sys
+import json
+from #{@task.meth} import #{handler}
+event = json.loads(sys.argv[1])
+context = {}
+resp = #{handler}(event, context)
+result = json.dumps(resp)
+print(result)
+EOL
+    end
+  end
+end

data/lib/jets/preheat.rb

@@ -0,0 +1,117 @@
+module Jets
+  class Preheat
+    extend Memoist
+
+    # Examples:
+    #
+    #   Jets::Preheat.warm("posts_controller-index")
+    #   Jets::Preheat.warm("jets-preheat_job-warm")
+    #
+    def self.warm(function_name, options={})
+      Preheat.new(options).warm(function_name)
+    end
+
+    def self.warm_all(options={})
+      Preheat.new(options).warm_all
+    end
+
+    def initialize(options)
+      @options = options # passed to Call.new options
+      @options[:mute_output] = true if @options[:mute_output].nil?
+      @options[:lambda_proxy] = false # do not transform controller event from {"event": "1"} to {"queryStringParameters":{"_prewarm":"1"}}
+    end
+
+    # Makes remote call to the Lambda function.
+    def warm(function_name)
+      Jets::Commands::Call.new(function_name, '{"_prewarm": "1"}', @options).run unless ENV['TEST']
+    end
+
+    # Loop through all methods for each class and makes special prewarm call to each method.
+    def warm_all
+      threads = []
+      all_functions.each do |function_name|
+        next if function_name.include?('jets-public_controller') # handled by warm_public_controller_more
+        next if function_name.include?('jets-rack_controller') # handled by warm_rack_controller_more
+        threads << Thread.new do
+          warm(function_name)
+        end
+      end
+      threads.each { |t| t.join }
+
+      # Warm the these controllers more since they can be hit more often
+      warm_public_controller_more
+      warm_rack_controller_more
+
+      # return the funciton names so we can see in the Lambda console
+      # the functions being prewarmed
+      all_functions
+    end
+
+    def warm_public_controller_more
+      function_name = 'jets-public_controller-show' # key function name
+      return unless all_functions.include?(function_name)
+
+      public_ratio = Jets.config.prewarm.public_ratio
+      return if public_ratio == 0
+
+      puts "Prewarming the public controller extra at a ratio of #{public_ratio}" unless @options[:mute]
+
+      threads = []
+      public_ratio.times do
+        threads << Thread.new do
+          warm(function_name)
+        end
+      end
+      threads.each { |t| t.join }
+    end
+
+    def warm_rack_controller_more
+      return unless Jets.rack?
+      function_name = 'jets-rack_controller-process' # key function name
+      return unless all_functions.include?(function_name)
+
+      rack_ratio = Jets.config.prewarm.rack_ratio
+      return if rack_ratio == 0
+
+      puts "Prewarming the rack controller extra at a ratio of #{rack_ratio}" unless @options[:mute]
+
+      threads = []
+      rack_ratio.times do
+        threads << Thread.new do
+          warm(function_name)
+        end
+      end
+      threads.each { |t| t.join }
+    end
+
+    # Returns:
+    #   [
+    #     "posts_controller-index",
+    #     "posts_controller-show",
+    #     ...
+    #   ]
+    def all_functions
+      classes.map do |klass|
+        tasks = klass.tasks.select { |t| t.lang == :ruby } # only prewarm ruby functions
+        tasks.map do |task|
+          meth = task.meth
+          underscored = klass.to_s.underscore.gsub('/','-')
+          "#{underscored}-#{meth}" # function_name
+        end
+      end.flatten.uniq.compact
+    end
+    memoize :all_functions
+
+    def classes
+      Jets::Commands::Build.app_files.map do |path|
+        next if path.include?("preheat_job.rb") # dont want to cause an infinite loop, just in case
+        next unless path =~ %r{app/controllers} # only prewarm controllers
+
+        class_path = path.sub(%r{.*app/\w+/},'').sub(/\.rb$/,'')
+        class_name = class_path.camelize
+        # IE: PostsController
+        class_name.constantize # load app/**/* class definition
+      end.compact
+    end
+  end
+end