jets 3.1.0 → 5.0.10

data/lib/jets/commands/dbconsole/dbconsole_command.rb

@@ -0,0 +1,184 @@
+# frozen_string_literal: true
+
+require "active_support/core_ext/string/filters"
+require "active_support/deprecation"
+
+module Jets
+  class DBConsole
+    def self.start(*args)
+      new(*args).start
+    end
+
+    def initialize(options = {})
+      @options = options
+    end
+
+    def start
+      ENV["JETS_ENV"] ||= @options[:environment] || environment
+      config = db_config.configuration_hash
+
+      case db_config.adapter
+      when /^(jdbc)?mysql/
+        args = {
+          host: "--host",
+          port: "--port",
+          socket: "--socket",
+          username: "--user",
+          encoding: "--default-character-set",
+          sslca: "--ssl-ca",
+          sslcert: "--ssl-cert",
+          sslcapath: "--ssl-capath",
+          sslcipher: "--ssl-cipher",
+          sslkey: "--ssl-key"
+        }.filter_map { |opt, arg| "#{arg}=#{config[opt]}" if config[opt] }
+
+        if config[:password] && @options[:include_password]
+          args << "--password=#{config[:password]}"
+        elsif config[:password] && !config[:password].to_s.empty?
+          args << "-p"
+        end
+
+        args << db_config.database
+
+        find_cmd_and_exec(["mysql", "mysql5"], *args)
+
+      when /^postgres|^postgis/
+        ENV["PGUSER"]         = config[:username] if config[:username]
+        ENV["PGHOST"]         = config[:host] if config[:host]
+        ENV["PGPORT"]         = config[:port].to_s if config[:port]
+        ENV["PGPASSWORD"]     = config[:password].to_s if config[:password] && @options[:include_password]
+        ENV["PGSSLMODE"]      = config[:sslmode].to_s if config[:sslmode]
+        ENV["PGSSLCERT"]      = config[:sslcert].to_s if config[:sslcert]
+        ENV["PGSSLKEY"]       = config[:sslkey].to_s if config[:sslkey]
+        ENV["PGSSLROOTCERT"]  = config[:sslrootcert].to_s if config[:sslrootcert]
+        find_cmd_and_exec("psql", db_config.database)
+
+      when "sqlite3"
+        args = []
+
+        args << "-#{@options[:mode]}" if @options[:mode]
+        args << "-header" if @options[:header]
+        args << File.expand_path(db_config.database, Jets.respond_to?(:root) ? Jets.root : nil)
+
+        find_cmd_and_exec("sqlite3", *args)
+
+      when "oracle", "oracle_enhanced"
+        logon = ""
+
+        if config[:username]
+          logon = config[:username].dup
+          logon << "/#{config[:password]}" if config[:password] && @options[:include_password]
+          logon << "@#{db_config.database}" if db_config.database
+        end
+
+        find_cmd_and_exec("sqlplus", logon)
+
+      when "sqlserver"
+        args = []
+
+        args += ["-d", "#{db_config.database}"] if db_config.database
+        args += ["-U", "#{config[:username]}"] if config[:username]
+        args += ["-P", "#{config[:password]}"] if config[:password]
+
+        if config[:host]
+          host_arg = +"tcp:#{config[:host]}"
+          host_arg << ",#{config[:port]}" if config[:port]
+          args += ["-S", host_arg]
+        end
+
+        find_cmd_and_exec("sqlcmd", *args)
+
+      else
+        abort "Unknown command-line client for #{db_config.database}."
+      end
+    end
+
+    def db_config
+      return @db_config if defined?(@db_config)
+
+      # If the user provided a database, use that. Otherwise find
+      # the first config in the database.yml
+      if database
+        @db_config = configurations.configs_for(env_name: environment, name: database, include_hidden: true)
+      else
+        @db_config = configurations.find_db_config(environment)
+      end
+
+      unless @db_config
+        missing_db = database ? "'#{database}' database is not" : "No databases are"
+        raise ActiveRecord::AdapterNotSpecified,
+          "#{missing_db} configured for '#{environment}'. Available configuration: #{configurations.inspect}"
+      end
+
+      @db_config
+    end
+
+    def environment
+      Jets.respond_to?(:env) ? Jets.env : Jets::Command.environment
+    end
+
+    def database
+      @options[:database]
+    end
+
+    private
+      def configurations # :doc:
+        # require APP_PATH
+        ActiveRecord::Base.configurations = Jets.application.config.database_configuration
+        ActiveRecord::Base.configurations
+      end
+
+      def find_cmd_and_exec(commands, *args) # :doc:
+        commands = Array(commands)
+
+        dirs_on_path = ENV["PATH"].to_s.split(File::PATH_SEPARATOR)
+        unless (ext = RbConfig::CONFIG["EXEEXT"]).empty?
+          commands = commands.map { |cmd| "#{cmd}#{ext}" }
+        end
+
+        full_path_command = nil
+        found = commands.detect do |cmd|
+          dirs_on_path.detect do |path|
+            full_path_command = File.join(path, cmd)
+            begin
+              stat = File.stat(full_path_command)
+            rescue SystemCallError
+            else
+              stat.file? && stat.executable?
+            end
+          end
+        end
+
+        if found
+          exec full_path_command, *args
+        else
+          abort("Couldn't find database client: #{commands.join(', ')}. Check your $PATH and try again.")
+        end
+      end
+  end
+
+  module Command
+    class DbconsoleCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      class_option :include_password, aliases: "-p", type: :boolean,
+        desc: "Automatically provide the password from database.yml"
+
+      class_option :mode, enum: %w( html list line column ), type: :string,
+        desc: "Automatically put the sqlite3 database in the specified mode (html, list, line, column)."
+
+      class_option :header, type: :boolean
+
+      class_option :database, aliases: "--db", type: :string,
+        desc: "Specifies the database to use."
+
+      desc "dbconsole", "Starts DB REPL console"
+      long_desc Help.text(:dbconsole)
+      def perform
+        extract_environment_option_from_argument
+        require_application_and_environment!
+        Jets::DBConsole.start(options)
+      end
+    end
+  end
+end

