jets 1.0.18 → 1.1.0

data/lib/jets/commands/build.rb

@@ -2,7 +2,6 @@ require 'digest'
 
 module Jets::Commands
   class Build
-    include Jets::Timing
     include StackInfo
 
     def initialize(options)
@@ -17,18 +16,15 @@ module Jets::Commands
       @options.merge!(stack_type: stack_type, s3_bucket: s3_bucket)
       build
     end
-    time :run
 
     def build
       build_code unless @options[:templates]
       build_templates
     end
-    time :build
 
     def build_code
       Jets::Builders::CodeBuilder.new.build unless @options[:noop]
     end
-    time :build_code
 
     def build_templates
       puts "Building CloudFormation templates."
@@ -36,7 +32,6 @@ module Jets::Commands
       build_minimal_template
       build_all_templates if full?
     end
-    time :build_templates
 
     def full?
       @options[:templates] || @options[:stack_type] == :full

data/lib/jets/commands/deploy.rb

@@ -2,7 +2,6 @@ module Jets::Commands
   class Deploy
     extend Memoist
     include StackInfo
-    include Jets::Timing
 
     def initialize(options)
       @options = options
@@ -32,7 +31,6 @@ module Jets::Commands
       # deploy full nested stack when stack already exists
       ship(stack_type: :full, s3_bucket: s3_bucket)
     end
-    time :run
 
     def delete_minimal_stack
       puts "Existing stack is in ROLLBACK_COMPLETE state from a previous failed minimal deploy. Deleting stack and continuing."
@@ -51,7 +49,6 @@ module Jets::Commands
     def build_code
       Jets::Commands::Build.new(@options).build_code
     end
-    time :build_code
 
     # Checks that all routes are validate and have corresponding lambda functions
     def validate_routes!
@@ -70,7 +67,6 @@ module Jets::Commands
       Jets::Commands::Build.new(options).build_templates
       Jets::Cfn::Ship.new(options).run
     end
-    time :ship
 
     def status
       Jets::Cfn::Status.new(stack_name)

data/lib/jets/commands/main.rb

@@ -18,9 +18,7 @@ module Jets::Commands
     # environment parameter. It is not actually set here.  It is set earlier
     # in cli.rb: set_jets_env_for_deploy_command!
     def deploy(environment=nil)
-      Jets::Timing.clear # must happen outside Deploy#run
       Deploy.new(options).run
-      Jets::Timing.report
     end
 
     desc "delete", "Delete the Jets project and all its resources"
@@ -35,13 +33,16 @@ module Jets::Commands
     long_desc Help.text(:server)
     option :port, default: "8888", desc: "use PORT"
     option :host, default: "127.0.0.1", desc: "listen on HOST"
+    option :reload, type: :boolean, default: true, desc: "Enables hot-reloading for development"
     def server
       # shell out to shotgun for automatic reloading
       o = options
-      command = "bundle exec shotgun --port #{o[:port]} --host #{o[:host]}"
+      server_command = o[:reload] ? "shotgun" : "rackup"
+      command = "bundle exec #{server_command} --port #{o[:port]} --host #{o[:host]}"
       puts "=> #{command}".colorize(:green)
       puts Jets::Booter.message
-      Jets::Rack::Server.start unless ENV['JETS_RACK'] == '0' # rack server runs in background by default
+      Jets::Booter.check_config_ru!
+      Jets::Server.start(options) unless ENV['JETS_RACK'] == '0' # rack server runs in background by default
       system(command)
     end
 
@@ -80,6 +81,16 @@ module Jets::Commands
     option :guess, type: :boolean, default: true, desc: "Enables guess mode. Uses inference to allows use of all dashes to specify functions. Smart mode verifies that the function exists in the code base."
     option :local, type: :boolean, desc: "Enables local mode. Instead of invoke the AWS Lambda function, the method gets called locally with current app code. With local mode guess mode is always used."
     def call(function_name, payload='')
+      # Printing to stdout can mangle up the response when piping
+      # the value to jq. For example:
+      #
+      #   `jets call --local .. | jq`
+      #
+      # By redirecting stderr we can use jq safely.
+      #
+      $stdout.sync = true
+      $stderr.sync = true
+      $stdout = $stderr # jets call operation
       Call.new(function_name, payload, options).run
     end
 
@@ -101,6 +112,22 @@ module Jets::Commands
       Jets::Commands::Url.new(options).display
     end
 
