jets 5.0.14 → 6.0.0

data/lib/jets/cli/init.rb

@@ -0,0 +1,90 @@
+class Jets::CLI
+  class Init < Jets::CLI::Group::Base
+    include Jets::Util::Sure
+
+    def self.cli_options
+      [
+        [:env, type: :boolean, desc: "Generate config/jets/env/.env example file"],
+        [:force, aliases: :f, type: :boolean, desc: "Bypass overwrite are you sure prompt for existing files"],
+        [:yes, aliases: :y, type: :boolean, desc: "Skip are you sure prompt"]
+      ]
+    end
+    cli_options.each { |args| class_option(*args) }
+
+    source_root "#{__dir__}/init/templates"
+
+    private
+
+    def sure_message
+      detected_message = "Detected #{framework.titleize} framework.\n" if framework
+      <<~EOL
+        #{detected_message}This will initialize the project for Jets.
+
+        It will make changes to your project source code.
+
+        Please make sure you have backed up and committed your changes first.
+      EOL
+    end
+
+    def configure_rails
+      # config/environments/production.rb adjustments
+      # Comment out public_file_server.enabled on new Rails 7.0 apps
+      #    config.public_file_server.enabled = ENV["RAILS_SERVE_STATIC_FILES"].present?
+      comment_out_line("config.public_file_server.enabled = ENV", env: "production")
+      config_environment("config.public_file_server.enabled = false\n\n", env: "production")
+      # Comment out config.asset_host = "http://assets.example.com" on new Rails 7.0 apps
+      #    config.asset_host = "http://assets.example.com"
+      comment_out_line('config.asset_host = "', env: "production")
+      asset_host = <<~EOL
+
+        # Assets https://docs.rubyonjets.com/docs/assets/cloudfront/
+        config.asset_host = ENV["JETS_ASSET_HOST"] unless ENV["JETS_ASSET_HOST"].blank?
+      EOL
+      config_environment(asset_host, env: "production")
+
+      jets_job = <<~EOL
+        # Jobs https://docs.rubyonjets.com/docs/jobs/enable/
+        # config.active_job.queue_adapter = :jets_job
+      EOL
+      config_environment(jets_job, env: "production")
+    end
+
+    def configure_hanami
+      after = "  class App < Hanami::App\n"
+      data = <<~EOL
+        # https://guides.hanamirb.org/v2.1/assets/using-a-cdn/
+        # https://docs.rubyonjets.com/docs/assets/cloudfront/
+        config.assets.base_url = ENV["JETS_ASSET_HOST"] if ENV["JETS_ASSET_HOST"]
+      EOL
+      inject_into_file "config/app.rb", optimize_indentation(data, 4), after: after, verbose: true
+    end
+
+    public
+
+    def are_you_sure?
+      return if options[:yes] || options[:force]
+      sure?(sure_message)
+    end
+
+    def env_example
+      # need to create .env for RAILS_ENV=production
+      create_env = @options[:env].nil? ? framework == "rails" : @options[:env]
+      if create_env
+        template "env/.env.tt", "config/jets/env/.env"
+      end
+    end
+
+    def config_jets
+      directory "config/jets", "config/jets"
+    end
+
+    def configure_environment
+      case framework
+      when "rails"
+        configure_rails
+      when "hanami"
+        configure_hanami
+      end
+    end
+  end
+end

data/lib/jets/cli/lambda/checks.rb

@@ -0,0 +1,22 @@
+module Jets::CLI::Lambda
+  module Checks
+    extend Memoist
+
+    def check_deployed!
+      return if stack_exists?(Jets.project.namespace)
+      warn "ERROR: Project has not been deployed".color(:red)
+      exit 1
+    end
+
+    def check_workers!
+      return if workers_deployed?
+      warn "No worker functions deployed"
+      exit 1
+    end
+
+    def workers_deployed?
+      Jets::CLI::Maintenance::Worker::Saver.new(@options).lambda_functions.size > 0
+    end
+    memoize :workers_deployed?
+  end
+end

data/lib/jets/cli/lambda/function.rb