data/lib/jets/commands/degenerate/degenerate_command.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+require "jets/generators"
+require "jets/commands/generate/generate_command"
+
+module Jets
+  module Command
+    class DegenerateCommand < GenerateCommand # :nodoc:
+      desc "Degenerate", "Opposite of generate. Removes the generated code."
+      long_desc Help.text(:degenerate)
+      def perform(*)
+        super
+      end
+
+    private
+      def behavior
+        :revoke
+      end
+    end
+  end
+end

data/lib/jets/commands/delete/delete_command.rb

@@ -0,0 +1,154 @@
+module Jets::Command
+  class DeleteCommand < Base # :nodoc:
+    desc "delete", "Delete the Jets project and all its resources"
+    long_desc Help.text(:delete)
+    option :yes, aliases: %w[y], type: :boolean, desc: "Skip are you sure prompt."
+    option :wait, type: :boolean, default: true, desc: "Wait for stack deletion to complete."
+    def perform
+      Delete.new(options).run
+    end
+  end
+
+  class Delete
+    include Jets::AwsServices
+    include AwsHelpers
+
+    def initialize(options={})
+      @options = options
+    end
+
+    def run
+      puts("Deleting project...")
+      return if @options[:noop]
+
+      are_you_sure?
+      confirm_project_exists
+
+      # Must first remove all objects from s3 bucket in order to delete stack
+      puts "First, deleting objects in s3 bucket #{s3_bucket_name}" if s3_bucket_name
+      empty_s3_bucket
+
+      stack_in_progress?(parent_stack_name)
+
+      cfn.delete_stack(stack_name: parent_stack_name)
+      puts "Deleting #{Jets.project_namespace.color(:green)}..."
+
+      stack = find_stack(parent_stack_name)
+      if @options[:wait]
+        wait_for_stack
+      end
+      Jets::Cfn::Deployment.new(stack_name: stack.stack_id).delete
+
+      delete_logs
+      puts "Project #{Jets.project_namespace.color(:green)} deleted!"
+    end
+
+    def wait_for_stack
+      status = Jets::Cfn::Status.new
+      start_time = Time.now
+      status.wait
+      took = Time.now - start_time
+      puts "Time took for deletion: #{status.pretty_time(took).color(:green)}."
+    end
+
+    def delete_logs
+      puts "Deleting CloudWatch logs"
+      log = Jets::Commands::Clean::Log.new(mute: true, yes: true)
+      log.clean
+    end
+
+    def confirm_project_exists
+      stack = find_stack(parent_stack_name)
+      return if stack
+      puts "ERROR: Stack #{parent_stack_name} does not exist".color(:red)
+      exit 1
+    end
+
+    def empty_s3_bucket
+      return unless s3_bucket_name # Happens when minimal stack fails to build
+      return unless bucket_exists?(s3_bucket_name)
+
+      resp = s3.list_objects(bucket: s3_bucket_name)
+      if resp.contents.size > 0
+        # IE: objects = [{key: "objectkey1"}, {key: "objectkey2"}]
+        objects = resp.contents.map { |item| {key: item.key} }
+        s3.delete_objects(
+          bucket: s3_bucket_name,
+          delete: {
+            objects: objects,
+            quiet: false,
+          }
+        )
+        empty_s3_bucket # keep deleting objects until bucket is empty
+      end
+    end
+
+    def s3_bucket_name
+      return @s3_bucket_name if defined?(@s3_bucket_name)
+
+      resp = cfn.describe_stacks(stack_name: parent_stack_name)
+      outputs = resp.stacks[0].outputs
+      if outputs.empty?
+        @s3_bucket_name = false
+      else
+        @s3_bucket_name = outputs.find {|o| o.output_key == 'S3Bucket'}.output_value
+      end
+    end
+
+    # Thanks: https://docs.aws.amazon.com/sdk-for-ruby/v3/developer-guide/s3-example-does-bucket-exist.html
+    def bucket_exists?(bucket_name)
+      bucket_exists = false
+      begin
+        resp = s3.head_bucket(bucket: bucket_name, use_accelerate_endpoint: false)
+        bucket_exists = true
+      rescue
+      end
+      bucket_exists
+    end
+
+    def parent_stack_name
+      Jets::Names.parent_stack_name
+    end
+
+    def are_you_sure?
+      if @options[:yes]
+        sure = 'y'
+      else
+        puts "Are you sure you want to want to delete the #{Jets.project_namespace.color(:green)} project? (y/N)"
+        sure = $stdin.gets
+      end
+
+      unless sure =~ /^y/
+        puts "Phew! Jets #{Jets.project_namespace.color(:green)} project was not deleted."
+        exit 0
+      end
+    end
+
+    # All CloudFormation states listed here: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
+    #
+    # Returns resp so we can use it to grab data about the stack without calling api again.
+    def check_deleteable_status
+      return true if !stack_exists?(@parent_stack_name)
+
+      # Assumes stack exists
+      resp = cfn.describe_stacks(stack_name: @parent_stack_name)
+      status = resp.stacks[0].stack_status
+
+      return true if status == 'ROLLBACK_COMPLETE'
+
+      if status =~ /_IN_PROGRESS$/
+        puts "The '#{@parent_stack_name}' stack status is #{status}. " \
+            "It is not in an updateable status. Please wait until the stack is ready and try again.".color(:red)
+        exit 0
+      elsif resp.stacks[0].outputs.empty?
+        # This Happens when the miminal stack fails at the very beginning.
+        # There is no s3 bucket at all.  User should delete the stack.
+        puts "The minimal stack failed to create. Please delete the stack first and try again. " \
+        "You can delete the CloudFormation stack or use the `jets delete` command"
+        exit 0
+      else
+        true
+      end
+    end
+  end
+end

