jets 5.0.14 → 6.0.0.beta1

data/lib/jets/mega/request.rb

@@ -1,163 +0,0 @@
-require 'net/http'
-require 'rack'
-
-module Jets::Mega
-  class Request
-    JETS_OUTPUT = "/tmp/jets-output.log"
-
-    extend Memoist
-
-    def initialize(event, controller)
-      @event = event
-      @controller = controller # Jets::Controller instance
-    end
-
-    def proxy
-      http_method = @event['httpMethod'] # GET, POST, PUT, DELETE, etc
-      params = @controller.params(include_path_params: false)
-
-      uri = get_uri
-
-      http = Net::HTTP.new(uri.host, uri.port)
-      http.open_timeout = http.read_timeout = 60
-
-      # Jets sets _method=patch or _method=put as workaround
-      # Falls back to GET when testing in lambda console
-      http_class = params['_method'] || http_method || 'GET'
-      http_class.capitalize!
-
-      request_class = "Net::HTTP::#{http_class}".constantize # IE: Net::HTTP::Get
-      request = request_class.new(uri)
-
-      # Set form data
-      if %w[Post Patch Put].include?(http_class)
-        params = HashConverter.encode(params)
-        request.set_form_data(params)
-      end
-
-      # Set body info
-      request.body = source.body
-      request.content_length = source.content_length
-
-      # Need to set headers after body and form_data for some reason
-      request = set_headers!(request)
-
-      # Make request
-      response = send_request(http, request)
-
-      puts_rack_output
-
-      status = response.code.to_i
-      headers = response.each_header.to_h
-      encoding = get_encoding(headers['content-type'])
-      body = response.body&.force_encoding(encoding)
-      {
-        status: status,
-        headers: headers,
-        body: body,
-      }
-    end
-
-    # Adds error handling in case the rack server has gone down. Will try to start the server back up if needed.
-    # Search CloudWatch logs for 'Unable to send request' to find for indication of this.
-    def send_request(http, request)
-      retries = 0
-      max_retries = 30 # 15 seconds at a delay of 0.5s
-      delay = 0.5
-
-      begin
-        http.request(request) # response
-      rescue Errno::ECONNREFUSED, Errno::EAFNOSUPPORT
-        puts "Unable to send request to localhost:9292. Will try to start the server with a delay of #{delay} and try again."
-        Jets.start_rack_server
-
-        sleep(delay)
-        retries += 1
-        if retries < max_retries
-          retry
-        else
-          puts "Giving up on trying to send request to localhost:9292"
-          raise # re-raise error
-        end
-      end
-    end
-
-    def get_encoding(content_type)
-      default = Jets.config.encoding.default
-      return default unless content_type
-
-      md = content_type.match(/charset=(.+)/)
-      return default unless md
-
-      md[1]
-    end
-
-    # Grab the rack output from the /tmp/jets-output.log and puts it back in the
-    # main process' stdout
-    def puts_rack_output
-      return unless File.exist?(JETS_OUTPUT)
-      puts IO.readlines(JETS_OUTPUT)
-      File.truncate(JETS_OUTPUT, 0)
-    end
-
-    def get_uri
-      url = "http://localhost:9292#{@controller.request.path}" # local rack server
-      unless @controller.query_parameters.empty?
-        # Thanks: https://stackoverflow.com/questions/798710/ruby-how-to-turn-a-hash-into-http-parameters
-        query_string = Rack::Utils.build_nested_query(@controller.query_parameters)
-        url += "?#{query_string}"
-      end
-      URI(url)
-    end
-
-    def source
-      Source.new(@event)
-    end
-    memoize :source
-
-    # Jets sets _method=patch or _method=put as workaround
-    # Falls back to GET when testing in lambda console
-    # @event['httpMethod'] is GET, POST, PUT, DELETE, etc
-    def http_class
-      http_class = params['_method'] || @event['httpMethod'] || 'GET'
-      http_class.capitalize!
-      http_class
-    end
-
-    def params
-      @controller.params(include_path_params: false, include_body_params: true)
-    end
-    memoize :params
-
-    # Set request headers. Forwards original request info from remote API gateway.
-    # By this time, the server/api_gateway.rb middleware.
-    def set_headers!(request)
-      headers = @event['headers'] # from api gateway
-      if headers # remote API Gateway
-        # Forward headers from API Gateway over to the sub http request.
-        # It's important to forward the headers. Here are some examples:
-        #
-        #   "Turbolinks-Referrer"=>"http://localhost:8888/posts/122",
-        #   "Referer"=>"http://localhost:8888/posts/122",
-        #   "Accept-Encoding"=>"gzip, deflate",
-        #   "Accept-Language"=>"en-US,en;q=0.9,pt;q=0.8",
-        #   "Cookie"=>"_demo_session=...",
-        #   "If-None-Match"=>"W/\"9fa479205fc6d24ca826d46f1f6cf461\"",
-        headers.each do |k,v|
-          request[k] = v
-        end
-
-        # Note by the time headers get to rack later in the they get changed to:
-        #
-        #   request['X-Forwarded-Host'] vs env['HTTP_X_FORWARDED_HOST']
-        #
-        request['X-Forwarded-For'] = headers['X-Forwarded-For'] # "1.1.1.1, 2.2.2.2" # can be comma separated list
-        request['X-Forwarded-Host'] = headers['Host'] # uhghn8z6t1.execute-api.us-east-1.amazonaws.com
-        request['X-Forwarded-Port'] = headers['X-Forwarded-Port'] # 443
-        request['X-Forwarded-Proto'] = headers['X-Forwarded-Proto'] # https # scheme
-      end
-
-      request
-    end
-  end
-end

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