+    desc "secret", "Generates secret"
+    long_desc Help.text(:secret)
+    def secret
+      puts SecureRandom.hex(64)
+    end
+
+    desc "middleware", "Prints list of middleware"
+    long_desc Help.text(:middleware)
+    def middleware
+      stack = Jets.application.middlewares
+      stack.middlewares.each do |middleware|
+        puts "use #{middleware.name}"
+      end
+      puts "run #{Jets.application.endpoint}"
+    end
+
     desc "version", "Prints Jets version"
     long_desc Help.text(:version)
     def version

data/lib/jets/commands/templates/skeleton/{.env → .env.tt}

@@ -1,2 +1,3 @@
 # Example .env, meant to be updated.
 # Variables in here are available and shared across all environments: development, production, etc.
+SECRET_KEY_BASE=<%= SecureRandom.hex(64) %>

data/lib/jets/commands/templates/skeleton/config.ru

@@ -1,4 +1,5 @@
 # This file is used by Rack-based servers to start the application.
 
 require "jets"
+Jets.boot
 run Jets.application

data/lib/jets/commands/upgrade/v1.rb

@@ -1,5 +1,6 @@
 require 'fileutils'
 
+# This class tries to be idempotent, so users should be able to run it multiple times safely.
 class Jets::Commands::Upgrade
   class V1
     def initialize(options)
@@ -11,6 +12,7 @@ class Jets::Commands::Upgrade
       environment_configs
       update_routes
       update_mode_setting
+      update_config_ru
       puts "Upgrade complete."
     end
 
@@ -67,5 +69,15 @@ class Jets::Commands::Upgrade
       content = lines.join
       IO.write(application_file, content)
     end
+
+    def update_config_ru
+      config_ru = File.read("#{Jets.root}config.ru")
+      return if config_ru.include?("Jets.boot")
+
+      src = File.expand_path("../templates/skeleton/config.ru", File.dirname(__FILE__))
+      dest = "#{Jets.root}config.ru"
+      puts "Update: config.ru"
+      FileUtils.cp(src, dest)
+    end
   end
 end

data/lib/jets/controller.rb

@@ -1,8 +1,13 @@
 class Jets::Controller
+  DEFAULT_CONTENT_TYPE = "text/html; charset=utf-8"
+
   autoload :Base, "jets/controller/base"
   autoload :Callbacks, "jets/controller/callbacks"
+  autoload :Cookies, "jets/controller/cookies"
   autoload :Layout, "jets/controller/layout"
+  autoload :Middleware, "jets/controller/middleware"
   autoload :Params, "jets/controller/params"
+  autoload :Rack, "jets/controller/rack"
   autoload :Redirection, "jets/controller/redirection"
   autoload :Renderers, "jets/controller/renderers"
   autoload :Rendering, "jets/controller/rendering"

data/lib/jets/controller/base.rb

@@ -6,38 +6,60 @@ require "rack/utils" # Rack::Utils.parse_nested_query
 # Controller public methods get turned into Lambda functions.
 class Jets::Controller
   class Base < Jets::Lambda::Functions
-    include Layout
     include Callbacks
-    include Rendering
+    include Cookies
+    include Layout
     include Params
+    include Rendering
 
-    def self.process(event, context={}, meth)
-      t1 = Time.now
-      Jets.logger.info "Processing by #{self}##{meth}"
+    delegate :headers, to: :request
+    delegate :set_header, to: :response
+    attr_reader :request, :response
+    attr_accessor :session
+    def initialize(event, context={}, meth)
+      super
+      @request = Request.new(event, context)
+      @response = Response.new
+    end
 
-      controller = new(event, context, meth)
+    def process!
+      adapter = Jets::Controller::Rack::Adapter.new(event, context, meth)
+      adapter.rack_vars(
+        'jets.controller' => self,
+        'lambda.context' => context,
+        'lambda.event' => event,
+        'lambda.meth' => meth,
+      )
+      # adapter.process ultimately calls app controller action at the very last
+      # middleware stack.
+      adapter.process # Returns API Gateway hash structure
+    end
 
-      Jets.logger.info "  Event: #{event.inspect}"
-      Jets.logger.info "  Parameters: #{controller.params(raw: true).to_h.inspect}"
+    def dispatch!
+      t1 = Time.now
+      Jets.logger.info "Processing by #{self.class.name}##{@meth}"
+      Jets.logger.info "  Event: #{@event.inspect}"
+      Jets.logger.info "  Parameters: #{params(raw: true).to_h.inspect}"
 
