jets_bb_fork 0.0.4

data/lib/jets/processors/deducer.rb

@@ -0,0 +1,65 @@
+# Jets::Processors::Deducer class figures out information that allows the
+# controller or job to be called. Sme key methods for deducer:
+#
+#   code - code to instance eval.  IE: PostsController.new(event, context).index
+#   path - full path to the app code. IE: #{Jets.root}app/controllers/posts_controller.rb
+#
+class Jets::Processors::Deducer
+  def initialize(handler)
+    @handler = handler # handlers/controllers/posts.show
+    # @handler_path: "handlers/controllers/posts"
+    # @handler_method: "show"
+    @handler_path, @handler_method = @handler.split('.')
+  end
+
+  def code
+    # code: "PostsController.process(event, context, meth: "show")"
+    # code: "HardJob.process(event, context, meth: "dig")"
+    %|#{class_name}.process(event, context, "#{@handler_method}")|
+  end
+
+  # Input: @handler_path: handlers/jobs/hard_job.rb
+  # Output: #{Jets.root/app/jobs/hard_job.rb
+  def path
+    @handler_path.sub("handlers", "app") + ".rb"
+  end
+
+  # process_type is key. It can be either "controller" or "job". It is used to
+  # deduce the rest of the methods: code, path.
+  def process_type
+    if shared?
+      "function" # all app/shared/functions are always function process_type
+    else
+      @handler.split('/')[1].singularize # controller, job, rule, etc
+    end
+  end
+
+  def shared?
+    @handler.include?("/shared/functions")
+  end
+
+  # Example underscored_class_name:
+  #   class_name = underscored_class_name
+  #   class_name = class_name # PostsController
+  def class_name
+    regexp = shared? ?
+      Regexp.new(".*handlers/shared/functions/") :
+      Regexp.new(".*handlers/#{process_type.pluralize}/")
+
+    # Example regexp:
+    #   /.*handlers\/controllers\//
+    #   /.*handlers\/jobs\//
+    class_name = @handler_path.sub(regexp, "")
+    # Example class names:
+    #   posts_controller
+    #   hard_job
+    #   hello
+    #   hello_function
+
+    class_name.camelize
+  end
+
+  def load_class
+    Jets::Klass.from_path(path)
+  end
+end

data/lib/jets/processors/main_processor.rb

@@ -0,0 +1,61 @@
+require 'json'
+require 'stringio'
+
+# Node shim calls this class to process both controllers and jobs
+class Jets::Processors::MainProcessor
+  attr_reader :event, :context, :handler
+  def initialize(event, context, handler)
+    @event = event
+    @context = context
+    @handler = handler
+  end
+
+  def run
+    # Use the handler to deduce app code to run.
+    # Example handlers: handlers/controllers/posts.create, handlers/jobs/sleep.perform
+    #
+    #   deducer = Jets::Processors::Deducer.new("handlers/controllers/posts.create")
+    #
+    deducer = Jets::Processors::Deducer.new(handler)
+    begin
+      # Examples:
+      #   deducer.code => PostsController.process(event, context, "show")
+      #   deducer.path => app/controllers/posts_controller.rb
+      #
+      #   deducer.code => HardJob.process(event, context, "dig")
+      #   deducer.path => app/jobs/hard_job.rb
+      #
+      #   deducer.code => HelloFunction.process(event, context, "world")
+      #   deducer.path => app/functions/hello.rb
+      deducer.load_class
+      # result = PostsController.process(event, context, "create")
+      result = instance_eval(deducer.code, deducer.path)
+      result = HashWithIndifferentAccess.new(result) if result.is_a?(Hash)
+
+      Jets.increase_call_count
+
+      if result.is_a?(Hash) && result["headers"]
+        # API Gateway is okay with the header values as Integers but
+        # ELBs are more strict about this and require the header values to be Strings
+        result["headers"]["x-jets-call-count"] = Jets.call_count.to_s
+        result["headers"]["x-jets-prewarm-count"] = Jets.prewarm_count.to_s
+      end
+
+      result
+    rescue Exception => e
+      unless ENV['TEST']
+        # Customize error message slightly so nodejs shim can process the
+        # returned error message.
+        # The "RubyError: " is a marker that the javascript shim scans for.
+        $stderr.puts("RubyError: #{e.class}: #{e.message}") # js needs this as the first line
+        backtrace = e.backtrace.map {|l| "  #{l}" }
+        $stderr.puts(backtrace)
+        # No need to having error in stderr above anymore because errors are handled in memory
+        # at ruby_server.rb but keeping around for posterity.
+      end
+
+      Jets.on_exception(e)
+      raise(e) # raise error to ruby_server.rb to rescue and handle
+    end
+  end
+end

