jets 0.2.0 → 0.5.0

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,72 @@
+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?
+    end
+
+    def warm(function_name)
+      Jets::Commands::Call.new(function_name, '{"_prewarm": "1"}', @options).run unless ENV['TEST']
+    end
+
+    # loop through all methods fo each class
+    # make the special prewarm call to keep them warm
+    def warm_all
+      threads = []
+      all_functions.each do |function_name|
+        threads << Thread.new do
+          warm(function_name)
+        end
+      end
+      threads.each { |t| t.join }
+      # return the funciton names so we can see in the Lambda console
+      # the functions being prewarmed
+      all_functions
+    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
+        next if path =~ %r{app/functions} # dont support app/functions
+
+        class_path = path.sub(%r{.*app/\w+/},'').sub(/\.rb$/,'')
+        class_name = class_path.classify
+        # IE: PostsController
+        class_name.constantize # load app/**/* class definition
+      end.compact
+    end
+  end
+end

data/lib/jets/processors.rb

@@ -0,0 +1,4 @@
+module Jets::Processors
+  autoload :Deducer, 'jets/processors/deducer'
+  autoload :MainProcessor, 'jets/processors/main_processor'
+end

data/lib/jets/processors/deducer.rb

@@ -0,0 +1,54 @@
+# Jets::Processors::Deducer class figures out information that allows the
+# controller or job to be called. Sme key methods for deducer:
+#
+#   code - code to instance eval.  IE: PostsController.new(event, context).index
+#   path - full path to the app code. IE: #{Jets.root}app/controllers/posts_controller.rb
+#
+class Jets::Processors::Deducer
+  def initialize(handler)
+    @handler = handler # handlers/controllers/posts.show
+    # @handler_path: "handlers/controllers/posts"
+    # @handler_method: "show"
+    @handler_path, @handler_method = @handler.split('.')
+  end
+
+  def code
+    # code: "PostsController.process(event, context, meth: "show")"
+    # code: "HardJob.process(event, context, meth: "dig")"
+    %|#{class_name}.process(event, context, "#{@handler_method}")|
+  end
+
+  # Input: @handler_path: handlers/jobs/hard_job.rb
+  # Output: #{Jets.root/app/jobs/hard_job.rb
+  def path
+    Jets.root.to_s + @handler_path.sub("handlers", "app") + ".rb"
+  end
+
+  # process_type is key. It can be either "controller" or "job". It is used to
+  # deduce the rest of the methods: code, path.
+  def process_type
+    @handler.split('/')[1].singularize # controller or job
+  end
+
+  # Example underscored_class_name:
+  #   class_name = underscored_class_name
+  #   class_name = class_name # PostsController
+  def class_name
+    regexp = Regexp.new(".*handlers/#{process_type.pluralize}/")
+    # Example regexp:
+    #   /.*handlers\/controllers\//
+    #   /.*handlers\/jobs\//
+    class_name = @handler_path.sub(regexp, "")
+    # Example class names:
+    #   posts_controller
+    #   hard_job
+    #   hello
+    #   hello_function
+
+    class_name.classify
+  end
+
+  def load_class
+    Jets::Klass.from_path(path)
+  end
+end

data/lib/jets/processors/main_processor.rb

@@ -0,0 +1,57 @@
+require 'json'
+
+# Node shim calls this class to process both controllers and jobs
+class Jets::Processors::MainProcessor
+  attr_reader :event, :context, :handler
+  def initialize(event, context, handler)
+    # assume valid json from Lambda
+    @event = JSON.parse(event)
+    @context = JSON.parse(context)
+    @handler = handler
+  end
+
+  def run
+    # Use the handler to deduce app code to run.
+    # Example handlers: handlers/controllers/posts.create, handlers/jobs/sleep.perform
+    #
+    #   deducer = Jets::Processors::Deducer.new("handlers/controllers/posts.create")
+    #
+    deducer = Jets::Processors::Deducer.new(handler)
+    begin
+      # Examples:
+      #   deducer.code => PostsController.process(event, context, "show")
+      #   deducer.path => app/controllers/posts_controller.rb
+      #
+      #   deducer.code => HardJob.process(event, context, "dig")
+      #   deducer.path => app/jobs/hard_job.rb
+      #
+      #   deducer.code => HelloFunction.process(event, context, "world")
+      #   deducer.path => app/functions/hello.rb
+      deducer.load_class
+      result = instance_eval(deducer.code, deducer.path)
+      # result = PostsController.process(event, context, "create")
+
+      # Puts the return value of project code to stdout because this is
+      # what eventually gets used by API Gateway.
+      # Explicitly using $stdout since puts has been redirected to $stderr.
+      #
+      # JSON.dump is pretty robust.  If it cannot dump the structure into a
+      # json string, it just dumps it to a plain text string.
+      Jets::Util.normalize_result(result) # String
+    rescue Exception => e
+      # Customize error message slightly so nodejs shim can process the
+      # returned error message.
+      # The "RubyError: " is a marker that the javascript shim scans for.
+      $stderr.puts("RubyError: #{e.class}: #{e.message}") # js needs this as the first line
+      backtrace = e.backtrace.map {|l| "  #{l}" }
+      $stderr.puts(backtrace)
+      # No need to having error in stderr above anymore because errors are handled in memory
+      # at ruby_server.rb but keeping around for posterity.
+
+      raise # raise error to ruby_server.rb to rescue and handle
+
+      # $stderr.puts("END OF RUBY OUTPUT") # uncomment for debugging
+    end
+  end
+
+end

data/lib/jets/rails_overrides.rb

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

data/lib/jets/rails_overrides/asset_tag_helper.rb

