jets-fs 1.6.10

data/lib/jets/rack_server.rb

@@ -0,0 +1,80 @@
+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 = ''
+        args << " --host #{@options[:host]}" if @options[:host] # only forward the host option
+                                                                # port is always 9292 for simplicity
+        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
+        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,74 @@
+class Jets::Resource
+  extend Memoist
+
+  autoload :ApiGateway, 'jets/resource/api_gateway'
+  autoload :Associated, 'jets/resource/associated'
+  autoload :Base, 'jets/resource/base'
+  autoload :ChildStack, 'jets/resource/child_stack'
+  autoload :Config, 'jets/resource/config'
+  autoload :Events, 'jets/resource/events'
+  autoload :Iam, 'jets/resource/iam'
+  autoload :Lambda, 'jets/resource/lambda'
+  autoload :Permission, 'jets/resource/permission'
+  autoload :Replacer, 'jets/resource/replacer'
+  autoload :Route53, 'jets/resource/route53'
+  autoload :S3, 'jets/resource/s3'
+  autoload :Sns, 'jets/resource/sns'
+  autoload :Sqs, 'jets/resource/sqs'
+  autoload :Standardizer, 'jets/resource/standardizer'
+
+  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)
+    Jets::Camelizer.camelize(id)
+  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.rb

@@ -0,0 +1,9 @@
+module Jets::Resource::ApiGateway
+  autoload :BasePath, 'jets/resource/api_gateway/base_path'
+  autoload :Cors, 'jets/resource/api_gateway/cors'
+  autoload :Deployment, 'jets/resource/api_gateway/deployment'
+  autoload :DomainName, 'jets/resource/api_gateway/domain_name'
+  autoload :Method, 'jets/resource/api_gateway/method'
+  autoload :Resource, 'jets/resource/api_gateway/resource'
+  autoload :RestApi, 'jets/resource/api_gateway/rest_api'
+end

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

@@ -0,0 +1,5 @@
+module Jets::Resource::ApiGateway::BasePath
+  autoload :Function, 'jets/resource/api_gateway/base_path/function'
+  autoload :Mapping, 'jets/resource/api_gateway/base_path/mapping'
+  autoload :Role, 'jets/resource/api_gateway/base_path/role'
+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

data/lib/jets/resource/api_gateway/cors.rb

@@ -0,0 +1,61 @@
+module Jets::Resource::ApiGateway
+  # Might be weird inheriting from Method because Method has Method#cors also
+  # but Cors is essentially a Method class.
+  class Cors < Method
+    def definition
+      {
+        cors_logical_id => {
+          type: "AWS::ApiGateway::Method",
+
+          properties: {
+            resource_id: "!Ref #{resource_id}",
+            rest_api_id: "!Ref #{RestApi.logical_id}",
+            authorization_type: cors_authorization_type,
+            http_method: "OPTIONS",
+            method_responses: [{
+              status_code: '200',
+              response_parameters: response_parameters(true),
+              response_models: {},
+            }],
+            request_parameters: {},
+            integration: {
+              type: "MOCK",
+              request_templates: {
+                "application/json": "{statusCode:200}",
+              },
+              integration_responses: [{
+                status_code: '200',
+                response_parameters: response_parameters,
+                response_templates: {
+                  "application/json": '',
+                },
+              }] # closes integration_responses
+            } # closes integration
+          } # closes properties
+        } # closes logical id
+      } # closes definition
+    end
+
+    def response_parameters(method_response=false)
+      cors_headers.map do |k,v|
+        k = "method.response.header.#{k}"
+        v = method_response ? true : "'#{v}'" # surround value with single quotes
+        [k,v]
+      end.to_h
+    end
+
+    # Always the pre-flight headers in this case
+    def cors_headers
+      rack = Jets::Controller::Middleware::Cors.new(Jets.application)
+      rack.cors_headers(true)
+    end
+
+    def cors_authorization_type
+      Jets.config.api.cors_authorization_type || @route.authorization_type || "NONE"
+    end
+
+    def cors_logical_id
+      "#{resource_logical_id}_cors_api_method"
+    end
+  end
+end

data/lib/jets/resource/api_gateway/deployment.rb

@@ -0,0 +1,78 @@
+module Jets::Resource::ApiGateway
+  class Deployment < Jets::Resource::Base
+    def definition
+      {
+        deployment_logical_id => {
+          type: "AWS::ApiGateway::Deployment",
+          properties: {
+            description: "Version #{timestamp} deployed by jets",
+            rest_api_id: "!Ref #{RestApi.logical_id}",
+            stage_name: stage_name,
+          }
+        }
+      }
+    end
+
+    def parameters
+      p = {
+        "IamRole" => "IamRole",
+        "RestApi" => "RestApi",
+        "S3Bucket" => "S3Bucket",
+      }
+      p[:DomainName] = "DomainName" if Jets.custom_domain?
+      p
+    end
+
+    def outputs(internal=false)
+      rest_api = internal ? RestApi.internal_logical_id : "RestApi"
+      {
+        "RestApiUrl" => "!Sub 'https://${#{rest_api}}.execute-api.${AWS::Region}.amazonaws.com/#{stage_name}/'",
+      }
+    end
+
+    def depends_on
+      expression = "#{Jets::Naming.template_path_prefix}-*_controller*"
+      controller_logical_ids = []
+      Dir.glob(expression).each do |path|
+        next unless File.file?(path)
+
+        regexp = Regexp.new(".*#{Jets.config.project_namespace}-")
+        controller_name = path.sub(regexp, '').sub('.yml', '')
+        # map the path to a camelized logical_id. Example:
+        #   /tmp/jets/demo/templates/demo-dev-2-posts_controller.yml to
+        #   PostsController
+        controller_logical_id = controller_name.underscore.camelize
+
+        controller_logical_ids << controller_logical_id
+      end
+      controller_logical_ids
+    end
+
+    # stage_name: dev, dev-1, dev-2, etc
+    def stage_name
+      self.class.stage_name
+    end
+
+    def self.stage_name
+      # Stage name only allows a-zA-Z0-9_
+      [Jets.config.short_env, Jets.config.env_extra].compact.join('_').gsub('-','_')
+    end
+
+    def timestamp
+      self.class.timestamp
+    end
+
+    @@timestamp = nil
+    def self.timestamp
+      @@timestamp ||= Time.now.strftime("%Y%m%d%H%M%S")
+    end
+
+    def deployment_logical_id
+      self.class.logical_id.underscore
+    end
+
+    def self.logical_id
+      "ApiDeployment#{timestamp}"
+    end
+  end
+end