data/lib/jets/commands/{deploy.rb → deploy/deploy_command.rb}

@@ -1,43 +1,41 @@
-require "aws-sdk-core"
-
-module Jets::Commands
-  class Deploy
-    extend Memoist
-    include StackInfo
-    def initialize(options)
-      @options = options
-    end
-
-    def run
-      deployment_env = Jets.config.project_namespace.color(:green)
-      puts "Deploying to Lambda #{deployment_env} environment..."
+module Jets::Command
+  class DeployCommand < Base # :nodoc:
+    include EnvironmentArgument
+
+    desc "deploy", "Builds and deploys project to AWS Lambda"
+    long_desc Help.text(:deploy)
+    option :message, aliases: :m, desc: "Custom message to use for the deployment message"
+    def perform
+      extract_environment_option_from_argument
+      require_application_and_environment!
+
+      stack = Jets.project_namespace.color(:green)
+      puts "Deploying stack #{stack} ..."
       return if @options[:noop]
 
       check_dev_mode
       validate_routes!
 
-      # deploy full nested stack when stack already exists
       # Delete existing rollback stack from previous bad minimal deploy
       delete_minimal_stack if minimal_rollback_complete?
       exit_unless_updateable! # Stack could be in a weird rollback state or in progress state
 
       if first_run?
         ship(stack_type: :minimal)
