jets 5.0.14 → 6.0.0.beta1

data/lib/jets/cli/ci.rb

@@ -0,0 +1,55 @@
+class Jets::CLI
+  class Ci < Jets::Thor::Base
+    Init.cli_options.each { |args| option(*args) }
+    register(Init, "init", "init", "CI init creates config/jets/ci.rb")
+
+    desc "build", "CI build cfn template"
+    def build
+      Build.new(options).run
+    end
+
+    desc "deploy", "CI deploy cfn stack"
+    yes_option
+    def deploy
+      Deploy.new(options).run
+    end
+
+    desc "delete", "CI delete cfn stack"
+    yes_option
+    def delete
+      Delete.new(options).run
+    end
+
+    desc "info", "CI info"
+    format_option(default: "info")
+    def info
+      Info.new(options).run
+    end
+
+    desc "start", "CI start build"
+    yes_option
+    option :buildspec_override, desc: "Path to buildspec override file"
+    option :branch, aliases: "b", desc: "git branch" # Default is nil. Will use what's configured on AWS CodeBuild project settings.
+    option :env_vars, aliases: "e", type: :array, desc: "env var overrides. IE: KEY1=VALUE1 KEY2=VALUE2"
+    def start
+      Start.new(options).run
+    end
+
+    desc "status", "CI status of build"
+    def status
+      Status.new(options).run
+    end
+
+    desc "stop", "CI stop build"
+    yes_option
+    def stop
+      Stop.new(options).run
+    end
+
+    desc "logs", "CI logs"
+    yes_option
+    def logs
+      Logs.new(options).run
+    end
+  end
+end

data/lib/jets/cli/clean.rb

@@ -0,0 +1,10 @@
+require "fileutils"
+
+class Jets::CLI
+  class Clean < Base
+    def run
+      FileUtils.rm_rf(Jets.build_root)
+      puts "Removed #{Jets.build_root}"
+    end
+  end
+end

data/lib/jets/cli/concurrency/base.rb

@@ -0,0 +1,17 @@
+class Jets::CLI::Concurrency
+  class Base < Jets::CLI::Base
+    include Jets::CLI::Lambda::Checks
+    include Jets::Util::Truthy
+
+    def initialize(options = {})
+      super
+      check_deployed!
+    end
+
+    def account_limit
+      response = lambda_client.get_account_settings
+      response.account_limit
+    end
+    memoize :account_limit
+  end
+end

data/lib/jets/cli/concurrency/get.rb

@@ -0,0 +1,37 @@
+class Jets::CLI::Concurrency
+  class Get < Base
+    def initialize(options = {})
+      super
+      function_name = Jets::CLI::Lambda::Lookup.function(@options[:function])
+      @lambda_function = Jets::CLI::Lambda::Function.new(function_name)
+    end
+
+    def run
+      puts <<~EOL
+        Settings for Function: #{@lambda_function.name}
+        Reserved concurreny: #{reserved_concurrency}
+        Provisioned concurrency: #{provisioned_concurrency}
+      EOL
+    end
+
+    def provisioned_concurrency
+      info = @lambda_function.provisioned_concurrency_info
+
+      if @lambda_function.provisioned_concurrency.nil?
+        "not set"
+      elsif info[:status] == "IN_PROGRESS"
+        "#{info[:allocated]}/#{info[:requested]} (In progress)"
+      else
+        @lambda_function.provisioned_concurrency
+      end
+    end
+
+    def reserved_concurrency
+      if @lambda_function.reserved_concurrency.nil?
+        "not set. Will scale to unreserved limit: #{account_limit.unreserved_concurrent_executions}"
+      else
+        @lambda_function.reserved_concurrency
+      end
+    end
+  end
+end

data/lib/jets/cli/concurrency/info.rb