-      controller.run_before_actions
-      controller.send(meth)
-      resp = controller.ensure_render
-      controller.run_after_actions
+      run_before_actions
+      send(@meth)
+      triplet = ensure_render
+      run_after_actions
 
       took = Time.now - t1
-      Jets.logger.info "Completed Status Code #{resp["statusCode"]} in #{took}s"
+      status = triplet[0]
+      Jets.logger.info "Completed Status Code #{status} in #{took}s"
 
-      resp
+      triplet # status, headers, body
     end
 
-    delegate :headers, to: :request
-    delegate :set_header, to: :response
-    attr_reader :request, :response
-    def initialize(event, context={}, meth)
-      super
-      @request = Request.new(event)
-      @response = Response.new(event)
+    def self.process(event, context={}, meth)
+      controller = new(event, context, meth)
+      # Using send because process! is private method in Jets::RackController so
+      # it doesnt create a lambda function.  It's doesnt matter what scope process!
+      # is in Controller::Base because Jets lambda functions inheritance doesnt
+      # include methods in Controller::Base.
+      controller.send(:process!)
     end
 
     class_attribute :internal_controller

data/lib/jets/controller/cookies.rb

@@ -0,0 +1,40 @@
+# Based on sinatra/cookies.rb
+# https://github.com/sinatra/sinatra/blob/master/sinatra-contrib/lib/sinatra/cookies.rb
+class Jets::Controller
+  # = Jets::Controller::Cookies
+  #
+  # Easy way to deal with cookies
+  #
+  # == Usage
+  #
+  # Allows you to read cookies:
+  #
+  #   def index
+  #     "value: #{cookies[:something]}"
+  #   end
+  #
+  # And of course to write cookies:
+  #
+  #   def show
+  #     cookies[:something] = 'foobar'
+  #     render json: cookies
+  #   end
+  #
+  # And generally behaves like a hash:
+  #
+  #   def index
+  #     cookies.merge! 'foo' => 'bar', 'bar' => 'baz'
+  #     cookies.keep_if { |key, value| key.start_with? 'b' }
+  #     foo, bar = cookies.values_at 'foo', 'bar'
+  #     puts "size: #{cookies.length}"
+  #     render json: cookies
+  #   end
+  #
+  module Cookies
+    autoload :Jar, "jets/controller/cookies/jar"
+
+    def cookies
+      @cookies ||= Jar.new(self)
+    end
+  end
+end

data/lib/jets/controller/cookies/jar.rb