-        Jets.application.reload_configs!
       end
 
-      # Build code after the minimal stack because need s3 bucket for assets
-      # on_aws? and s3_base_url logic
+      # Build code after the minimal stack because need s3 bucket for assets on_aws? and s3_base_url logic
       # TODO: possible deploy hook point: before_build
-      build_code
+      Jets::Builders::CodeBuilder.new.build
 
       # TODO: possible deploy hook point: before_ship
       create_s3_event_buckets
-      ship(stack_type: :full, s3_bucket: s3_bucket)
+      ship(stack_type: :full, s3_bucket: Jets.s3_bucket)
     end
 
+  private
     def create_s3_event_buckets
-      buckets = Jets::Job::Base.s3_events.keys
+      buckets = Jets::Job::Base._s3_events.keys
       buckets.each do |bucket|
         Jets::AwsServices::S3Bucket.ensure_exists(bucket)
       end
@@ -46,42 +44,37 @@ module Jets::Commands
     def delete_minimal_stack
       puts "Existing stack is in ROLLBACK_COMPLETE state from a previous failed minimal deploy. Deleting stack and continuing."
       cfn.delete_stack(stack_name: stack_name)
-      status.wait
-      status.reset
+      cfn_status.wait
+      cfn_status.reset
     end
 
     def check_dev_mode
-      if File.exist?("#{Jets.root}/dev.mode")
+      if File.exist?("#{Jets.root}/dev.mode") && !ENV['JETS_SKIP_DEV_MODE_CHECK']
         puts "The dev.mode file exists. Please removed it and run bundle update before you deploy.".color(:red)
         exit 1
       end
     end
 
-    def build_code
-      Jets::Commands::Build.new(@options).build_code
-    end
-
     def validate_routes!
       valid = Jets::Router.validate_routes!
-      unless valid
-        puts "Deploy fail: The jets application contain invalid routes.".color(:red)
-        exit 1
-      end
+      return if valid
+
+      puts "Deploy fail: The jets application contain invalid routes.".color(:red)
+      exit 1
     end
 
     def ship(stack_options)
-      options = @options.merge(stack_options) # includes stack_type and s3_bucket
-      Jets::Commands::Build.new(options).build_templates
+      options = @options.merge(stack_options) # includes stack_type
+      Jets::Cfn::Builder.new(options).build
       Jets::Cfn::Ship.new(options).run
     end
 