@@ -0,0 +1,86 @@
+class Jets::CLI::Concurrency
+  class Info < Base
+    include Jets::CLI::Lambda::Functions
+
+    def run
+      concurrency_info
+      account_limit_info
+    end
+
+    def concurrency_info
+      warn "Concurrency for #{Jets.project.namespace}"
+
+      presenter = CliFormat::Presenter.new(@options)
+      presenter.empty_message = "No Lambda Functions found"
+      presenter.header = ["Function"]
+      presenter.header << "Reserved" if has_reserved?
+      presenter.header << "Provisioned" if has_provisioned?
+      concurrency_settings.each do |function_name, concurrency_info|
+        row = []
+        row << function_name.gsub("#{Jets.project.namespace}-", "")
+        if has_reserved?
+          reserved = concurrency_info[:reserved_concurrency]
+          @reserved_concurrency_total ||= 0
+          @reserved_concurrency_total += reserved.to_i
+          row << reserved
+        end
+        if has_provisioned?
+          provisioned = concurrency_info[:provisioned_concurrency]
+          @provisioned_concurrency_total ||= 0
+          @provisioned_concurrency_total += provisioned.to_i
+          row << provisioned
+        end
+        presenter.rows << row
+      end
+
+      # Totals row
+      unless presenter.rows.empty?
+        totals = ["total"]
+        totals << @reserved_concurrency_total if @reserved_concurrency_total
+        totals << @provisioned_concurrency_total if @provisioned_concurrency_total
+        presenter.rows << totals
+      end
+      presenter.show
+    end
+
+    def concurrency_settings
+      concurrency_settings = {}
+
+      lambda_functions.each do |lambda_function|
+        concurrency_info = {
+          reserved_concurrency: lambda_function.reserved_concurrency,
+          provisioned_concurrency: lambda_function.provisioned_concurrency
+        }
+        concurrency_info.delete_if { |_, v| v.nil? }
+        concurrency_settings[lambda_function.name] = concurrency_info
+      end
+
+      concurrency_settings
+    end
+    memoize :concurrency_settings
+
+    def has_reserved?
+      concurrency_settings.any? { |_, info| info.key?(:reserved_concurrency) }
+    end
+
+    def has_provisioned?
+      concurrency_settings.any? { |_, info| info.key?(:provisioned_concurrency) }
+    end
+
+    def account_limit_info
+      message = <<~EOL
+        Account Limits
+          Concurrent Executions: #{account_limit.concurrent_executions}
+          Unreserved Concurrent Executions: #{account_limit.unreserved_concurrent_executions}
+      EOL
+      if has_unreserved?
+        message << "Functions with no reserved limit scale to Unreserved Concurrent Executions\n"
+      end
+      warn message
+    end
+
+    def has_unreserved?
+      concurrency_settings.any? { |_, info| !info.key?(:reserved_concurrency) }
+    end
+  end
+end

data/lib/jets/cli/concurrency/set.rb

@@ -0,0 +1,31 @@
+class Jets::CLI::Concurrency
+  class Set < Get
+    def run
+      sure? "Will update the concurrency settings for #{Jets.project.namespace}"
+      puts "Updating concurrency settings for #{Jets.project.namespace}"
+
+      if @options[:reserved]
+        @lambda_function.reserved_concurrency = @options[:reserved]
+        puts "Set reserved concurrency to #{@options[:reserved]}"
+      end
+
+      if @options[:provisioned]
+        success = set_provisioned_concurrency(@options[:provisioned])
+        puts "Set provisioned concurrency to #{@options[:provisioned]}" if success
+      end
+
+      Jets::CLI::Tip.show(:concurrency_change)
+    end
+
+    def set_provisioned_concurrency(value)
+      @lambda_function.provisioned_concurrency = value
+      true # success
+    rescue Aws::Lambda::Errors::ResourceNotFoundException => e
+      # Can happen for Events Lambda Lambda Functions where Wersion and Alias resources are only created when specified in config/jets
+      # For controller Lambda Function the Alias and Version resource is always created.
+      if e.message.include?("Cannot find alias")
+        puts "ERROR: The live alias does not exist for the function. Please deploy the function an initial provisioned concurrency first.".color(:red)
+      end
+    end
+  end
+end

data/lib/jets/cli/concurrency/unset.rb