@@ -0,0 +1,41 @@
+# Override to prepend stage name when on AWS.
+module Jets::AssetTagHelper
+  include Jets::CommonMethods
+
+  def javascript_include_tag(*sources, **options)
+    sources = sources.map { |s| stage_name_asset_url(s, :javascripts) }
+    super
+  end
+
+  def stylesheet_link_tag(*sources, **options)
+    sources = sources.map { |s| stage_name_asset_url(s, :stylesheets) }
+    super
+  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 stage_name_asset_url(url, asset_type)
+    unless url.starts_with?('/') or url.starts_with?('http')
+      url = "/#{asset_type}/#{url}" # /javascript/asset/test
+    end
+    url = add_stage_name(url)
+    url
+  end
+end
+ActionView::Helpers.send(:include, Jets::AssetTagHelper)

data/lib/jets/rails_overrides/common_methods.rb

@@ -0,0 +1,13 @@
+module Jets::CommonMethods
+  # Add API Gateway Stage Name
+  def add_stage_name(url)
+    if request.host.include?("amazonaws.com") &&
+            url.starts_with?('/') &&
+            !url.starts_with?('http')
+      stage_name = Jets::Cfn::TemplateMappers::ApiGatewayDeploymentMapper.stage_name
+      url = "/#{stage_name}#{url}"
+    end
+
+    url
+  end
+end

data/lib/jets/rails_overrides/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/rails_overrides/url_helper.rb

@@ -0,0 +1,26 @@
+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
+
+    url = add_stage_name(url)
+    url
+  end
+end # UrlHelper
+ActionView::Helpers.send(:include, Jets::UrlHelper)

data/lib/jets/route.rb

@@ -0,0 +1,145 @@
+# route = Jets::Route.new(
+#   path: "posts",
+#   method: :get,
+#   to: "posts#index",
+# )
+class Jets::Route
+  def initialize(options)
+    @options = options
+  end
+
+  # IE: standard: posts/:id/edit
+  #     api_gateway: posts/{id}/edit
+  def path(format=:jets)
+    case format
+    when :api_gateway
+      api_gateway_format(@options[:path])
+    when :raw
+      @options[:path]
+    else # jets format
+      ensure_jets_format(@options[:path])
+    end
+  end
+
+  def method
+    @options[:method].to_s.upcase
+  end
+
+  # IE: posts#index
+  def to
+    @options[:to]
+  end
+
+  def internal?
+    !!@options[:internal]
+  end
+
+  def homepage?
+    path == ''
+  end
+
+  # IE: PostsController
+  def controller_name
+    to.sub(/#.*/,'').camelize + "Controller"
+  end
+
+  # IE: index
+  def action_name
+    to.sub(/.*#/,'')
+  end
+
+  # Extracts the path parameters from the actual path
+  # Only supports extracting 1 parameter. So:
+  #
+  #   actual_path: posts/tung/edit
+  #   route.path: posts/:id/edit
+  #
+  # Returns:
+  #    { id: "tung" }
+  def extract_parameters(actual_path)
+    if path.include?(':')
+      extract_parameters_capture(actual_path)
+    elsif path.include?('*')
+      extract_parameters_proxy(actual_path)
+    else
+      # Lambda AWS_PROXY sets null to the input request when there are no path parmeters
+      nil
+    end
+  end
+
+  def extract_parameters_proxy(actual_path)
+    # changes path to a string used for a regexp
+    # others/*proxy => others\/(.*)
+    # nested/others/*proxy => nested/others\/(.*)
+    if path.include?('/')
+      leading_path = path.split('/')[0..-2].join('/') # drop last segment
+      # leading_path: nested/others
+      # capture everything after the leading_path as the value
+      regexp = Regexp.new("#{leading_path}/(.*)")
+      value = actual_path.match(regexp)[1]
+    else
+      value = actual_path
+    end
+
+    # the last segment without the '*' is the key
+    proxy_segment = path.split('/').last # last segment is the proxy segment
+    # proxy_segment: *proxy
+    key = proxy_segment.sub('*','')
+
+    { key => value }
+  end
+
+  def extract_parameters_capture(actual_path)
+    # changes path to a string used for a regexp
+    # posts/:id/edit => posts\/(.*)\/edit
+    regexp_string = path.split('/').map do |s|
+                      s.include?(':') ? "([a-zA-Z0-9_]*)" : s
+                    end.join('\/')
+    # make sure beginning and end of the string matches
+    regexp_string = "^#{regexp_string}$"
+    regexp = Regexp.new(regexp_string)
+    value = regexp.match(actual_path)[1]
+
+    # only supports one path parameter key right now
+    key = path.split('/').find {|s| s.include?(':') } # :id
+    key = key.sub(':','')
+
+    { key => value }
+  end
+
+private
+  def ensure_jets_format(path)
+    path.split('/').map do |s|
+      if s =~ /^\{/ and s =~ /\+\}$/
+        s.sub(/^\{/, '*').sub(/\+\}$/,'') # {proxy+} => *proxy
+      elsif s =~ /^\{/ and s =~ /\}$/
+        s.sub('{',':').sub(/\}$/,'') # {id} => :id
+      else
+        s
+      end
+    end.join('/')
+  end
+
+  def api_gateway_format(path)
+    path.split('/')
+      .map {|s| transform_capture(s) }
+      .map {|s| transform_proxy(s) }
+      .join('/')
+  end
+
+  def transform_capture(text)
+    if text.starts_with?(':')
+      text = text.sub(':','')
+      text = "{#{text}}"
+    end
+    text
+  end
+
+  def transform_proxy(text)
+    if text.starts_with?('*')
+      text = text.sub('*','')
+      text = "{#{text}+}"
+    end
+    text
+  end
+end