jets-fs 1.6.10

data/lib/jets/internal/app/controllers/jets/rack_controller.rb

@@ -0,0 +1,25 @@
+class Jets::RackController < Jets::Controller::Base
+  layout false
+  internal true
+
+  # Megamode
+  def process
+    resp = mega_request
+    render(resp)
+  end
+
+private
+  # Override process! so it doesnt go through middleware adapter and hits
+  # process logic directly. This handles the case for AWS Lambda.
+  # For local server, we adjust the Middleware::Local logic.
+  def process!
+    status, headers, body = dispatch!
+    # Use the adapter only to convert the Rack triplet to a API Gateway hash structure
+    adapter = Jets::Controller::Rack::Adapter.new(event, context, meth)
+    adapter.convert_to_api_gateway(status, headers, body)
+  end
+
+  def mega_request
+    Jets::Mega::Request.new(event, self).proxy
+  end
+end

data/lib/jets/internal/app/functions/jets/base_path.rb

@@ -0,0 +1,153 @@
+require 'aws-sdk-apigateway'
+require 'aws-sdk-cloudformation'
+
+STAGE_NAME = "<%= @stage_name %>"
+
+def lambda_handler(event:, context:)
+  puts("event['RequestType'] #{event['RequestType']}")
+  puts("event: #{JSON.dump(event)}")
+  puts("context: #{JSON.dump(context)}")
+  puts("context.log_stream_name #{context.log_stream_name.inspect}")
+
+  mimic = event['ResourceProperties']['Mimic']
+  physical_id = event['ResourceProperties']['PhysicalId'] || "PhysicalId"
+
+  puts "mimic: #{mimic}"
+  puts "physical_id: #{physical_id}"
+
+  if event['RequestType'] == 'Delete'
+    if mimic == 'FAILED'
+      send_response(event, context, "FAILED")
+    else
+      mapping = BasePathMapping.new(event)
+      mapping.delete(true) if mapping.should_delete?
+      send_response(event, context, "SUCCESS")
+    end
+    return # early return
+  end
+
+  mapping = BasePathMapping.new(event)
+  mapping.update
+
+  response_status = mimic == "FAILED" ? "FAILED" : "SUCCESS"
+  response_data = { "Hello" => "World" }
+
+  send_response(event, context, response_status, response_data, physical_id)
+
+# We rescue all exceptions and send an message to CloudFormation so we dont have to
+# wait for over an hour for the stack operation to timeout and rollback.
+rescue Exception => e
+  puts e.message
+  puts e.backtrace
+  sleep 10 # provide delete to make sure that the log gets sent to CloudWatch
+  send_response(event, context, "FAILED")
+end
+
+def send_response(event, context, response_status, response_data={}, physical_id="PhysicalId")
+  response_body = JSON.dump(
+    Status: response_status,
+    Reason: "See the details in CloudWatch Log Stream: #{context.log_stream_name.inspect}",
+    PhysicalResourceId: physical_id,
+    StackId: event['StackId'],
+    RequestId: event['RequestId'],
+    LogicalResourceId: event['LogicalResourceId'],
+    Data: response_data
+  )
+
+  puts "RESPONSE BODY:\n"
+  puts response_body
+
+  url = event['ResponseURL']
+  uri = URI(url)
+  http = Net::HTTP.new(uri.host, uri.port)
+  http.open_timeout = http.read_timeout = 30
+  http.use_ssl = true if uri.scheme == 'https'
+
+
+  # must used url to include the AWSAccessKeyId and Signature
+  req = Net::HTTP::Put.new(url) # url includes query string and uri.path does not, must used url t
+  req.body = response_body
+  req.content_length = response_body.bytesize
+
+  # set headers
+  req['content-type'] = ''
+  req['content-length'] = response_body.bytesize
+
+  res = http.request(req)
+  puts "status code: #{res.code}"
+  puts "headers: #{res.each_header.to_h.inspect}"
+  puts "body: #{res.body}"
+end
+
+
+class BasePathMapping
+  def initialize(event)
+    @event = event
+    @rest_api_id = get_rest_api_id
+    @domain_name = get_domain_name
+    @base_path = ''
+  end
+
+  def update
+    # Cannot use update_base_path_mapping to update the base_mapping because it doesnt
+    # allow us to change the rest_api_id. So we delete and create.
+    delete(true)
+    create
+  end
+
+  # Dont delete the newly created base path mapping unless this is an operation
+  # where we're fully deleting the stack
+  def should_delete?
+    deleting_parent?
+  end
+
+  def delete(fail_silently=false)
+    apigateway.delete_base_path_mapping(
+      domain_name: @domain_name, # required
+      base_path: '(none)',
+    )
+  rescue Aws::APIGateway::Errors::NotFoundException => e
+    raise(e) unless fail_silently
+  end
+
+  def create
+    apigateway.create_base_path_mapping(
+      domain_name: @domain_name, # required
+      base_path: @base_path,
+      rest_api_id: @rest_api_id, # required
+      stage: STAGE_NAME,
+    )
+  end
+
+  def get_domain_name
+    param = deployment_stack[:parameters].find { |p| p.parameter_key == 'DomainName' }
+    param.parameter_value
+  end
+
+  def deployment_stack
+    @deployment_stack ||= cfn.describe_stacks(stack_name: @event['StackId']).stacks.first
+  end
+
+  def get_rest_api_id
+    param = deployment_stack[:parameters].find { |p| p.parameter_key == 'RestApi' }
+    param.parameter_value
+  end
+
+  def deleting_parent?
+    stack = cfn.describe_stacks(stack_name: parent_stack_name).stacks.first
+    stack.stack_status == 'DELETE_IN_PROGRESS'
+  end
+
+  def parent_stack_name
+    deployment_stack[:root_id]
+  end
+
+private
+  def apigateway
+    @apigateway ||= Aws::APIGateway::Client.new
+  end
+
+  def cfn
+    @cfn ||= Aws::CloudFormation::Client.new
+  end
+end