data/lib/jets/rack_server.rb

@@ -0,0 +1,86 @@
+module Jets
+  class RackServer
+    def self.start(options={})
+      new(options).start
+    end
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def start
+      return unless File.exist?("#{rack_project}/config.ru")
+      puts "Starting additional rack server for the project under the rack subfolder..." if ENV['JETS_DEBUG']
+
+      if ENV['FOREGROUND']
+        serve
+        return
+      end
+
+      # Reaching here means we'll run the server in the background.
+      # Handle daemonzing ourselves because it keeps the stdout of the 2nd
+      # rack server. The rackup --daemonize option ends up hiding the output.
+      pid = Process.fork
+      if pid.nil?
+        # we're in the child process
+        serve
+      else
+        # we're in the parent process
+        Process.detach(pid) # dettached but still in the "foreground" since bin/rackup runs in the foreground
+      end
+    end
+
+    # Runs in the child process
+    def serve
+      # Note, looks like stopping jets server with Ctrl-C sends the TERM signal
+      # down to the sub bin/rackup command cleans up the child process fine.
+      Bundler.with_clean_env do
+        args = ''
+        # only forward the host option, port is always 9292 for simplicity
+        if @options[:host]
+          args << " --host #{@options[:host]}"
+        else
+          args << " --host 127.0.0.1" # using the default localhost is not starting up https://stackoverflow.com/questions/4356646/address-family-not-supported-by-protocol-family
+        end
+
+
+        command = "cd #{rack_project} && bin/rackup#{args}" # leads to the same wrapper rack scripts
+        puts "=> #{command}".color(:green)
+        system(command)
+      end
+    end
+
+    # blocks until rack server is up
+    def wait_for_socket
+      return unless Jets.rack?
+
+      retries = 0
+      max_retries = 30 # 15 seconds at a delay of 0.5s
+      delay = 0.5
+      if ENV['C9_USER'] # overrides for local testing
+        max_retries = 3
+        delay = 3
+      end
+      begin
+        server = TCPSocket.new('localhost', 9292)
+        server.close
+      rescue Errno::ECONNREFUSED, Errno::EAFNOSUPPORT
+        puts "Unable to connect to localhost:9292. Delay for #{delay} and will try to connect again."  if ENV['JETS_DEBUG']
+        sleep(delay)
+        retries += 1
+        if retries < max_retries
+          retry
+        else
+          puts "Giving up on trying to connect to localhost:9292"
+          return false
+        end
+      end
+      puts "Connected to localhost:9292 successfully"
+      true
+    end
+
+    def rack_project
+      "#{Jets.root}/rack"
+    end
+  end
+end

data/lib/jets/rdoc.rb

@@ -0,0 +1,30 @@
+module Jets
+  module Rdoc
+    # Use for both jets.gemspec and rake rdoc task
+    def options
+      exclude = %w[
+        docs
+        spec
+        vendor
+        core.rb
+        .js
+        templates
+        commands
+        internal
+        support
+        Dockerfile
+        Dockerfile.base
+        Gemfile
+        Gemfile.lock
+        Guardfile
+        LICENSE
+        Procfile
+        Rakefile
+        bin
+      ]
+      exclude = exclude.map { |word| ['-x', word] }.flatten
+      ["-m", "README.md", "--markup", "tomdoc"] + exclude
+    end
+    extend self
+  end
+end