@@ -0,0 +1,104 @@
+module Jets::CLI::Lambda
+  class Function
+    include Jets::AwsServices
+    attr_reader :function_name
+    alias_method :name, :function_name
+
+    def initialize(function_name)
+      @function_name = function_name
+    end
+
+    # Environment Variables
+    def environment_variables
+      response = lambda_client.get_function_configuration(function_name: function_name)
+      response.environment.variables.sort.to_h
+    end
+
+    def environment_variables=(env_vars)
+      current_env = environment_variables
+
+      # Update existing vars and remove vars set to nil
+      updated_env = current_env.merge(env_vars.stringify_keys) { |key, old_val, new_val| new_val.nil? ? nil : new_val }
+      updated_env.compact!  # Removes all key-value pairs where value is nil
+
+      lambda_client.update_function_configuration(
+        function_name: function_name,
+        environment: {variables: updated_env}
+      )
+    end
+
+    # Reserved Concurrency
+    def reserved_concurrency
+      response = lambda_client.get_function_concurrency(function_name: function_name)
+      response.reserved_concurrent_executions
+    rescue Aws::Lambda::Errors::ResourceNotFoundException
+      nil  # No reserved concurrency set implies no limit
+    end
+
+    def reserved_concurrency=(concurrency)
+      if concurrency.nil?
+        lambda_client.delete_function_concurrency(function_name: function_name)
+      else
+        lambda_client.put_function_concurrency(
+          function_name: function_name,
+          reserved_concurrent_executions: concurrency
+        )
+      end
+    end
+
+    def provisioned_concurrency(qualifier = "live")
+      info = provisioned_concurrency_info(qualifier)
+      (info[:status] == "not set") ? nil : info[:requested]
+    end
+
+    # Provisioned Concurrency
+    def provisioned_concurrency_info(qualifier = "live")
+      response = lambda_client.get_provisioned_concurrency_config(
+        function_name: function_name,
+        qualifier: qualifier
+      )
+      {
+        requested: response.requested_provisioned_concurrent_executions,
+        allocated: response.allocated_provisioned_concurrent_executions,
+        status: response.status
+      }
+    rescue Aws::Lambda::Errors::ResourceNotFoundException,
+      Aws::Lambda::Errors::ProvisionedConcurrencyConfigNotFoundException
+      {
+        status: "not set"
+      }
+    end
+
+    def provisioned_concurrency=(concurrency, qualifier = "live")
+      if concurrency.nil? || concurrency == 0
+        begin
+          lambda_client.delete_provisioned_concurrency_config(
+            function_name: function_name,
+            qualifier: qualifier
+          )
+        rescue Aws::Lambda::Errors::ResourceNotFoundException
+        end
+      else
+        lambda_client.put_provisioned_concurrency_config(
+          function_name: function_name,
+          qualifier: qualifier,
+          provisioned_concurrent_executions: concurrency
+        )
+      end
+    end
+
+    # Check if reserved concurrency is zero or not set
+    def reserved_concurrency_zero?
+      reserved_concurrency == 0
+    end
+
+    # Check if provisioned concurrency is unset
+    def provisioned_concurrency_unset?(qualifier = "live")
+      pc = provisioned_concurrency(qualifier)
+      pc.nil? || (pc[:requested] == 0 && pc[:allocated] == 0)
+    rescue Aws::Lambda::Errors::ResourceNotFoundException,
+      Aws::Lambda::Errors::ProvisionedConcurrencyConfigNotFoundException
+      true  # Treat not found as unset
+    end
+  end
+end

data/lib/jets/cli/lambda/functions.rb

@@ -0,0 +1,10 @@
+module Jets::CLI::Lambda
+  module Functions
+    extend Memoist
+    def lambda_functions
+      names = Jets::CLI::Functions.new(full: true).all
+      names.map { |name| Jets::CLI::Lambda::Function.new(name) }
+    end
+    memoize :lambda_functions
+  end
+end

data/lib/jets/cli/lambda/lookup.rb