data/lib/jets/internal/app/jobs/jets/preheat_job.rb

@@ -0,0 +1,62 @@
+class Jets::PreheatJob < ApplicationJob
+  ENABLED = Jets.config.prewarm.enable
+  CONCURRENCY = Jets.config.prewarm.concurrency
+  PREWARM_RATE = Jets.config.prewarm.rate
+  torching = ENABLED && CONCURRENCY > 1
+  warming = ENABLED && CONCURRENCY == 1
+
+  class_timeout 30
+  class_memory 1024
+  class_iam_policy(
+    {
+      sid: "Statement1",
+      action: ["logs:*"],
+      effect: "Allow",
+      resource: "arn:aws:logs:#{Jets.aws.region}:#{Jets.aws.account}:log-group:#{Jets.config.project_namespace}-*",
+    },
+    {
+      sid: "Statement2",
+      action: ["lambda:InvokeFunction", "lambda:InvokeAsync"],
+      effect: "Allow",
+      resource: "arn:aws:lambda:#{Jets.aws.region}:#{Jets.aws.account}:function:#{Jets.config.project_namespace}-*",
+    }
+  )
+
+  rate(PREWARM_RATE) if torching
+  def torch
+    threads = []
+    CONCURRENCY.times do
+      threads << Thread.new do
+        # intentionally calling remote lambda for concurrency
+        # avoid passing the _prewarm=1 flag because we want the PreheatJob#warm
+        # to run it's normal workload.
+        # Do not use Jets::Preheat.warm(function_name) here as that passes the _prewarm=1.
+        function_name = "jets-preheat_job-warm"
+        event_json = JSON.dump(event)
+        options = call_options(event[:quiet])
+        Jets::Commands::Call.new(function_name, event_json, options).run unless ENV['TEST']
+      end
+    end
+    threads.each { |t| t.join }
+    "Finished prewarming your application with a concurrency of #{CONCURRENCY}."
+  end
+
+  rate(PREWARM_RATE) if warming
+  def warm
+    options = call_options(event[:quiet])
+    Jets::Preheat.warm_all(options)
+    "Finished prewarming your application."
+  end
+
+private
+  def call_options(quiet)
+    options = {}
+    options.merge!(mute: true, mute_output: true) if quiet
+    # All the methods in this Job class leads to Jets::Commands::Call.
+    # This is true for the Jets::Preheat.warm_all also.
+    # These jobs delegate out to Lambda function calls. We do not need/want
+    # the invocation type: RequestResponse in this case.
+    options.merge!(invocation_type: "Event")
+    options
+  end
+end

data/lib/jets/io.rb

@@ -0,0 +1,14 @@
+# Wrapper class works with jets/core_ext/kernel.rb
+module Jets
+  class IO
+    class << self
+      def buffer
+        Kernel.io_buffer
+      end
+
+      def flush
+        Kernel.io_flush
+      end
+    end
+  end
+end

