jets_bb_fork 0.0.4

data/lib/jets/controller/request.rb

@@ -0,0 +1,29 @@
+require 'rack/request'
+
+class Jets::Controller
+  class Request < ::Rack::Request
+    def initialize(event, context)
+      @event, @context = event, context
+      super(env)
+    end
+
+    def env
+      @env ||= Jets::Controller::Rack::Env.new(@event, @context).convert # convert to Rack env
+    end
+
+    # When request hits the middleware Controller::Rack::Middleware::Main endpoint
+    # We set the it with the updated env since it could had been mutated down the
+    # middleware stack.
+    def set_env!(env)
+      @env = env
+    end
+
+    # API Gateway is inconsistent about how it cases it keys.
+    # Sometimes it is "x-requested-with" vs "X-Requested-With"
+    # Normalize it with downcase.
+    def headers
+      headers = @event["headers"] || {}
+      headers.transform_keys { |key| key.downcase }
+    end
+  end
+end

data/lib/jets/controller/response.rb

@@ -0,0 +1,61 @@
+require 'rack/response'
+
+class Jets::Controller
+  # The response object. See Rack::Response and Rack::Response::Helpers for
+  # more info:
+  # http://rubydoc.info/github/rack/rack/master/Rack/Response
+  # http://rubydoc.info/github/rack/rack/master/Rack/Response/Helpers
+  class Response < ::Rack::Response
+    DROP_BODY_RESPONSES = [204, 304]
+    def initialize(*)
+      super
+      # headers['Content-Type'] ||= 'text/html'
+    end
+
+    # TODO: unsure if we should even have these methods.  We dont really use them.
+    def body=(value)
+      value = value.body while Rack::Response === value
+      @body = String === value ? [value.to_str] : value
+    end
+
+    def each
+      block_given? ? super : enum_for(:each)
+    end
+
+    def finish
+      result = body
+
+      if drop_content_info?
+        headers.delete "Content-Length"
+        headers.delete "Content-Type"
+      end
+
+      if drop_body?
+        close
+        result = []
+      end
+
+      if calculate_content_length?
+        # if some other code has already set Content-Length, don't muck with it
+        # currently, this would be the static file-handler
+        headers["Content-Length"] = body.inject(0) { |l, p| l + p.bytesize }.to_s
+      end
+
+      [status.to_i, headers, result]
+    end
+
+    private
+
+    def calculate_content_length?
+      headers["Content-Type"] and not headers["Content-Length"] and Array === body
+    end
+
+    def drop_content_info?
+      status.to_i / 100 == 1 or drop_body?
+    end
+
+    def drop_body?
+      DROP_BODY_RESPONSES.include?(status.to_i)
+    end
+  end
+end

data/lib/jets/controller/stage.rb

@@ -0,0 +1,33 @@
+class Jets::Controller
+  class Stage
+    def initialize(host, url)
+      @host, @url = host, url
+    end
+
+    def add
+      return @url unless add_stage?
+
+      stage_name = Jets::Resource::ApiGateway::Deployment.stage_name
+      "/#{stage_name}#{@url}"
+    end
+
+    def add_stage?
+      return false if on_cloud9?
+      @host.include?("amazonaws.com") && @url.starts_with?('/')
+    end
+
+    def on_cloud9?
+      self.class.on_cloud9?(@host)
+    end
+
+    class << self
+      def add(host, url)
+        new(host, url).add
+      end
+
+      def on_cloud9?(host)
+        !!(host =~ /cloud9\..*\.amazonaws\.com/)
+      end
+    end
+  end
+end

data/lib/jets/core.rb