@@ -0,0 +1,68 @@
+module Jets::CLI::Lambda
+  class Lookup
+    class Error < StandardError
+      class ParentStack < self; end
+
+      class Output < self; end
+
+      class ChildStack < self; end
+    end
+
+    class << self
+      def function(name)
+        new(name).lookup
+      end
+    end
+
+    include Jets::AwsServices
+    def initialize(name)
+      @name = name
+    end
+
+    MAX_FUNCTION_NAME_SIZE = 64
+    def function_name
+      name = if @name.starts_with?(Jets.project.namespace)
+        @name # fully qualified function name
+      elsif !ENV["JETS_RESET"]
+        [Jets.project.namespace, @name].join("-")
+      else
+        lookup
+      end
+      (name.size > MAX_FUNCTION_NAME_SIZE) ? lookup : name
+    end
+
+    def lookup
+      if @name == "controller"
+        class_name, meth = "Controller", ""
+      else
+        # IE: jets-prewarm_event-handle
+        #     class_name => "JetsPrewarm" - no colons ::
+        #     meth => "Handle"
+        parts = @name.split("-")
+        meth = parts.pop.tr("-", "_").camelize
+        class_name = parts.join("_").camelize
+      end
+
+      parent_name = Jets::Names.parent_stack_name
+      parent = cfn.describe_stacks(stack_name: parent_name).stacks.first
+      unless parent
+        raise Error::ParentStack, "Unable to find parent stack #{parent_name}"
+      end
+
+      # Can occur while stack is initially creating for the first time
+      output = parent.outputs.find { |o| o.output_key == class_name }
+      unless output
+        raise Error::Output, "Unable to find output #{class_name} in parent stack #{parent_name}"
+      end
+
+      # Can occur while stack is initially creating for the first time
+      child_name = output.output_value
+      child = cfn.describe_stacks(stack_name: child_name).stacks.first
+      unless child
+        raise Error::ChildStack, "Unable to find child stack #{parent_name}"
+      end
+      output = child.outputs.find { |o| o.output_key == "#{meth}LambdaFunction" }
+      output.output_value
+    end
+  end
+end

data/lib/jets/cli/login.rb

@@ -0,0 +1,7 @@
+class Jets::CLI
+  class Login < Base
+    def run
+      Jets::Api::Config.instance.update_api_key(@options[:token])
+    end
+  end
+end

data/lib/jets/cli/logout.rb

@@ -0,0 +1,7 @@
+class Jets::CLI
+  class Logout < Base
+    def run
+      Jets::Api::Config.instance.clear_token
+    end
+  end
+end

data/lib/jets/cli/logs.rb

@@ -0,0 +1,40 @@
+require "aws-logs"
+
+class Jets::CLI
+  class Logs < Base
+    include Jets::AwsServices::AwsHelpers
+
+    def run
+      options = @options.dup # so it can be modified
+      options[:log_group_name] = log_group_name
+      options[:since] ||= "10m" # by default, start search 10m in the past
+      options[:wait_exists_retries] = 60 # 300 seconds = 300 / 5 = 60 retries
+      options[:wait_exists_seconds] = 5
+
+      verb = options[:follow] ? "Tailing" : "Showing"
+      warn "#{verb} logs for #{options[:log_group_name]}"
+
+      tail = AwsLogs::Tail.new(options)
+      tail.run
+    end
+
+    def log_group_name
+      log_group_name = @options[:log_group_name] # can be nil
+      if log_group_name.nil?
+        begin
+          log_group_name = Jets::CLI::Lambda::Lookup.function("controller") # function_name
+        rescue Jets::CLI::Call::Error => e
+          puts "ERROR: #{e.message}"
+          abort "Unable to determine log group name by looking it up. Can you double check it?"
+        end
+      end
+      unless log_group_name.include?(Jets.project.namespace)
+        log_group_name = "#{Jets.project.namespace}-#{log_group_name}"
+      end
+      unless log_group_name.include?("aws/lambda")
+        log_group_name = "/aws/lambda/#{log_group_name}"
+      end
+      log_group_name
+    end
+  end
+end

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

@@ -0,0 +1,15 @@
+class Jets::CLI::Maintenance
+  class Base < Jets::CLI::Base
+    include Jets::CLI::Lambda::Checks
+    include Jets::Util::Truthy
+
+    def initialize(options = {})
+      super
+      check_deployed!
+    end
+
+    def status
+      on? ? "on" : "off"
+    end
+  end
+end

data/lib/jets/cli/maintenance/mode.rb