data/lib/jets/job.rb

@@ -0,0 +1,4 @@
+class Jets::Job
+  autoload :Dsl, "jets/job/dsl"
+  autoload :Base, "jets/job/base"
+end

data/lib/jets/job/base.rb

@@ -0,0 +1,29 @@
+require 'json'
+
+# Job public methods get turned into Lambda functions.
+#
+# Jets::Job::Base < Jets::Lambda::Functions
+# Both Jets::Job::Base and Jets::Lambda::Functions have Dsl modules included.
+# So the Jets::Job::Dsl overrides some of the Jets::Lambda::Functions behavior.
+class Jets::Job
+  class Base < Jets::Lambda::Functions
+    include Dsl
+
+    class << self
+      def process(event, context, meth)
+        job = new(event, context, meth)
+        job.send(meth)
+      end
+
+      def perform_now(meth, event={}, context={})
+        new(event, context, meth).send(meth)
+      end
+
+      def perform_later(meth, event={}, context={})
+        function_name = "#{self.to_s.underscore}-#{meth}"
+        call = Jets::Commands::Call.new(function_name, JSON.dump(event), invocation_type: "Event")
+        call.run
+      end
+    end
+  end
+end

data/lib/jets/job/dsl.rb

@@ -0,0 +1,108 @@
+# Jets::Job::Base < Jets::Lambda::Functions
+# Both Jets::Job::Base and Jets::Lambda::Functions have Dsl modules included.
+# So the Jets::Job::Dsl overrides some of the Jets::Lambda::Functions behavior.
+#
+# Implements:
+#
+#   default_associated_resource_definition
+#
+module Jets::Job::Dsl
+  extend ActiveSupport::Concern
+
+  included do
+    class << self
+      # Public: Creates CloudWatch Event Rule
+      #
+      # expression - The rate expression.
+      #
+      # Examples
+      #
+      #   rate("10 minutes")
+      #   rate("10 minutes", description: "Hard job")
+      #
+      def rate(expression, props={})
+        schedule_job("rate(#{expression})", props)
+      end
+
+      # Public: Creates CloudWatch Event Rule
+      #
+      # expression - The cron expression.
+      #
+      # Examples
+      #
+      #   cron("0 */12 * * ? *")
+      #   cron("0 */12 * * ? *", description: "Hard job")
+      #
+      def cron(expression, props={})
+        schedule_job("cron(#{expression})", props)
+      end
+
+      def schedule_job(expression, props={})
+        @associated_properties = nil # dont use any current associated_properties
+        props = props.merge(schedule_expression: expression)
+        associated_properties(props)
+        # Eager define resource
+        resource(events_rule_definition) # add associated resources immediately
+        @associated_properties = nil # reset for next definition, since we're defining eagerly
+      end
+
+      def event_pattern(details={}, props={})
+        @associated_properties = nil # dont use any current associated_properties
+        props = props.merge(event_pattern: details)
+        associated_properties(props)
+        # Eager define resource
+        resource(events_rule_definition) # add associated resources immediately
+        @associated_properties = nil # reset for next definition, since we're defining eagerly
+        add_descriptions # useful: generic description in the Event Rule console
+      end
+
+      def events_rule(props={})
+        @associated_properties = nil # dont use any current associated_properties
+        associated_properties(props)
+        # Eager define resource
+        resource(events_rule_definition) # add associated resources immediately
+        @associated_properties = nil # reset for next definition, since we're defining eagerly
+      end
+
+      # Works with eager definitions
+      def add_descriptions
+        numbered_resources = []
+        n = 1
+        @associated_resources.map do |associated|
+          # definition = associated.definition
+          # puts "associated #{associated.inspect}"
+          # puts "definition #{definition.inspect}"
+
+          # logical_id = definition.keys.first
+          # attributes = definition.values.first
+
+          logical_id = associated.logical_id
+          attributes = associated.attributes
+
+          attributes[:properties][:description] ||= "#{self.name} Event Rule #{n}"
+          new_definition = { "#{logical_id}" => attributes }
+          numbered_resources << Jets::Resource::Associated.new(new_definition)
+          n += 1
+        end
+        @associated_resources = numbered_resources
+      end
+
+      ASSOCIATED_PROPERTIES = %W[
+        description
+        state
+        schedule_expression
+      ]
+      define_associated_properties(ASSOCIATED_PROPERTIES)
+      alias_method :desc, :description
+
+      def default_associated_resource_definition(meth)
+        events_rule_definition
+      end
+
+      def events_rule_definition
+        resource = Jets::Resource::Events::Rule.new(associated_properties)
+        resource.definition # returns a definition to be added by associated_resources
+      end
+    end
+  end
+end