@@ -0,0 +1,149 @@
+module Jets::Core
+  extend Memoist
+
+  def application
+    Jets::Application.instance
+  end
+
+  def config
+    application.config
+  end
+
+  def aws
+    application.aws
+  end
+
+  # Load all application base classes and project classes
+  def boot
+    Jets::Booter.boot!
+  end
+
+  def root
+    # Do not memoize this method. Turbo mode can change it
+    root = ENV['JETS_ROOT'].to_s
+    root = Dir.pwd if root == ''
+    Pathname.new(root)
+  end
+
+  def env
+    env = ENV['JETS_ENV'] || 'development'
+    ENV['RAILS_ENV'] = ENV['RACK_ENV'] = env
+    ActiveSupport::StringInquirer.new(env)
+  end
+  memoize :env
+
+  def build_root
+    "/tmp/jets/#{config.project_name}".freeze
+  end
+  memoize :build_root
+
+  def logger
+    Jets.application.config.logger
+  end
+  memoize :logger
+
+  def webpacker?
+    Gem.loaded_specs.keys.include?("webpacker")
+  end
+  memoize :webpacker?
+
+  def load_tasks
+    Jets::Commands::RakeTasks.load!
+  end
+
+  def version
+    Jets::VERSION
+  end
+
+  # NOTE: In development this will always be 1 because the app gets reloaded.
+  # On AWS Lambda, this will be ever increasing until the container gets replaced.
+  @@call_count = 0
+  def increase_call_count
+    @@call_count += 1
+  end
+
+  def call_count
+    @@call_count
+  end
+
+  @@prewarm_count = 0
+  def increase_prewarm_count
+    @@prewarm_count += 1
+  end
+
+  def prewarm_count
+    @@prewarm_count
+  end
+
+  def project_namespace
+    [config.project_name, config.short_env, config.env_extra].compact.join('-').gsub('_','-')
+  end
+
+  def rack?
+    path = "#{Jets.root}/rack"
+    File.exist?(path) || File.symlink?(path)
+  end
+
+  def poly_only?
+    return true if ENV['JETS_POLY_ONLY'] # bypass to allow rapid development of handlers
+    Jets::Commands::Build.poly_only?
+  end
+
+  def report_exception(exception)
+    puts "DEPRECATED: report_exception. Use on_exception instead.".color(:yellow)
+    on_exception(exception)
+  end
+
+  def on_exception(exception)
+    Jets::Turbine.subclasses.each do |subclass|
+      reporters = subclass.on_exceptions || []
+      reporters.each do |label, block|
+        block.call(exception)
+      end
+    end
+  end
+
+  def custom_domain?
+    Jets.config.domain.hosted_zone_name
+  end
+
+  def s3_event?
+    !Jets::Job::Base.s3_events.empty?
+  end
+
+  def process(event, context, handler)
+    if event['_prewarm']
+      Jets.increase_prewarm_count
+      Jets.logger.info("Prewarm request")
+      {prewarmed_at: Time.now.to_s}
+    else
+      Jets::Processors::MainProcessor.new(event, context, handler).run
+    end
+  end
+
+  def once
+    boot
+    override_lambda_ruby_runtime
+    tmp_load!
+    start_rack_server
+  end
+
+  def tmp_load!
+    Jets::TmpLoader.load!
+  end
+
+  # Megamode support
+  def start_rack_server(options={})
+    rack = Jets::RackServer.new(options)
+    rack.start
+    rack.wait_for_socket
+  end
+
+  def default_gems_source
+    "https://gems2.lambdagems.com"
+  end
+
+  def override_lambda_ruby_runtime
+    require "jets/overrides/lambda"
+  end
+end

data/lib/jets/core_ext/kernel.rb

@@ -0,0 +1,13 @@
+module Kernel
+  module_function
+
+  alias_method :jets_original_require, :require
+  # @param path [String]
+  # @return [Boolean]
+  def require(path)
+    # Hack to prevent Rails const from being defined
+    # Actionview requires "rails-html-sanitizer" and that creates a Rails module
+    path = "jets-html-sanitizer" if path == "rails-html-sanitizer"
+    jets_original_require(path)
+  end
+end

data/lib/jets/db.rb

@@ -0,0 +1,15 @@
+module Jets::Db ; end
+
+# Thanks: https://makandracards.com/makandra/42521-detecting-if-a-ruby-gem-is-loaded
+if File.exist?("#{Jets.root}/config/database.yml")
+  require "active_record"
+  specs = Gem.loaded_specs
+  require "mysql2" if specs.key?('mysql2')
+  require "pg" if specs.key?('pg')
+end
+
+if File.exist?("#{Jets.root}/config/dynamodb.yml")
+  specs = Gem.loaded_specs
+  specs.key?('dynomite')
+  require "dynomite" if specs.key?('dynomite')
+end

data/lib/jets/dotenv.rb