-    def status
-      Jets::Cfn::Status.new(stack_name)
+    def cfn_status
+      @cfn_status ||= Jets::Cfn::Status.new(stack_name)
     end
-    memoize :status
 
     def stack_name
-      Jets::Naming.parent_stack_name
+      Jets::Names.parent_stack_name
     end
 
     # Checks for a few things before deciding to delete the parent stack
@@ -101,37 +94,25 @@ module Jets::Commands
       resource_statuses == ['DELETE_COMPLETE']
     end
 
-    def find_stack(stack_name)
-      resp = cfn.describe_stacks(stack_name: stack_name)
-      resp.stacks.first
-    rescue Aws::CloudFormation::Errors::ValidationError => e
-      # example: Stack with id demo-dev does not exist
-      if e.message =~ /Stack with/ && e.message =~ /does not exist/
-        nil
-      else
-        raise
-      end
-    end
-
     # All CloudFormation states listed here: http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
     def exit_unless_updateable!
       return if ENV['JETS_FORCE_UPDATEABLE'] # useful for debugging if stack stack updating
 
-      stack_name = Jets::Naming.parent_stack_name
+      stack_name = Jets::Names.parent_stack_name
       exists = stack_exists?(stack_name)
       return unless exists # continue because stack could be updating
 
       stack = cfn.describe_stacks(stack_name: stack_name).stacks.first
       status = stack["stack_status"]
       if status =~ /^ROLLBACK_/ ||
-         status =~ /_IN_PROGRESS$/
+          status =~ /_IN_PROGRESS$/
         region = `aws configure get region`.strip rescue "us-east-1"
         url = "https://console.aws.amazon.com/cloudformation/home?region=#{region}#/stacks"
-        puts "The parent stack of the #{Jets.config.project_name.color(:green)} project is not in an updateable state."
+        puts "The parent stack of the #{Jets.project_name.color(:green)} project is not in an updateable state."
         puts "Stack name #{stack_name.color(:yellow)} status #{stack["stack_status"].color(:yellow)}"
         puts "Here's the CloudFormation url to check for more details #{url}"
         exit 1
       end
     end
-  end
+    end
 end

data/lib/jets/commands/dev/dev_command.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "jets/dev_caching"
+
+module Jets
+  module Command
+    class DevCommand < Base # :nodoc:
+      no_commands do
+        def help
+          say "jets dev:cache # Toggle development mode caching on/off."
+        end
+      end
+
+      def cache
+        Jets::DevCaching.enable_by_file
+      end
+    end
+  end
+end

data/lib/jets/commands/{dotenv.rb → dotenv/dotenv_command.rb}

@@ -1,5 +1,5 @@
-module Jets::Commands
-  class Dotenv < Jets::Commands::Base
+module Jets::Command
+  class DotenvCommand < Base # :nodoc:
     desc "show", "Shows evaulated dotenv values"
     long_desc Help.text('dotenv:show')
     def show

data/lib/jets/commands/encrypted/USAGE