data/lib/jets/klass.rb

@@ -0,0 +1,109 @@
+# Loading a class can usually be loaded via .constantize.
+# But app/functions files are anonymous ruby classes created with
+# Class.new.  Anonymous classes cannot be loaded via .constantize and
+# go through standard autoloading.
+#
+# Jets::Klass provides a way to load app classes in app/controllers, app/jobs,
+# app/functions in a consistent way without having to worry about the anonymous
+# class loading quirk. Classes that are not anonymously defined like controllers
+# and jobs are loaded via autoloading with .constantize. Anonymously defined
+# classes like functions are loaded via Object.const_set.
+#
+# Examples:
+#
+#   Jets::Klass.from_path("app/controllers/posts_controller.rb")
+#   Jets::Klass.from_path("app/jobs/hard_job.rb")
+#   Jets::Klass.from_path("app/functions/hello.rb")
+#   Jets::Klass.from_path("app/functions/hello_function.rb")
+#   Jets::Klass.from_path("app/shared/functions/whatever.rb")
+#
+#   Jets::Klass.from_task(task)
+#
+# The from_task method takes a Jets::Lambda::Task as an argument and is useful
+# for the CloudFormation child stack generation there the registered task info
+# is available but the path info is now.
+class Jets::Klass
+  class << self
+    # from_path allows us to load any app classes in consistent way for
+    # app/controllers, app/jobs, and app/functions.
+    def from_path(path)
+      class_name = class_name(path)
+      if path.include?("/functions/") # simple function
+        class_name = load_anonymous_class(class_name, path)
+        class_name.constantize # removed :: for anonymous classes
+      else
+        class_name.constantize # autoload
+      end
+    end
+
+    # app/controllers/posts_controller.rb => PostsController
+    def class_name(path)
+      if path.include?("/shared/")
+        path.sub(%r{.*app/shared/(.*?)/},'').sub(/\.rb$/,'').classify
+      else
+        path.sub(%r{.*app/(.*?)/},'').sub(/\.rb$/,'').classify
+      end
+    end
+
+    def from_task(task)
+      class_name = task.class_name
+      filename = class_name.underscore
+
+      # Examples of filename: posts_controller, hard_job, security_rule,
+      #   hello_function, hello
+      valid_types = %w[controller job rule]
+      type = filename.split('_').last
+      type = "function" unless valid_types.include?(type)
+
+      path = "app/#{type.pluralize}/#{filename}.rb"
+      from_path(path)
+    end
+
+    @@loaded_anonymous_classes = []
+    def load_anonymous_class(class_name, path)
+      parent_mod = modularize(class_name)
+
+      constructor = Jets::Lambda::FunctionConstructor.new(path)
+      # Dont load anonyomous class more than once to avoid these warnings:
+      #   warning: already initialized constant Hello
+      #   warning: previous definition of Hello was here
+      unless @@loaded_anonymous_classes.include?(class_name)
+        # use class_name as the variable name for prettier class name.
+        leaf_class_name = class_name.split('::').last
+        parent_mod.const_set(leaf_class_name, constructor.build)
+        @@loaded_anonymous_classes << class_name
+      end
+
+      class_name
+    end
+
+    # Ensures the parent namespace modules are defined. Example:
+    #
+    #   modularize("Foo::Bar::Test")
+    #   => Foo::Bar # is a now defined as a module if it wasnt before
+    #
+    # Also returns the parent module, so we can use it to do a const_set if needed. IE:
+    #
+    #   parent_mod = modularize("Foo::Bar::Test")
+    #   parent_mod.const_set("Test")
+    def modularize(class_name)
+      leaves = []
+      mods = class_name.split('::')[0..-2] # drop the last word
+      # puts "mods: #{mods}"
+      return Object if mods.empty?
+
+      leaves = []
+      mods.each do |leaf_mod|
+        leaves += [leaf_mod]
+        namespace = leaves.join('::')
+        previous_namespace = leaves[0..-2].join('::')
+        previous_namespace = "Object" if previous_namespace.empty?
+        previous_namespace = previous_namespace.constantize
+        previous_namespace.const_set(leaf_mod, Module.new) unless Object.const_defined?(namespace)
+      end
+
+      mods.join('::').constantize
+    end
+
+  end
+end