@@ -0,0 +1,48 @@
+require 'dotenv'
+
+class Jets::Dotenv
+  def self.load!(remote=false)
+    new(remote).load!
+  end
+
+  def initialize(remote=false)
+    @remote = ENV['JETS_ENV_REMOTE'] || remote
+  end
+
+  def load!
+    return if on_aws? # this prevents ssm calls if used in dotenv files
+    vars = ::Dotenv.load(*dotenv_files)
+    Ssm.new(vars).interpolate!
+  end
+
+  def on_aws?
+    !!ENV['_HANDLER'] # https://docs.aws.amazon.com/lambda/latest/dg/lambda-environment-variables.html
+  end
+
+  # dotenv files with the following precedence:
+  #
+  # - .env.development.jets_env_extra (highest)
+  # - .env.development.remote (2nd highest)
+  # - .env.development.local
+  # - .env.development
+  # - .env.local - This file is loaded for all environments _except_ `test`.
+  # - .env - The original (lowest)
+  #
+  def dotenv_files
+    files = [
+      root.join(".env"),
+      (root.join(".env.local") unless Jets.env.test?),
+      root.join(".env.#{Jets.env}"),
+      root.join(".env.#{Jets.env}.local"),
+    ]
+    files << root.join(".env.#{Jets.env}.remote") if @remote
+    if ENV["JETS_ENV_EXTRA"]
+      files << root.join(".env.#{Jets.env}.#{ENV["JETS_ENV_EXTRA"]}")
+    end
+    files.compact
+  end
+
+  def root
+    Jets.root || Pathname.new(ENV["JETS_ROOT"] || Dir.pwd)
+  end
+end

data/lib/jets/dotenv/ssm.rb

@@ -0,0 +1,48 @@
+require 'aws-sdk-ssm'
+
+class Jets::Dotenv
+  class Ssm
+    SSM_VARIABLE_REGEXP = /^ssm:(.*)/
+
+    def initialize(variables={})
+      @variables = variables
+      @missing = []
+    end
+
+    def interpolate!
+      interpolated_variables = @variables.map do |key, value|
+        if value[SSM_VARIABLE_REGEXP]
+          value = fetch_ssm_value(key, $1)
+        end
+
+        [key, value]
+      end
+
+      interpolated_variables.each do |key, value|
+        ENV[key] = value
+      end
+
+      if @missing.empty?
+        interpolated_variables.to_h # success
+      else
+        message = "Error loading .env variables. No matching SSM parameters found for:\n".color(:red)
+        message += @missing.map { |k,v,n| "  #{k}=ssm:#{v} # ssm name: #{n}"}.join("\n")
+        abort message
+      end
+    end
+
+    def fetch_ssm_value(key, value)
+      name = value.start_with?("/") ? value :
+        "/#{Jets.config.project_name}/#{Jets.env}/#{value}"
+      response = ssm.get_parameter(name: name, with_decryption: true)
+      response.parameter.value
+    rescue Aws::SSM::Errors::ParameterNotFound
+      @missing << [key, value, name]
+      ''
+    end
+
+    def ssm
+      @ssm ||= Aws::SSM::Client.new
+    end
+  end
+end

data/lib/jets/erb.rb

@@ -0,0 +1,51 @@
+require 'erb'
+
+# Renders Erb and provide better backtrace where there's an error
+#
+# Usage:
+#
+#   result = Jets::Erb.result(path, key1: "val1", key2: "val2")
+#
+class Jets::Erb
+  class << self
+    def result(path, variables={})
+      set_template_variables(variables)
+      template = IO.read(path)
+      begin
+        ERB.new(template, nil, "-").result(binding)
+      rescue Exception => e
+        puts e
+        puts e.backtrace if ENV['JETS_DEBUG']
+
+        # how to know where ERB stopped? - https://www.ruby-forum.com/topic/182051
+        # syntax errors have the (erb):xxx info in e.message
+        # undefined variables have (erb):xxx info in e.backtrac
+        error_info = e.message.split("\n").grep(/\(erb\)/)[0]
+        error_info ||= e.backtrace.grep(/\(erb\)/)[0]
+        raise unless error_info # unable to find the (erb):xxx: error line
+        line = error_info.split(':')[1].to_i
+        puts "Error evaluating ERB template on line #{line.to_s.color(:red)} of: #{path.sub(/^\.\//, '').color(:green)}"
+
+        template_lines = template.split("\n")
+        context = 5 # lines of context
+        top, bottom = [line-context-1, 0].max, line+context-1
+        spacing = template_lines.size.to_s.size
+        template_lines[top..bottom].each_with_index do |line_content, index|
+          line_number = top+index+1
+          if line_number == line
+            printf("%#{spacing}d %s\n".color(:red), line_number, line_content)
+          else
+            printf("%#{spacing}d %s\n", line_number, line_content)
+          end
+        end
+        exit 1 unless ENV['TEST']
+      end
+    end
+
+    def set_template_variables(variables)
+      variables.each do |key, value|
+        instance_variable_set(:"@#{key}", value)
+      end
+    end
+  end
+end