jets 0.2.0 → 0.5.0

data/lib/jets/router.rb

@@ -0,0 +1,115 @@
+require 'text-table'
+
+module Jets
+  class Router
+    attr_reader :routes
+    def initialize
+      @routes = []
+    end
+
+    def draw(&block)
+      instance_eval(&block)
+    end
+
+    # Methods supported by API Gateway
+    %w[any delete get head options patch post put].each do |method_name|
+      define_method method_name do |path, options|
+        create_route(options.merge(path: path, method: __method__))
+      end
+    end
+
+    # resources macro expands to all the routes
+    def resources(name)
+      get "#{name}", to: "#{name}#index"
+      get "#{name}/new", to: "#{name}#new"
+      get "#{name}/:id", to: "#{name}#show"
+      post "#{name}", to: "#{name}#create"
+      get "#{name}/:id/edit", to: "#{name}#edit"
+      put "#{name}/:id", to: "#{name}#update"
+      delete "#{name}/:id", to: "#{name}#delete"
+    end
+
+    def create_route(options)
+      @routes << Route.new(options)
+    end
+
+    # root "posts#index"
+    def root(to)
+      @routes << Route.new(path: '', to: to, method: :get, root: true)
+    end
+
+    # Useful for creating API Gateway Resources
+    def all_paths
+      results = []
+      paths = routes.map(&:path)
+      paths.each do |p|
+        sub_paths = []
+        parts = p.split('/')
+        until parts.empty?
+          parts.pop
+          sub_path = parts.join('/')
+          sub_paths << sub_path unless sub_path == ''
+        end
+        results += sub_paths
+      end
+      @all_paths = (results + paths).sort.uniq
+    end
+
+    # Useful for RouterMatcher
+    #
+    # Precedence:
+    # 1. Routes with no captures get highest precedence: posts/new
+    # 2. Then consider the routes with captures: post/:id
+    # 3. Last consider the routes with wildcards: *catchall
+    #
+    # Within these 2 groups we consider the routes with the longest path first
+    # since posts/:id and posts/:id/edit can both match.
+    def ordered_routes
+      length = Proc.new { |r| r.path.length * -1 }
+      capture_routes = routes.select { |r| r.path.include?(':') }.sort_by(&length)
+      wildcard_routes = routes.select { |r| r.path.include?('*') }.sort_by(&length)
+      simple_routes = (routes - capture_routes - wildcard_routes).sort_by(&length)
+      simple_routes + capture_routes + wildcard_routes
+    end
+
+    def self.has_controller?(name)
+      routes.detect { |r| r.controller_name == name }
+    end
+
+    # Class methods
+    def self.draw
+      drawn_router
+    end
+
+    @@drawn_router = nil
+    def self.drawn_router
+      return @@drawn_router if @@drawn_router
+
+      router = Jets.application.routes
+      @@drawn_router = router
+    end
+
+    def self.routes
+      drawn_router.routes
+    end
+
+    # Returns all paths including subpaths.
+    # Example:
+    # Input: ["posts/:id/edit"]
+    # Output: ["posts", "posts/:id", "posts/:id/edit"]
+    def self.all_paths
+      drawn_router.all_paths
+    end
+
+    def self.routes_help
+      return "Your routes table is empty." if routes.empty?
+
+      table = Text::Table.new
+      table.head = %w[Verb Path Controller#action]
+      routes.each do |route|
+        table.rows << [route.method, route.path, route.to]
+      end
+      table
+    end
+  end
+end

data/lib/jets/ruby_server.rb

@@ -0,0 +1,91 @@
+require 'socket'
+require 'json'
+
+# https://ruby-doc.org/stdlib-2.3.0/libdoc/socket/rdoc/TCPServer.html
+# https://stackoverflow.com/questions/806267/how-to-fire-and-forget-a-subprocess
+#
+# There's a generated bin/ruby_server which calls bin/ruby_server.rb as part of the
+# starter project template. Usage:
+#
+#    bin/ruby_server # background
+#    FOREGROUND=1 bin/ruby_server # foreground
+#
+module Jets
+  class RubyServer
+    PORT = 8080
+
+    def run
+      $stdout.sync = true
+      Jets.boot # outside of child process for COW
+
+      # INT - ^C
+      trap('INT') do
+        puts "Shutting down ruby_server.rb..."
+        sleep 0.1
+        exit
+      end
+      if ENV['FOREGROUND'] # Usage above
+        serve
+        return
+      end
+
+      # Reaching here means we'll run the server in the background
+      pid = Process.fork
+      if pid.nil?
+        serve
+      else
+        # parent process
+        Process.detach(pid)
+      end
+    end
+
+    def serve
+      # child process
+      server = TCPServer.new(8080) # Server bind to port 8080
+      puts "TCPServer started on port #{PORT}"
+      input_completed = false
+      loop do
+        event, handler = nil, nil
+        client = server.accept    # Wait for a client to connect
+        unless input_completed
+          event = client.gets.strip # text
+          # puts event # uncomment for debugging, Jets has changed stdout to stderr
+          handler = client.gets.strip # text
+          # puts handler # uncomment for debugging, Jets has changed stdout to stderr
+          input_completed = true
+        end
+
+        result = event['_prewarm'] ?
+          prewarm_request(event) :
+          standard_request(event, '{}', handler)
+
+        client.puts(result)
+        client.close
+        input_completed = false
+      end
+    end
+
+    def prewarm_request(event)
+      # JSON.dump("prewarmed_at" => Time.now.to_s)
+      %Q|{"prewarmed_at":"#{Time.now.to_s}"}| # raw json for speed
+    end
+
+    def standard_request(event, context, handler)
+      Jets::Processors::MainProcessor.new(
+        event,
+        context,
+        handler).run
+    rescue Exception => e
+      JSON.dump(
+        "stackTrace" => e.backtrace,
+        "errorMessage" => e.message,
+        "errorType" => "RubyError",
+      )
+    end
+
+    def self.run
+      new.run
+    end
+  end
+end
+

data/lib/jets/rule.rb

@@ -0,0 +1,5 @@
+class Jets::Rule
+  autoload :Dsl, "jets/rule/dsl"
+  autoload :Base, "jets/rule/base"
+  autoload :Task, "jets/rule/task"
+end

data/lib/jets/rule/base.rb

@@ -0,0 +1,19 @@
+require 'json'
+
+# Base public methods get turned into Lambda functions.
+#
+# Jets::Rule::Base < Jets::Lambda::Functions
+# Both Jets::Rule::Base and Jets::Lambda::Functions have Dsl modules included.
+# So the Jets::Rule::Dsl overrides some of the Jets::Lambda::Functions behavior.
+class Jets::Rule
+  class Base < Jets::Lambda::Functions
+    include Dsl
+
+    class << self
+      def process(event, context, meth)
+        job = new(event, context, meth)
+        job.send(meth)
+      end
+    end
+  end
+end

data/lib/jets/rule/dsl.rb

@@ -0,0 +1,64 @@
+# Jets::Rule::Base < Jets::Lambda::Functions
+# Both Jets::Rule::Base and Jets::Lambda::Functions have Dsl modules included.
+# So the Jets::Rule::Dsl overrides some of the Jets::Lambda::Functions behavior.
+module Jets::Rule::Dsl
+  extend ActiveSupport::Concern
+
+  included do
+    class << self
+      # Allows for different types of values. Examples:
+      #
+      # String: scope "AWS::EC2::SecurityGroup"
+      # Array:  scope ["AWS::EC2::SecurityGroup"]
+      # Hash:   scope {"ComplianceResourceTypes" => ["AWS::EC2::SecurityGroup"]}
+      def scope(value)
+        scope = case value
+          when String
+            {"ComplianceResourceTypes" => [value]}
+          when Array
+            {"ComplianceResourceTypes" => value}
+          else # default to hash
+            value
+          end
+
+        config_rule(scope: scope)
+      end
+
+      def config_rule_name(value)
+        config_rule(config_rule_name: value)
+      end
+
+      def description(value)
+        config_rule(description: value)
+      end
+      alias_method :desc, :description
+
+      def input_parameters(value)
+        config_rule(input_parameters: value)
+      end
+
+      def maximum_execution_frequency(value)
+        config_rule(maximum_execution_frequency: value)
+      end
+
+      # not really meant to be used but provided for completeness
+      def source(value)
+        config_rule(source: value)
+      end
+
+      def config_rule(options={})
+        @config_rule ||= {}
+        @config_rule.deep_merge!(options)
+      end
+
+      # Override register_task.
+      # Creates instances of Rule::Task instead of a Lambda::Task
+      # Also adds the config_rule option that is specific to Rule classes
+      def register_task(meth, lang=:ruby)
+        all_tasks[meth] = Jets::Rule::Task.new(self.name, meth,
+          properties: @properties, config_rule: @config_rule, lang: lang)
+        true
+      end
+    end
+  end
+end

data/lib/jets/rule/task.rb

@@ -0,0 +1,44 @@
+class Jets::Rule::Task < Jets::Lambda::Task
+  attr_reader :config_rule
+  def initialize(class_name, meth, options={})
+    super
+    @config_rule = options[:config_rule] || {}
+  end
+
+  def config_rule_name
+    @properties[:config_rule_name] || conventional_config_rule_name
+  end
+
+  def conventional_config_rule_name
+    name_without_rule = @class_name.underscore.gsub(/_rule$/,'')
+    "#{name_without_rule}_#{@meth}".dasherize
+  end
+
+  def config_rule_properties
+    props = Pascalize.pascalize(@config_rule)
+    props = config_rule_defaults.merge(props)
+    props
+  end
+
+  def config_rule_defaults
+    map = Jets::Cfn::TemplateMappers::ConfigRuleMapper.new(self)
+    source_identifier = "!GetAtt #{map.lambda_function_logical_id}.Arn"
+    {
+      "ConfigRuleName" => config_rule_name,
+      "Source" => {
+        "Owner" => "CUSTOM_LAMBDA",
+        "SourceIdentifier" => source_identifier,
+        "SourceDetails" => [
+            {
+                "EventSource" => "aws.config",
+                "MessageType" => "ConfigurationItemChangeNotification"
+            },
+            {
+                "EventSource" => "aws.config",
+                "MessageType" => "OversizedConfigurationItemChangeNotification"
+            }
+        ]
+      }
+    }
+  end
+end

data/lib/jets/server.rb

@@ -0,0 +1,16 @@
+require 'rack'
+require 'rack/server'
+require "jets/server/webpacker_setup" if Jets.webpacker?
+
+class Jets::Server
+  autoload :RouteMatcher, "jets/server/route_matcher"
+  autoload :TimingMiddleware, "jets/server/timing_middleware"
+  autoload :ApiGateway, "jets/server/api_gateway"
+  autoload :LambdaAwsProxy, "jets/server/lambda_aws_proxy"
+
+  # Use by Jets::Application
+  # Where config.ru in the project leads to.
+  def self.call(env)
+    ApiGateway.call(env)
+  end
+end

data/lib/jets/server/api_gateway.rb

@@ -0,0 +1,39 @@
+require 'kramdown'
+
+class Jets::Server
+  class ApiGateway
+    def self.call(env)
+      Jets.boot
+      route = RouteMatcher.new(env).find_route
+      if route
+        proxy = LambdaAwsProxy.new(route, env)
+        triplet = proxy.response
+      else
+        [404, {'Content-Type' => 'text/html'}, [routes_error_message(env)]]
+      end
+    end
+
+    def self.routes_error_message(env)
+      message = "<h2>404 Error: Route #{env['PATH_INFO'].sub('/','')} not found</h2>"
+      if Jets.env != "production"
+        message << "<p>Here are the routes defined in your application:</p>"
+        message << "#{routes_table}"
+      end
+      message
+    end
+
+    # Show pretty route table for user to help with debugging in non-production mode
+    def self.routes_table
+      routes = Jets::Router.routes
+
+      return "Your routes table is empty." if routes.empty?
+
+      text = "Verb | Path | Controller#action\n"
+      text << "--- | --- | ---\n"
+      routes.each do |route|
+        text << "#{route.method} | #{route.path} | #{route.to}\n"
+      end
+      Kramdown::Document.new(text).to_html
+    end
+  end
+end

data/lib/jets/server/lambda_aws_proxy.rb

@@ -0,0 +1,122 @@
+require 'cgi'
+require 'stringio'
+
+class Jets::Server
+  # This doesnt really need to be middleware
+  class LambdaAwsProxy
+    def initialize(route, env)
+      @route = route
+      @env = env
+      # @env.each do |k,v|
+      #   puts "#{k}: #{v}"
+      # end
+    end
+
+    def response
+      event = build_event
+      context = {}
+
+      controller_class = find_controller_class
+      controller_action = find_controller_action
+
+      fun = Jets::PolyFun.new(controller_class, controller_action)
+      resp = fun.run(event, context) # check the logs for polymorphic function errors
+
+      # Map lambda proxy response format to rack format
+      status = resp["statusCode"]
+      headers = resp["headers"] || {}
+      headers = {'Content-Type' => 'text/html'}.merge(headers)
+      body = resp["body"]
+
+      [status, headers, [body]]
+    end
+
+    def build_event
+      resource = @route.path(:api_gateway) # posts/{id}/edit
+      path = @env['PATH_INFO'].sub('/','') # remove beginning space
+      {
+        "resource" => "/#{resource}", # "/posts/{id}/edit"
+        "path" => @env['PATH_INFO'],  # /posts/tung/edit
+        "httpMethod" => @env['REQUEST_METHOD'], # GET
+        "headers" => request_headers,
+        "queryStringParameters" => query_string_parameters,
+        "pathParameters" => @route.extract_parameters(path),
+        "stageVariables" => nil,
+        "requestContext" => {},
+        "body" => get_body,
+        "isBase64Encoded" => false,
+      }
+    end
+
+    # Annoying. The headers part of the AWS Lambda proxy structure
+    # does not consisently use the same casing scheme for the header keys.
+    # Sometimes it looks like this:
+    #   Accept-Encoding
+    # and sometimes it looks like this:
+    #   cache-control
+    # Map for special cases when the casing doesn't match.
+    CASING_MAP = {
+      "Cache-Control" => "cache-control",
+      "Content-Type" => "content-type",
+      "Origin" => "origin",
+      "Upgrade-Insecure-Requests" => "upgrade-insecure-requests",
+    }
+
+    def request_headers
+      headers = @env.select { |k,v| k =~ /^HTTP_/ }.inject({}) do |h,(k,v)|
+          # map things like HTTP_USER_AGENT to "User-Agent"
+          key = k.sub('HTTP_','').split('_').map(&:capitalize).join('-')
+          h[key] = v
+          h
+        end
+      # Content type is not prepended with HTTP_ but is part of Lambda's event headers thankfully
+      headers["Content-Type"] = @env["CONTENT_TYPE"] if @env["CONTENT_TYPE"]
+
+      # Adjust the casing so it matches the Lambda AWS Proxy's structure
+      CASING_MAP.each do |nice_casing, bad_casing|
+        if headers.key?(nice_casing)
+          headers[bad_casing] = headers.delete(nice_casing)
+        end
+      end
+
+      # There are also a couple of other headers that are specific to
+      # AWS Lambda Proxy and API Gateway. Example:
+      #
+      # "X-Amz-Cf-Id": "W8DF6J-lx1bkV00eCiBwIq5dldTSGGiG4BinJlxvN_4o8fCZtbsVjw==",
+      # "X-Amzn-Trace-Id": "Root=1-5a0dc1ac-58a7db712a57d6aa4186c2ac",
+      # "X-Forwarded-For": "88.88.88.88, 54.239.203.117",
+      # "X-Forwarded-Port": "443",
+      # "X-Forwarded-Proto": "https",
+      #
+      # For sample dump of the event headers, check out:
+      #   spec/fixtures/samples/event-headers-form-post.json
+
+      headers
+    end
+
+    def query_string_parameters
+      Rack::Utils.parse_nested_query(@env['QUERY_STRING'])
+    end
+
+    # To get the post body:
+    #   rack.input: #<StringIO:0x007f8ccf8db9a0>
+    def get_body
+      # @env["rack.input"] is always provided by rack and we should make
+      # the test data always have rack.input to mimic rack, but but handling
+      # it this way because it's simpler.
+      input = @env["rack.input"] || StringIO.new
+      body = input.read
+      # return nil for blank string, because thats what Lambda AWS_PROXY does
+      body unless body.empty?
+    end
+
+    def find_controller_class
+      # posts#edit => PostsController
+      @route.controller_name.constantize
+    end
+
+    def find_controller_action
+      @route.action_name
+    end
+  end
+end