@@ -1,11 +0,0 @@
-# This is a dummy Rails class that delegates to Jets.
-# It's only used for jets generate and jets db:migrate.
-# It's easier to mock out the Rails module then to get them working.
-
-module Rails
-  cattr_accessor :application
-  self.application = Jets.application
-  class << self
-    delegate :env, :root, to: Jets
-  end
-end

data/lib/jets/overrides/lambda/marshaller.rb

@@ -1,31 +0,0 @@
-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
-          # Note: Removed previous code which did force_encoding("ISO-8859-1").encode("UTF-8")
-          # It caused issues with international characters.
-          # It does not seem like we need the force_encoding anymore.
-          JSON.dump(method_response)
-        end
-      end
-    end
-  end
-end

data/lib/jets/overrides/lambda.rb

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

data/lib/jets/overrides/puma.rb

@@ -1,10 +0,0 @@
-require "puma/error_logger"
-class Puma::ErrorLogger
-  alias_method :original_title, :title
-  def title(options={})
-    string = original_title(options)
-    error = options[:error]
-    string << "\n#{error.backtrace.join("\n")}" if error
-    string
-  end
-end

data/lib/jets/paths.rb

@@ -1,243 +0,0 @@
-# frozen_string_literal: true
-
-require "pathname"
-
-module Jets
-  module Paths
-    # This object is an extended hash that behaves as root of the <tt>Jets::Paths</tt> system.
-    # It allows you to collect information about how you want to structure your application
-    # paths through a Hash-like API. It requires you to give a physical path on initialization.
-    #
-    #   root = Root.new "/jets"
-    #   root.add "app/controllers", eager_load: true
-    #
-    # The above command creates a new root object and adds "app/controllers" as a path.
-    # This means we can get a Jets::Paths::Path object back like below:
-    #
-    #   path = root["app/controllers"]
-    #   path.eager_load?               # => true
-    #   path.is_a?(Jets::Paths::Path) # => true
-    #
-    # The +Path+ object is simply an enumerable and allows you to easily add extra paths:
-    #
-    #   path.is_a?(Enumerable) # => true
-    #   path.to_ary.inspect    # => ["app/controllers"]
-    #
-    #   path << "lib/controllers"
-    #   path.to_ary.inspect    # => ["app/controllers", "lib/controllers"]
-    #
-    # Notice that when you add a path using +add+, the path object created already
-    # contains the path with the same path value given to +add+. In some situations,
-    # you may not want this behavior, so you can give <tt>:with</tt> as option.
-    #
-    #   root.add "config/routes", with: "config/routes.rb"
-    #   root["config/routes"].inspect # => ["config/routes.rb"]
-    #
-    # The +add+ method accepts the following options as arguments:
-    # eager_load, autoload, autoload_once, and glob.
-    #
-    # Finally, the +Path+ object also provides a few helpers:
-    #
-    #   root = Root.new "/jets"
-    #   root.add "app/controllers"
-    #
-    #   root["app/controllers"].expanded # => ["/jets/app/controllers"]
-    #   root["app/controllers"].existent # => ["/jets/app/controllers"]
-    #
-    # Check the <tt>Jets::Paths::Path</tt> documentation for more information.
-    class Root
-      attr_accessor :path
-
-      def initialize(path)
-        @path = path
-        @root = {}
-      end
-
-      def []=(path, value)
-        glob = self[path] ? self[path].glob : nil
-        add(path, with: value, glob: glob)
-      end
-
-      def add(path, options = {})
-        with = Array(options.fetch(:with, path))
-        @root[path] = Path.new(self, path, with, options)
-      end
-
-      def [](path)
-        @root[path]
-      end
-
-      def values
-        @root.values
-      end
-
-      def keys
-        @root.keys
-      end
-
-      def values_at(*list)
-        @root.values_at(*list)
-      end
-
-      def all_paths
-        values.tap(&:uniq!)
-      end
-
-      def autoload_once
-        filter_by(&:autoload_once?)
-      end
-
-      def eager_load
-        filter_by(&:eager_load?)
-      end
-
-      def autoload_paths
-        filter_by(&:autoload?)
-      end
-
-      def load_paths
-        filter_by(&:load_path?)
-      end
-
-    private
-      def filter_by(&block)
-        all_paths.find_all(&block).flat_map { |path|
-          paths = path.existent
-          paths - path.children.flat_map { |p| yield(p) ? [] : p.existent }
-        }.uniq
-      end
-    end
-
-    class Path
-      include Enumerable
-
-      attr_accessor :glob
-
-      def initialize(root, current, paths, options = {})
-        @paths   = paths
-        @current = current
-        @root    = root
-        @glob    = options[:glob]
-        @exclude = options[:exclude]
-
-        options[:autoload_once] ? autoload_once! : skip_autoload_once!
-        options[:eager_load]    ? eager_load!    : skip_eager_load!
-        options[:autoload]      ? autoload!      : skip_autoload!
-        options[:load_path]     ? load_path!     : skip_load_path!
-      end
-
-      def absolute_current # :nodoc:
-        File.expand_path(@current, @root.path)
-      end
-
-      def children
-        keys = @root.keys.find_all { |k|
-          k.start_with?(@current) && k != @current
-        }
-        @root.values_at(*keys.sort)
-      end
-
-      def first
-        expanded.first
-      end
-
-      def last
-        expanded.last
-      end
-
-      %w(autoload_once eager_load autoload load_path).each do |m|
-        class_eval <<-RUBY, __FILE__, __LINE__ + 1
-          def #{m}!        # def eager_load!
-            @#{m} = true   #   @eager_load = true
-          end              # end
-                           #
-          def skip_#{m}!   # def skip_eager_load!
-            @#{m} = false  #   @eager_load = false
-          end              # end
-                           #
-          def #{m}?        # def eager_load?
-            @#{m}          #   @eager_load
-          end              # end
-        RUBY
-      end
-
-      def each(&block)
-        @paths.each(&block)
-      end
-
-      def <<(path)
-        @paths << path
-      end
-      alias :push :<<
-
-      def concat(paths)
-        @paths.concat paths
-      end
-
-      def unshift(*paths)
-        @paths.unshift(*paths)
-      end
-
-      def to_ary
-        @paths
-      end
-
-      def paths
-        raise "You need to set a path root" unless @root.path
-
-        map do |p|
-          Pathname.new(@root.path).join(p)
-        end
-      end
-
-      def extensions # :nodoc:
-        $1.split(",") if @glob =~ /\{([\S]+)\}/
-      end
-
-      # Expands all paths against the root and return all unique values.
-      def expanded
-        raise "You need to set a path root" unless @root.path
-        result = []
-
-        each do |path|
-          path = File.expand_path(path, @root.path)
-
-          if @glob && File.directory?(path)
-            result.concat files_in(path)
-          else
-            result << path
-          end
-        end
-
-        result.uniq!
-        result
-      end
-
-      # Returns all expanded paths but only if they exist in the filesystem.
-      def existent
-        expanded.select do |f|
-          does_exist = File.exist?(f)
-
-          if !does_exist && File.symlink?(f)
-            raise "File #{f.inspect} is a symlink that does not point to a valid file"
-          end
-          does_exist
-        end
-      end
-
-      def existent_directories
-        expanded.select { |d| File.directory?(d) }
-      end
-
-      alias to_a expanded
-
-      private
-        def files_in(path)
-          files = Dir.glob(@glob, base: path)
-          files -= @exclude if @exclude
-          files.map! { |file| File.join(path, file) }
-          files.sort
-        end
-    end
-  end
-end