data/lib/jets/resource.rb

@@ -0,0 +1,71 @@
+class Jets::Resource
+  extend Memoist
+
+  attr_reader :definition, :replacements
+  def initialize(definition, replacements={})
+    @definition = definition
+    @replacements = replacements
+  end
+
+  def template
+    standarize(definition)
+  end
+  memoize :template
+
+  # CloudFormation Resources reference: https://amzn.to/2NKg6ip
+  def standarize(*definition)
+    Standardizer.new(definition).template
+  end
+
+  def logical_id
+    id = template.keys.first
+    # replace possible {namespace} in the logical id
+    id = replacer.replace_value(id)
+    id = Jets::Camelizer.camelize(id)
+
+    Jets::Resource.truncate_id(id)
+  end
+
+  def self.truncate_id(id)
+    # Api Gateway resource name has a limit of 64 characters.
+    # Yet it throws not found when ID is longer than 62 characters and I don't know why.
+    # To keep it safe, let's stick to the 62 characters limit.
+    if id.size > 62
+      "#{id[0..55]}#{Digest::MD5.hexdigest(id)[0..5]}"
+    else
+      id
+    end
+  end
+
+  def type
+    attributes['Type']
+  end
+
+  def properties
+    attributes['Properties']
+  end
+
+  def attributes
+    attributes = template.values.first
+    attributes = replacer.replace_placeholders(attributes)
+    Jets::Camelizer.transform(attributes)
+  end
+
+  def parameters
+    {}
+  end
+
+  def outputs
+    {}
+  end
+
+  def replacer
+    Replacer.new(replacements)
+  end
+  memoize :replacer
+
+  def permission
+    Permission.new(replacements, self)
+  end
+  memoize :permission
+end

data/lib/jets/resource/api_gateway/base_path/function.rb

@@ -0,0 +1,42 @@
+module Jets::Resource::ApiGateway::BasePath
+  class Function < Jets::Resource::Base
+    include Jets::Resource::Lambda::Function::Environment
+
+    def definition
+      {
+        base_path_function: {
+          type: "AWS::Lambda::Function",
+          properties: {
+            function_name: function_name,
+            code: {
+              s3_bucket: "!Ref S3Bucket",
+              s3_key: code_s3_key,
+            },
+            role: "!GetAtt BasePathRole.Arn",
+            handler: handler,
+            runtime: "ruby2.5",
+            timeout: 60,
+            memory_size: 1536,
+            environment: env_properties[:environment],
+          }
+        }
+      }
+    end
+
+    def function_name
+      method = "jets-base-path"
+      # need to add the deployment timestamp because or else function name collides between deploys
+      timestamp = Jets::Resource::ApiGateway::Deployment.timestamp
+      "#{Jets.config.project_namespace}-#{method}-#{timestamp}"
+    end
+
+    def handler
+      "handlers/functions/jets/base_path.lambda_handler"
+    end
+
+    def code_s3_key
+      checksum = Jets::Builders::Md5.checksums["stage/code"]
+      "jets/code/code-#{checksum}.zip" # s3_key
+    end
+  end
+end

data/lib/jets/resource/api_gateway/base_path/mapping.rb