@@ -0,0 +1,269 @@
+# Based on sinatra/cookies.rb
+# https://github.com/sinatra/sinatra/blob/master/sinatra-contrib/lib/sinatra/cookies.rb
+module Jets::Controller::Cookies
+  class Jar
+    include Enumerable
+    attr_reader :options
+
+    def initialize(controller)
+      @response_string = nil
+      @response_hash   = {}
+      @response        = controller.response
+      @request         = controller.request
+      @deleted         = []
+
+      @options = {
+        path: @request.script_name.to_s.empty? ? '/' : @request.script_name,
+        domain: @request.host == 'localhost' ? nil : @request.host,
+        secure: @request.ssl?,
+        httponly: true
+      }
+    end
+
+    def ==(other)
+      other.respond_to? :to_hash and to_hash == other.to_hash
+    end
+
+    def [](key)
+      response_cookies[key.to_s] || request_cookies[key.to_s]
+    end
+
+    def []=(key, value)
+      set(key, value: value)
+    end
+
+    def assoc(key)
+      to_hash.assoc(key.to_s)
+    end if Hash.method_defined? :assoc
+
+    def clear
+      each_key { |k| delete(k) }
+    end
+
+    def compare_by_identity?
+      false
+    end
+
+    def default
+      nil
+    end
+
+    alias default_proc default
+
+    def delete(key)
+      result = self[key]
+      @response.delete_cookie(key.to_s, @options)
+      result
+    end
+
+    def delete_if
+      return enum_for(__method__) unless block_given?
+      each { |k, v| delete(k) if yield(k, v) }
+      self
+    end
+
+    def each(&block)
+      return enum_for(__method__) unless block_given?
+      to_hash.each(&block)
+    end
+
+    def each_key(&block)
+      return enum_for(__method__) unless block_given?
+      to_hash.each_key(&block)
+    end
+
+    alias each_pair each
+
+    def each_value(&block)
+      return enum_for(__method__) unless block_given?
+      to_hash.each_value(&block)
+    end
+
+    def empty?
+      to_hash.empty?
+    end
+
+    def fetch(key, &block)
+      response_cookies.fetch(key.to_s) do
+        request_cookies.fetch(key.to_s, &block)
+      end
+    end
+
+    def flatten
+      to_hash.flatten
+    end if Hash.method_defined? :flatten
+
+    def has_key?(key)
+      response_cookies.has_key? key.to_s or request_cookies.has_key? key.to_s
+    end
+
+    def has_value?(value)
+      response_cookies.has_value? value or request_cookies.has_value? value
+    end
+
+    def hash
+      to_hash.hash
+    end
+
+    alias include? has_key?
+    alias member?  has_key?
+
+    def index(value)
+      warn "Hash#index is deprecated; use Hash#key"
+      key(value)
+    end
+
+    def inspect
+      "<##{self.class}: #{to_hash.inspect[1..-2]}>"
+    end
+
+    def invert
+      to_hash.invert
+    end if Hash.method_defined? :invert
+
+    def keep_if
+      return enum_for(__method__) unless block_given?
+      delete_if { |*a| not yield(*a) }
+    end
+
+    def key(value)
+      to_hash.key(value)
+    end
+
+    alias key? has_key?
+
+    def keys
+      to_hash.keys
+    end
+
+    def length
+      to_hash.length
+    end
+
+    def merge(other, &block)
+      to_hash.merge(other, &block)
+    end
+
+    def merge!(other)
+      other.each_pair do |key, value|
+        if block_given? and include? key
+          self[key] = yield(key.to_s, self[key], value)
+        else
+          self[key] = value
+        end
+      end
+    end
+
+    def rassoc(value)
+      to_hash.rassoc(value)
+    end
+
+    def rehash
+      response_cookies.rehash
+      request_cookies.rehash
+      self
+    end
+
+    def reject(&block)
+      return enum_for(__method__) unless block_given?
+      to_hash.reject(&block)
+    end
+
+    alias reject! delete_if
+
+    def replace(other)
+      select! { |k, v| other.include?(k) or other.include?(k.to_s)  }
+      merge! other
+    end
+
+    def select(&block)
+      return enum_for(__method__) unless block_given?
+      to_hash.select(&block)
+    end
+
+    alias select! keep_if if Hash.method_defined? :select!
+
+    def set(key, options = {})
+      @response.set_cookie key.to_s, @options.merge(options)
+    end
+
+    def shift
+      key, value = to_hash.shift
+      delete(key)
+      [key, value]
+    end
+
+    alias size length
+
+    def sort(&block)
+      to_hash.sort(&block)
+    end if Hash.method_defined? :sort
+
+    alias store []=
+
+    def to_hash
+      request_cookies.merge(response_cookies)
+    end
+
+    def to_a
+      to_hash.to_a
+    end
+
+    def to_s
+      to_hash.to_s
+    end
+
+    alias update merge!
+    alias value? has_value?
+
+    def values
+      to_hash.values
+    end
+
+    def values_at(*list)
+      list.map { |k| self[k] }
+    end
+
+    private
+
+    def warn(message)
+      super "#{caller.first[/^[^:]:\d+:/]} warning: #{message}"
+    end
+
+    def deleted
+      parse_response
+      @deleted
+    end
+
+    def response_cookies
+      parse_response
+      @response_hash
+    end
+
+    def parse_response
+      string = @response.headers['Set-Cookie']
+      return if @response_string == string
+
+      hash = {}
+
+      string.each_line do |line|
+        key, value = line.split(';', 2).first.to_s.split('=', 2)
+        next if key.nil?
+        key = Rack::Utils.unescape(key)
+        if line =~ /expires=Thu, 01[-\s]Jan[-\s]1970/
+          @deleted << key
+        else
+          @deleted.delete key
+          hash[key] = value
+        end
+      end
+
+      @response_hash.replace hash
+      @response_string = string
+    end
+
+    def request_cookies
+      @request.cookies.reject { |key, value| deleted.include? key }
+    end
+  end
+end