jets_bb_fork 0.0.4

data/lib/jets/lambda/function.rb

@@ -0,0 +1,29 @@
+module Jets::Lambda
+  class Function < Functions
+    # Override and change the signature so we do not have to provide info at
+    # initialization. So:
+    #
+    #   hello_function = HelloFunction.new
+    #   hello_function.lambda_handler(event, context)
+    #
+    # Normally controller and job functions initialize like this:
+    #
+    #   controller = PostController.new(event, context, "handler_handler")
+    def initialize
+    end
+
+    def self.handler
+      handler_task.meth
+    end
+
+    def self.handler_task
+      tasks.first
+    end
+
+    # Used by main_processor.rb.  Same interface as controllers and jobs.
+    def self.process(event, context, meth)
+      function = new
+      function.send(handler, event, context)
+    end
+  end
+end

data/lib/jets/lambda/function_constructor.rb

@@ -0,0 +1,55 @@
+# Builds an anonymous class that represents a single Lambda function from code
+# in app/functions.
+#
+# The build method returns an anonymous class using Class.new that contains
+# the methods defined in the app/functions/hello.rb code.
+#
+# Ruby Class.new docs:
+#
+# Creates a new anonymous (unnamed) class with the given superclass (or
+# Object if no parameter is given). You can give a class a name by
+# assigning the class object to a constant.
+# http://ruby-doc.org/core-2.1.1/Class.html#method-c-new
+#
+# So assigning the result of build to a constant makes for a prettier
+# class name. Example:
+#
+#   constructor = FunctionConstructor.new(code_path)
+#   HelloFunction = constructor.build
+#
+# The class name will be HelloFunction instead of (anonymous). Then usage would
+# be:
+#
+#   hello_function = HelloFunction.new
+#   hello_function(hello_function.handler, event, context)
+#
+# Or call with the process class method:
+#
+#   HelloFunction.process(event, context, "world")
+module Jets::Lambda
+  class FunctionConstructor
+    def initialize(code_path)
+      @code_path = "#{Jets.root}/#{code_path}"
+    end
+
+    def build
+      code = IO.read(@code_path)
+      function_klass = Class.new(Jets::Lambda::Function)
+      function_klass.module_eval(code)
+      adjust_tasks(function_klass)
+      function_klass # assign this to a Constant for a pretty class name
+    end
+
+    # For anonymous classes method_added during task registration contains ""
+    # for the class name.  We adjust it here.
+    def adjust_tasks(klass)
+      class_name = @code_path.to_s.sub(/.*\/functions\//,'').sub(/\.rb$/, '')
+      class_name = class_name.camelize
+      klass.tasks.each do |task|
+        task.class_name = class_name
+        task.type = "function"
+      end
+    end
+  end
+end
+

data/lib/jets/lambda/functions.rb

@@ -0,0 +1,34 @@
+require 'json'
+
+# Jets::Lambda::Functions represents a collection of Lambda functions.
+#
+# Jets::Lambda::Functions is the superclass of:
+#   Jets::Controller::Base
+#   Jets::Job::Base
+module Jets::Lambda
+  class Functions
+    attr_reader :event, :context, :meth
+    def initialize(event, context, meth)
+      @event = event # Hash, JSON.parse(event) ran BaseProcessor
+      @context = context # Hash. JSON.parse(context) ran in BaseProcessor
+      @meth = meth
+      # store meth because it is useful to for identifying the which template
+      # to use later.
+    end
+
+    include Dsl # At the end so methods like event, context and method
+      # do not trigger method_added
+
+    class << self
+      # Tracking subclasses because it helps with Lambda::Dsl#find_all_tasks
+      def subclasses
+        @subclasses ||= []
+      end
+
+      def inherited(base)
+        super
+        self.subclasses << base if base.name
+      end
+    end
+  end
+end

data/lib/jets/lambda/task.rb

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

@@ -0,0 +1,21 @@
+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/mega/hash_converter.rb

@@ -0,0 +1,25 @@
+# Thanks https://mensfeld.pl/2012/01/converting-nested-hash-into-http-url-params-hash-version-in-ruby/
+module Jets::Mega
+  module HashConverter
+    def self.encode(value, key = nil, out_hash = {})
+      case value
+      when Hash  then
+        value.each { |k,v| encode(v, append_key(key,k), out_hash) }
+        out_hash
+      when Array then
+        value.each { |v| encode(v, "#{key}[]", out_hash) }
+        out_hash
+      when nil   then ''
+      else
+        out_hash[key] = value
+        out_hash
+      end
+    end
+
+    private
+
+    def self.append_key(root_key, key)
+      root_key.nil? ? :"#{key}" : :"#{root_key}[#{key.to_s}]"
+    end
+  end
+end

data/lib/jets/mega/request.rb

@@ -0,0 +1,139 @@
+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(raw: true, path_parameters: false)
+
+      uri = get_uri
+
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = http.read_timeout = 60
+
+      # Rails 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 = http.request(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
+
+    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
+
+    # Rails 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(raw: true, path_parameters: false, body_parameters: 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/mega/request/source.rb

@@ -0,0 +1,21 @@
+class Jets::Mega::Request
+  class Source
+    def initialize(event)
+      @event = event
+      env = Jets::Controller::Rack::Env.new(@event, {}).convert # convert to Rack env
+      @source_request = Rack::Request.new(env)
+    end
+
+    def body
+      if @source_request.body.respond_to?(:read)
+        body = @source_request.body.read
+        @source_request.body.rewind
+      end
+      body
+    end
+
+    def content_length
+      @source_request.content_length.to_i
+    end
+  end
+end

data/lib/jets/middleware.rb

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