@@ -0,0 +1,46 @@
+## Storing Encrypted Files in Source Control
+
+The Jets `encrypted` commands provide access to encrypted files or configurations.
+See the `Jets.application.encrypted` documentation for using them in your app.
+
+This is a more generalized concept of `jets credentials`.
+
+## Encryption Keys
+
+By default, Jets looks for the encryption key in `config/master.key` or
+`ENV["JETS_MASTER_KEY"]`, but that lookup can be overridden with `--key`:
+
+    jets encrypted:edit config/encrypted_file.yml.enc --key config/encrypted_file.key
+
+Don't commit the key! Add it to your source control's ignore file. If you use
+Git, Jets handles this for you.
+
+## Editing Files
+
+To edit or create an encrypted file use:
+
+    jets encrypted:edit config/encrypted_file.yml.enc
+
+This opens a temporary file in `$EDITOR` with the decrypted contents for editing.
+
+## Viewing Files
+
+To print the decrypted contents of an encrypted file use:
+
+    jets encrypted:show config/encrypted_file.yml.enc
+
+## Access in App
+
+Let's say you have encrypted like so:
+
+    ❯ jets encrypted:show config/encrypted_file.yml.enc
+    cloud:
+      foo: bar
+
+You can access them in the app like so:
+
+    $ jets console
+    > file = ActiveSupport::EncryptedFile.new(content_path: "./config/encrypted_file.yml.enc", key_path: "./config/master.key", env_key: Jets.env, raise_if_missing_key: true)
+    > YAML.load(file.read)
+    => {"cloud"=>{"foo"=>"bar"}}
+    >

data/lib/jets/commands/encrypted/encrypted_command.rb

@@ -0,0 +1,87 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "active_support"
+require "jets/command/helpers/editor"
+
+module Jets
+  module Command
+    class EncryptedCommand < Jets::Command::Base # :nodoc:
+      include Helpers::Editor
+
+      class_option :key, aliases: "-k", type: :string,
+        default: "config/master.key", desc: "The Jets.root relative path to the encryption key"
+
+      no_commands do
+        def help
+          say "Usage:\n  #{self.class.banner}"
+          say ""
+          say self.class.desc
+        end
+      end
+
+      def edit(file_path)
+        require_application!
+        encrypted = Jets.application.encrypted(file_path, key_path: options[:key])
+
+        ensure_editor_available(command: "bin/jets encrypted:edit") || (return)
+        ensure_encryption_key_has_been_added(options[:key]) if encrypted.key.nil?
+        ensure_encrypted_file_has_been_added(file_path, options[:key])
+
+        catch_editing_exceptions do
+          change_encrypted_file_in_system_editor(file_path, options[:key])
+        end
+
+        say "File encrypted and saved."
+      rescue ActiveSupport::MessageEncryptor::InvalidMessage
+        say "Couldn't decrypt #{file_path}. Perhaps you passed the wrong key?"
+      end
+
+      def show(file_path)
+        require_application!
+        encrypted = Jets.application.encrypted(file_path, key_path: options[:key])
+
+        say encrypted.read.presence || missing_encrypted_message(key: encrypted.key, key_path: options[:key], file_path: file_path)
+      end
+
+      private
+        def ensure_encryption_key_has_been_added(key_path)
+          encryption_key_file_generator.add_key_file(key_path)
+          encryption_key_file_generator.ignore_key_file(key_path)
+        end
+
+        def ensure_encrypted_file_has_been_added(file_path, key_path)
+          encrypted_file_generator.add_encrypted_file_silently(file_path, key_path)
+        end
+
+        def change_encrypted_file_in_system_editor(file_path, key_path)
+          Jets.application.encrypted(file_path, key_path: key_path).change do |tmp_path|
+            system("#{ENV["EDITOR"]} #{tmp_path}")
+          end
+        end
+
+
+        def encryption_key_file_generator
+          require "rails/generators"
+          require "rails/generators/rails/encryption_key_file/encryption_key_file_generator"
+
+          Rails::Generators::EncryptionKeyFileGenerator.new
+        end
+
+        def encrypted_file_generator
+          require "rails/generators"
+          require "rails/generators/rails/encrypted_file/encrypted_file_generator"
+
+          Rails::Generators::EncryptedFileGenerator.new
+        end
+
+        def missing_encrypted_message(key:, key_path:, file_path:)
+          if key.nil?
+            "Missing '#{key_path}' to decrypt data. See `bin/jets encrypted:help`"
+          else
+            "File '#{file_path}' does not exist. Use `bin/jets encrypted:edit #{file_path}` to change that."
+          end
+        end
+    end
+  end
+end