@@ -0,0 +1,21 @@
+class Jets::CLI::Concurrency
+  class Unset < Set
+    def run
+      sure? "Will unset the concurrency settings for #{Jets.project.namespace}"
+      puts "Unsetting concurrency settings for #{Jets.project.namespace}"
+
+      if @options[:reserved]
+        @lambda_function.reserved_concurrency = nil
+        puts "Removed reserved concurrency"
+        puts "Will scale to your AWS account unreserved limit. Currently: #{account_limit.unreserved_concurrent_executions}"
+      end
+
+      if @options[:provisioned]
+        success = set_provisioned_concurrency(0)
+        puts "Removed provisioned concurrency" if success
+      end
+
+      Jets::CLI::Tip.show(:concurrency_change)
+    end
+  end
+end

data/lib/jets/cli/concurrency.rb

@@ -0,0 +1,33 @@
+class Jets::CLI
+  class Concurrency < Jets::Thor::Base
+    desc "info", "Concurrency info"
+    format_option(default: "table")
+    def info
+      Info.new(options).run
+    end
+
+    desc "get", "Get concurrency for function"
+    function_name_option
+    def get
+      Get.new(options).run
+    end
+
+    desc "set", "Set concurrency for function"
+    function_name_option
+    option :reserved, type: :numeric, desc: "Reserved concurrency"
+    option :provisioned, type: :numeric, desc: "Provisioned concurrency"
+    yes_option
+    def set
+      Set.new(options).run
+    end
+
+    desc "unset", "Unset concurrency for function"
+    function_name_option
+    option :reserved, type: :boolean, desc: "Reserved concurrency"
+    option :provisioned, type: :boolean, desc: "Provisioned concurrency"
+    yes_option
+    def unset
+      Unset.new(options).run
+    end
+  end
+end

data/lib/jets/cli/curl/adapter/base.rb

@@ -0,0 +1,8 @@
+module Jets::CLI::Curl::Adapter
+  class Base
+    extend Memoist
+    def initialize(options)
+      @options = options
+    end
+  end
+end

data/lib/jets/cli/curl/adapter/cookies/jar.rb

@@ -0,0 +1,28 @@
+module Jets::CLI::Curl::Adapter::Cookies
+  class Jar
+    include Jets::Util::Logging
+
+    def initialize(result, filename)
+      @result, @filename = result, filename
+    end
+
+    def write_to_file
+      cookies = @result[:cookies]
+      if cookies.nil? || cookies.empty?
+        log.debug "No cookies found in the result."
+        return
+      end
+
+      File.open(@filename, "w") do |file|
+        cookies.each do |cookie|
+          file.puts("# HTTP Cookie File")
+          file.puts("# Created by jets curl #{Jets::VERSION}")
+          file.puts("# Date: #{Time.now}\n\n")
+          file.puts("#{cookie}\n")
+        end
+      end
+
+      log.debug "Cookies written to #{@filename}."
+    end
+  end
+end

data/lib/jets/cli/curl/adapter/cookies/parser.rb

@@ -0,0 +1,48 @@
+module Jets::CLI::Curl::Adapter::Cookies
+  class Parser
+    def initialize(cookie_string)
+      @cookie_string = cookie_string
+    end
+
+    def parse
+      if @cookie_string.include?("=")
+        parse_inline_cookies
+      else
+        parse_cookies_from_file
+      end
+    end
+
+    private
+
+    def skip_line?(line)
+      line.empty? || line.start_with?("#")
+    end
+
+    def parse_inline_cookies
+      cookies = []
+
+      @cookie_string.split(";").each do |cookie|
+        cookie = cookie.strip
+        cookies << cookie unless skip_line?(cookie)
+      end
+
+      cookies
+    end
+
+    def parse_cookies_from_file
+      cookies = []
+
+      if File.exist?(@cookie_string)
+        File.open(@cookie_string, "r").each_line do |line|
+          line = line.chomp.strip
+          cookies << line unless skip_line?(line)
+        end
+      else
+        warn "Error: File '#{@cookie_string}' not found."
+        exit 1
+      end
+
+      cookies
+    end
+  end
+end