data/lib/jets/poly/base_executor.rb

@@ -1,125 +0,0 @@
-require 'open3'
-require 'tmpdir'
-
-class Jets::Poly
-  class BaseExecutor
-    extend Memoist
-
-    def initialize(definition)
-      @definition = definition
-    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 = @definition.class_name.constantize
-      internal = app_class.respond_to?(:internal) && app_class.internal
-      src = internal ?
-        "#{File.expand_path("../internal", File.dirname(__FILE__))}/#{@definition.poly_src_path}" :
-        "#{Jets.root}/#{@definition.poly_src_path}"
-      dest = "#{@temp_dir}/#{@definition.poly_src_path}"
-
-      FileUtils.mkdir_p(File.dirname(dest))
-      FileUtils.cp(src, dest)
-    end
-
-    def lambda_executor_script
-      File.dirname("#{@temp_dir}/#{@definition.poly_src_path}") + "/lambda_executor" + @definition.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/definition/handlers/controllers/posts_controller/python/index.py",
-    #         22,
-    #         "handle",
-    #         "return response({'message': e.message}, 400)"
-    #       ]
-    #     ]
-    #   }
-    #
-    def run_lambda_executor(event, context)
-      interpreter = @definition.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,
-          "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::Cfn::Resource::Lambda::Function.new(@definition)
-      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/lambda_executor.rb

@@ -1,16 +0,0 @@
-require 'json'
-
-class Jets::Poly
-  class LambdaExecutor
-    def initialize(task)
-      @task = task
-    end
-
-    def run(event, context)
-      executor_class = "Jets::Poly::#{@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/node_error.rb

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

data/lib/jets/poly/node_executor.rb

@@ -1,54 +0,0 @@
-class Jets::Poly
-  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}/" + @definition.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("./#{@definition.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("./#{@definition.meth}.js")
-var resp = app.#{handler}(event, context, callback)
-EOL
-    end
-  end
-end

data/lib/jets/poly/python_error.rb

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