@@ -0,0 +1,44 @@
+class Jets::CLI::Maintenance
+  class Mode < Base
+    def on
+      are_you_sure?
+      warn "Enabling #{role_info} maintenance mode #{for_info}"
+      role.on
+    end
+
+    def off
+      warn "Disabling #{role_info} maintenance mode #{for_info}"
+      role.off
+    end
+
+    def status
+      if @options[:all]
+        warn "Maintenance status for #{Jets.project.namespace}"
+        puts "web #{Web.new.status}"
+        puts "worker #{Worker.new.status}"
+      else
+        warn "#{role_info.titleize} maintenance status #{for_info}"
+        puts role.status
+      end
+    end
+
+    def are_you_sure?
+      sure?("Will enable #{role_info} maintenance mode #{for_info}")
+    end
+
+    def role_info
+      @options[:role]
+    end
+
+    def for_info
+      "for #{Jets.project.namespace}"
+    end
+
+    def role
+      # IE: Web or Worker
+      klass = Jets::CLI::Maintenance.const_get(@options[:role].camelize)
+      klass.new(@options)
+    end
+    memoize :role
+  end
+end

data/lib/jets/cli/maintenance/web.rb

@@ -0,0 +1,31 @@
+class Jets::CLI::Maintenance
+  class Web < Base
+    def initialize(options = {})
+      super
+      function_name = Jets::CLI::Lambda::Lookup.function("controller")
+      @lambda_function = Jets::CLI::Lambda::Function.new(function_name)
+    end
+
+    def on
+      if on?
+        warn "Web maintenance is already on"
+      else
+        @lambda_function.environment_variables = {JETS_MAINTENANCE: "on"}
+        warn "Web maintenance has been turned on"
+      end
+    end
+
+    def off
+      if on?
+        @lambda_function.environment_variables = {JETS_MAINTENANCE: nil}
+        warn "Web maintenance has been turned off"
+      else
+        warn "Web maintenance is already off"
+      end
+    end
+
+    def on?
+      truthy?(@lambda_function.environment_variables["JETS_MAINTENANCE"])
+    end
+  end
+end

data/lib/jets/cli/maintenance/worker/base.rb

@@ -0,0 +1,22 @@
+class Jets::CLI::Maintenance::Worker
+  class Base < Jets::CLI::Base
+    include Jets::CLI::Lambda::Functions
+
+    attr_reader :s3_bucket
+    def initialize(options = {})
+      super
+      @s3_bucket = Jets.aws.s3_bucket
+    end
+
+    def state_file
+      "jets/state/maintenance/lambda_concurrency_settings.json"
+    end
+
+    def lambda_functions
+      super.select do |lambda_function|
+        # Accounts for both app/events and app/jobs (from jets geneneration)
+        lambda_function.name.match(/_event-/)
+      end
+    end
+  end
+end

data/lib/jets/cli/maintenance/worker/restorer.rb

@@ -0,0 +1,19 @@
+class Jets::CLI::Maintenance::Worker
+  class Restorer < Base
+    def restore_concurrency_settings
+      data = read_from_s3
+      data.each do |function_name, settings|
+        lambda_function = Jets::CLI::Lambda::Function.new(function_name)
+        lambda_function.reserved_concurrency = settings["reserved_concurrency"] if settings["reserved_concurrency"]
+        lambda_function.provisioned_concurrency = settings["provisioned_concurrency"] if settings["provisioned_concurrency"]
+      end
+    end
+
+    private
+
+    def read_from_s3
+      response = s3.get_object(bucket: s3_bucket, key: state_file)
+      JSON.parse(response.body.read)
+    end
+  end
+end

data/lib/jets/cli/maintenance/worker/saver.rb

@@ -0,0 +1,15 @@
+class Jets::CLI::Maintenance::Worker
+  class Saver < Base
+    def save_concurrency_settings
+      concurrency_settings = Jets::CLI::Concurrency::Info.new(@options).concurrency_settings
+      save_to_s3(concurrency_settings)
+    end
+
+    private
+
+    def save_to_s3(data)
+      s3.put_object(bucket: s3_bucket, key: state_file, body: data.to_json)
+      log.debug "Saved concurrency settings to s3://#{s3_bucket}/#{state_file}"
+    end
+  end
+end

data/lib/jets/cli/maintenance/worker/zeroer.rb