data/lib/jets/cli/curl/adapter/lambda.rb

@@ -0,0 +1,142 @@
+require "rack/utils"
+
+module Jets::CLI::Curl::Adapter
+  class Lambda < Base
+    def convert
+      {
+        version: "2.0",
+        routeKey: "$default",
+        rawPath: path,
+        rawQueryString: raw_query_string,
+        cookies: cookies,
+        body: body,
+        headers: headers,
+        requestContext: request_context,
+        isBase64Encoded: false
+      }.delete_if { |k, v| v.nil? }.to_json
+    end
+
+    def cookies
+      Cookies::Parser.new(@options[:cookie]).parse if @options[:cookie]
+    end
+
+    def body
+      data = @options[:data]
+      return unless data
+      if data.starts_with?("@")
+        file = data[1..]
+        file = "#{Jets.root}/#{file}" unless file.starts_with?("/")
+        IO.read(file) # IE: @data.json
+      else
+        data
+      end
+    end
+
+    def headers
+      default_headers.merge(headers_option)
+    end
+
+    def default_headers
+      {
+        host: host,
+        "x-forwarded-proto": "https",
+        "x-forwarded-port": "443",
+        "x-forwarded-for": "127.0.0.1",
+        "user-agent": "jets curl (#{Jets::VERSION})"
+      }
+    end
+
+    def headers_option
+      headers = @options[:headers] || {}
+      headers["user-agent"] = user_agent if user_agent
+      headers.transform_keys(&:downcase).transform_values(&:strip)
+    end
+
+    def host
+      return default_host unless @options[:headers]
+      deleted_host = @options[:headers].delete("Host")&.strip
+      host = @options[:headers][:host] || deleted_host
+      host || default_host
+    end
+
+    def default_host
+      host = uri.host
+      if host && (host.include?("amazonaws.com") || host.include?(".aws"))
+        host
+      else
+        "#{api_id}.lambda-url.#{aws_region}.on.aws"
+      end
+    end
+
+    def user_agent
+      return unless @options[:headers]
+      deleted_user_agent = @options[:headers].delete("User-Agent")&.strip
+      @options[:headers]["user-agent"] || deleted_user_agent
+    end
+    memoize :user_agent # run only since .delete will change the headers_option
+
+    def request_context
+      now = Time.now.utc
+      {
+        accountId: "anonymous",
+        apiId: api_id,
+        domainName: host,
+        domainPrefix: api_id,
+        http: {
+          method: http_method,
+          path: path,
+          protocol: "HTTP/1.1",
+          sourceIp: "127.0.0.1",
+          userAgent: user_agent
+        },
+        requestId: "3fca3afe-2fb7-4e93-ac3b-949519408c39",
+        routeKey: "$default",
+        stage: "$default",
+        time: now.strftime("%d/%b/%Y:%H:%M:%S %z"),
+        timeEpoch: now.to_i
+      }
+    end
+
+    def api_id
+      "dummy"
+    end
+
+    def aws_region
+      Jets.aws.region
+    end
+
+    def http_method
+      @options[:request] || "GET"
+    end
+
+    def uri
+      URI.parse(@options[:path])
+    end
+
+    def path
+      uri.path
+    end
+
+    def raw_query_string
+      uri.query
+    end
+
+    # AWS Lambda 2.0 Behavior
+    # https://docs.aws.amazon.com/apigateway/latest/developerguide/http-api-develop-integrations-lambda.html
+    def parse_query_string(raw_query_string)
+      query_params = {}
+
+      raw_query_string.split("&").each do |param|
+        key, value = param.split("=")
+        key = key.to_sym
+        if query_params.key?(key)
+          query_params[key] += ",#{value}"
+        else
+          query_params[key] = value
+        end
+      end
+
+      query_params.transform_values! { |value| value.include?(",") ? value.split(",") : value }
+    end
+  end
+end

data/lib/jets/cli/curl/request.rb