@@ -0,0 +1,44 @@
+# CloudFormation Docs AWS::ApiGateway::DomainName: https://amzn.to/2BsrSqo
+#
+# Example:
+#
+#   Type: AWS::ApiGateway::BasePathMapping
+#   Properties:
+#     BasePath: String
+#     DomainName: String
+#     RestApiId: String
+#     Stage: String
+#
+# Currently unable to add base path mapping in-place with CloudFormation.
+# The workaround for this is to do it post deployment with raw API calls outside
+# of CloudFormation.  Leaving this around for now in case there's a workaround
+# to get this into CloudFormation instead of raw API calls. Some notes:
+#   * Also tried to change the domain name of to something like demo-dev-[random].mydomain.com
+#   That does not work because the domain name has to match the route53 record exactly.
+#
+module Jets::Resource::ApiGateway::BasePath
+  class Mapping < Jets::Resource::Base
+    def definition
+      function_logical_id = "BasePathFunction" # lambda function that supports custom resource
+      {
+        base_path_mapping: {
+          type: "Custom::BasePathMapping",
+          properties: {
+            service_token: "!GetAtt #{function_logical_id}.Arn",
+            # base_path: '', # empty path represents root
+            # domain_name: "!Ref DomainName",
+            # rest_api_id: "!Ref RestApi", # since this is in the Deployment template
+            # stage: Deployment.stage_name,
+          },
+          depends_on: Jets::Resource::ApiGateway::Deployment.logical_id,
+        }
+      }
+    end
+
+    def outputs
+      {
+        "BasePathMapping" => "!Ref BasePathMapping",
+      }
+    end
+  end
+end

data/lib/jets/resource/api_gateway/base_path/role.rb

@@ -0,0 +1,76 @@
+module Jets::Resource::ApiGateway::BasePath
+  class Role < Jets::Resource::Base
+    extend Memoist
+    include Jets::AwsServices
+
+    def definition
+      {
+        base_path_role: {
+          type: "AWS::IAM::Role",
+          properties: {
+            role_name: role_name,
+            path: "/",
+            assume_role_policy_document: {
+              version: "2012-10-17",
+              statement: [{
+                effect: "Allow",
+                principal: {service: ["lambda.amazonaws.com"]},
+                action: ["sts:AssumeRole"]}
+              ]
+            },
+            policies: [
+              policy_name: "#{role_name}-policy",
+              policy_document: policy_document,
+            ]
+          },
+        }
+      }
+    end
+
+    def policy_document
+      project_namespace = Jets.config.project_namespace
+      default_policy_statements = Jets::Application.default_iam_policy # Array of Hashes
+      apigateway = [{
+        action: [ "apigateway:*" ],
+        effect: "Allow",
+        resource: "arn:aws:apigateway:#{Jets.aws.region}::/restapis/*", # scoped to all restapis because this changes
+      },{
+        action: [ "apigateway:*" ],
+        effect: "Allow",
+        resource: "arn:aws:apigateway:#{Jets.aws.region}::/domainnames/*", # scoped to all restapis because this changes
+      }]
+      cloudformation = [{
+        action: ["cloudformation:DescribeStacks"],
+        effect: "Allow",
+        resource: "arn:aws:cloudformation:#{Jets.aws.region}:#{Jets.aws.account}:stack/#{project_namespace}*",
+      }]
+
+      # Combine the statements
+      {
+        version: '2012-10-17',
+        statement: default_policy_statements + apigateway + cloudformation
+      }
+    end
+
+    # Duplicated in rest_api/change_detection.rb, base_path/role.rb, rest_api/routes.rb
+    def rest_api_id
+      stack_name = Jets::Naming.parent_stack_name
+      return "RestApi" unless stack_exists?(stack_name)
+
+      stack = cfn.describe_stacks(stack_name: stack_name).stacks.first
+
+      api_gateway_stack_arn = lookup(stack[:outputs], "ApiGateway")
+
+      # resources = cfn.describe_stack_resources(stack_name: api_gateway_stack_arn).stack_resources
+      stack = cfn.describe_stacks(stack_name: api_gateway_stack_arn).stacks.first
+      rest_api_id = lookup(stack[:outputs], "RestApi")
+    end
+    memoize :rest_api_id
+
+    def role_name
+      # TODO: dont think we should change the role name every time but have to right now because the deployment logical id changes
+      timestamp = Jets::Resource::ApiGateway::Deployment.timestamp
+      "#{Jets.config.project_namespace}-base-path-mapping-#{timestamp}"
+    end
+  end
+end