@@ -0,0 +1,19 @@
+class Jets::CLI::Maintenance::Worker
+  class Zeroer < Base
+    def zero_all_concurrency
+      lambda_functions.each do |lambda_function|
+        # must zero provisioned before reserved
+        lambda_function.provisioned_concurrency = nil
+        lambda_function.reserved_concurrency = 0
+      end
+    end
+
+    def all_zeroed?
+      lambda_functions.all? do |lambda_function|
+        # check both reserved and provisioned
+        lambda_function.provisioned_concurrency_unset? &&
+          lambda_function.reserved_concurrency_zero?
+      end
+    end
+  end
+end

data/lib/jets/cli/maintenance/worker.rb

@@ -0,0 +1,31 @@
+class Jets::CLI::Maintenance
+  class Worker < Base
+    def on
+      check_workers!
+
+      if on?
+        warn "Worker maintenance is already on"
+      else
+        Saver.new(@options).save_concurrency_settings
+        Zeroer.new(@options).zero_all_concurrency
+        warn "Worker maintenance has been turned on"
+      end
+    end
+
+    def off
+      check_workers!
+
+      if on?
+        Restorer.new(@options).restore_concurrency_settings
+        warn "Worker maintenance has been turned off"
+      else
+        warn "Worker maintenance is already off"
+      end
+    end
+
+    def on?
+      check_workers!
+      Zeroer.new(@options).all_zeroed?
+    end
+  end
+end

data/lib/jets/cli/maintenance.rb

@@ -0,0 +1,32 @@
+class Jets::CLI
+  class Maintenance < Jets::Thor::Base
+    class_option :role, aliases: [:r], default: "web", desc: "Role to apply the maintenance mode to. IE: web worker"
+
+    desc "on", "Turn on maintenance mode"
+    long_desc Help.text("maintenance/on")
+    yes_option
+    def on
+      Mode.new(options).on
+    end
+
+    # Note: --yes or -y is not used for the off command.
+    # User will not be prompted for confirmation.
+    # The option is allowed in case users accidentally use it.
+    # Example:
+    #   jets maintenance off -y
+    # This is why the option is hidden. This makes the user experience better.
+    desc "off", "Turn off maintenance mode"
+    long_desc Help.text("maintenance/off")
+    option :yes, aliases: [:y], type: :boolean, desc: "Skip are you sure prompt", hide: true
+    def off
+      Mode.new(options).off
+    end
+
+    desc "status", "Show maintenance mode status"
+    long_desc Help.text("maintenance/status")
+    option :all, aliases: [:a], type: :boolean, desc: "Show status for all roles. Takes precedence over --role option", default: false
+    def status
+      Mode.new(options).status
+    end
+  end
+end

data/lib/jets/cli/package/dockerfile.rb

@@ -0,0 +1,9 @@
+class Jets::CLI::Package
+  class Dockerfile < Jets::CLI::Base
+    def run
+      sure?("Will build a Dockerfile for #{Jets.project.namespace.color(:green)}")
+      Jets::Cfn::Bootstrap.new(@options).run
+      Jets::Remote::Runner.new(@options.merge(command: "package:dockerfile")).run
+    end
+  end
+end

data/lib/jets/cli/package.rb

@@ -0,0 +1,8 @@
+class Jets::CLI
+  class Package < Jets::Thor::Base
+    desc "dockerfile", "Build dockerfile"
+    def dockerfile
+      Dockerfile.new(options).run
+    end
+  end
+end

data/lib/jets/cli/ping.rb

@@ -0,0 +1,10 @@
+class Jets::CLI
+  class Ping < Base
+    rescue_api_error
+
+    def run
+      Jets::Api::Ping.create
+      puts "Auth check successful"
+    end
+  end
+end

data/lib/jets/cli/projects.rb

@@ -0,0 +1,22 @@
+class Jets::CLI
+  class Projects < Base
+    rescue_api_error
+
+    def run
+      resp = Jets::Api::Project.list(paging_params)
+      present(resp[:data])
+      paginate(resp)
+    end
+
+    private
+
+    def present(items)
+      presenter = CliFormat::Presenter.new(@options)
+      presenter.empty_message = "No projects found"
+      items.each do |item|
+        presenter.rows << [item[:name]]
+      end
+      presenter.show
+    end
+  end
+end

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

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