@@ -0,0 +1,62 @@
+require "active_support"
+require "active_support/core_ext/string/filters"
+
+class Jets::CLI::Curl
+  class Request < Jets::CLI::Call
+    TRIM_MAX = ENV["JETS_CURL_TRIM_MAX"] || 64
+    def run
+      warn "Calling Lambda function #{function_name}"
+      show_body
+      result = invoke
+
+      if result[:cookies] && @options[:cookie_jar]
+        cookie_jar = Adapter::Cookies::Jar.new(result, @options[:cookie_jar])
+        cookie_jar.write_to_file
+      end
+      if @options[:trim] || ENV["JETS_CURL_TRIM"]
+        trim!(result, TRIM_MAX)
+      else
+        result
+      end
+    end
+
+    def show_body
+      return unless @options[:verbose] && @options[:data]
+      hash = JSON.parse(payload)
+      body = hash["body"]
+      text = begin
+        JSON.pretty_generate(JSON.parse(body))
+      rescue JSON::ParserError
+        body
+      end
+
+      warn "Request Body:"
+      warn text
+    end
+
+    # interface method: override to convert cli curl-like options to Call payload
+    def payload
+      adapter.convert
+    end
+
+    def trim!(hash, max_length)
+      hash.transform_values! do |value|
+        if value.is_a?(String) && value.length > max_length
+          value.truncate(max_length)
+        elsif value.is_a?(Hash)
+          trim!(value, max_length)
+        elsif value.is_a?(Array)
+          value.map! { |v| (v.is_a?(String) && v.length > max_length) ? v.truncate(max_length) : v }
+        else
+          value
+        end
+      end
+    end
+
+    def adapter
+      # Only support Lambda URL for now.
+      Adapter::Lambda.new(@options)
+    end
+    memoize :adapter
+  end
+end

data/lib/jets/cli/curl.rb

@@ -0,0 +1,9 @@
+class Jets::CLI
+  class Curl < Base
+    def run
+      result = Request.new(options).run
+      # only thing that goes to stdout. so can pipe to commands like jq
+      puts JSON.pretty_generate(result)
+    end
+  end
+end

data/lib/jets/cli/delete.rb

@@ -0,0 +1,23 @@
+class Jets::CLI
+  class Delete < Base
+    def run
+      are_you_sure?
+      Jets::Cfn::Bootstrap.new(@options).run
+      Jets::Cfn::Delete.new(options).run
+    end
+
+    def are_you_sure?
+      stack_name = Jets.project.namespace
+      message = "Will delete #{stack_name.color(:green)}"
+      unless stack_exists?(stack_name)
+        message << <<~EOL
+
+          Note: It looks like the stack #{stack_name} has already been deleted.
+          Jets will create a dummy stack to delete the API deployment record.
+          The dummy stack will be deleted immediately after.
+        EOL
+      end
+      sure?(message)
+    end
+  end
+end

data/lib/jets/cli/deploy.rb

@@ -0,0 +1,18 @@
+class Jets::CLI
+  class Deploy < Base
+    def run
+      dev_mode_check!
+      sure?("Will deploy #{Jets.project.namespace.color(:green)}")
+      Tip.show(:faster_deploy)
+
+      Jets::Cfn::Bootstrap.new(@options).run
+      Jets::Remote::Runner.new(@options.merge(command: "deploy")).run
+    end
+
+    def dev_mode_check!
+      if File.exist?("#{Jets.root}/dev.mode") && !ENV["JETS_SKIP_DEV_MODE_CHECK"]
+        abort "The dev.mode file exists. Please removed it and run bundle update before you deploy.".color(:red)
+      end
+    end
+  end
+end

data/lib/jets/cli/dotenv/base.rb

@@ -0,0 +1,4 @@
+class Jets::CLI::Dotenv
+  class Base < Jets::CLI::Base
+  end
+end

data/lib/jets/cli/dotenv/get.rb

@@ -0,0 +1,14 @@
+class Jets::CLI::Dotenv
+  class Get < Base
+    def run
+      vars = Jets::Dotenv.parse
+      vars.find do |name, value|
+        if name == @options[:name]
+          puts value
+          exit # success
+        end
+      end
+      exit 1 # not found
+    end
+  end
+end