jets 4.0.17 → 5.0.0.beta1

data/lib/jets/commands/call/caller.rb

@@ -0,0 +1,184 @@
+module Jets::Commands::Call
+  class Caller
+    include Jets::AwsServices
+
+    def initialize(provided_function_name, event, options={})
+      @options = options
+      @guess = @options[:guess].nil? ? true : @options[:guess]
+
+      @provided_function_name = provided_function_name
+      @event = event
+
+      @invocation_type = options[:invocation_type] || "RequestResponse"
+      @log_type = options[:log_type] || "Tail"
+      @qualifier = @qualifier
+    end
+
+    def function_name
+      if @provided_function_name == 'controller'
+        "#{Jets.project_namespace}-controller"
+      elsif @provided_function_name.starts_with?(Jets.project_namespace)
+        @provided_function_name # fully qualified function name
+      elsif @guess
+        ensure_guesses_found! # possibly exits here
+        guesser.function_name # guesser adds namespace already
+      else
+        [Jets.project_namespace, @provided_function_name].join('-')
+      end
+    end
+
+    def run
+      @options[:local] ? local_run : remote_run
+    end
+
+    # With local mode there is no way to bypass the guesser
+    def local_run
+      puts "Local mode enabled!"
+      ensure_guesses_found! # possibly exits here
+      klass = guesser.class_name.constantize
+      # Example:
+      #   PostsController.process(event, context, meth)
+      event = JSON.load(transformed_event) || {} # transformed_event is JSON text String
+
+      fun = Jets::Poly.new(klass, guesser.method_name)
+      result = fun.run(event) # check the logs for polymorphic function errors
+      # Note: even though data might not always be json, the JSON.dump does a
+      # good job of not bombing, so always calling it to simplify code.
+
+      text = Jets::Util.normalize_result(result)
+      STDOUT.puts text
+    end
+
+    def remote_run
+      puts "Calling lambda function #{function_name} on AWS" unless @options[:mute]
+      return if @options[:noop]
+
+      options = {
+        # client_context: client_context,
+        function_name: function_name,
+        invocation_type: @invocation_type, # "Event", # RequestResponse
+        log_type: @log_type, # pretty sweet
+        payload: transformed_event, # "fileb://file-path/input.json", <= JSON
+        qualifier: @qualifier, # "1",
+      }
+
+      begin
+        resp = lambda_client.invoke(options)
+      rescue Aws::Lambda::Errors::ResourceNotFoundException
+        puts "The function #{function_name} was not found.  Maybe check the spelling or the AWS_PROFILE?".color(:red)
+        return
+      end
+
+      if @options[:show_logs] || @options[:show_log]
+        puts "Last 4KB of log in the x-amz-log-result header:".color(:green)
+        puts Base64.decode64(resp.log_result)
+      end
+
+      add_console_link_to_clipboard
+      result = resp.payload.read # already been normalized/JSON.dump by AWS
+      unless @options[:mute_output]
+        STDOUT.puts result # only thing that goes to stdout
+      end
+    end
+
+    def guesser
+      @guesser ||= Guesser.new(@provided_function_name)
+    end
+
+    def ensure_guesses_found!
+      unless guesser.class_name and guesser.method_name
+        puts guesser.error_message
+        exit
+      end
+    end
+
+    # @event is String because it can be the file:// notation
+    # Returns text String for the lambda.invoke payload.
+    def transformed_event
+      text = @event
+      if text && text.include?("file://")
+        text = load_event_from_file(text)
+      end
+
+      check_valid_json!(text)
+
+      puts "Function name: #{function_name.color(:green)}" unless @options[:mute]
+      return text unless function_name.include?("_controller-")
+      return text if @options[:lambda_proxy] == false
+
+      event = JSON.load(text)
+      lambda_proxy = {"queryStringParameters" => event}
+      JSON.dump(lambda_proxy)
+    end
+
+    def load_event_from_file(text)
+      path = text.gsub('file://','')
+      path = "#{Jets.root}/#{path}" unless path[0..0] == '/'
+      unless File.exist?(path)
+        puts "File #{path} does not exist.  Are you sure the file exists?".color(:red)
+        exit
+      end
+      text = IO.read(path)
+    end
+
+    # Exits with friendly error message when user provides bad just
+    def check_valid_json!(text)
+      JSON.load(text)
+    rescue JSON::ParserError => e
+      puts "Invalid json provided:\n  '#{text}'"
+      puts "Exiting... Please try again and provide valid json."
+      exit 1
+    end
+
+    # So use can quickly paste this into their browser if they want to see the function
+    # via the Lambda console
+    def add_console_link_to_clipboard
+      return unless RUBY_PLATFORM =~ /darwin/
+      return unless system("type pbcopy > /dev/null")
+
+      # TODO: for add_console_link_to_clipboard get the region from the ~/.aws/config and AWS_PROFILE setting
+      region = Aws::S3::Client.new.config.region || ENV["AWS_REGION"] ||'us-east-1'
+      link = "https://console.aws.amazon.com/lambda/home?region=#{region}#/functions/#{function_name}?tab=configuration"
+      system("echo #{link} | pbcopy")
+      puts "Pro tip: The Lambda Console Link to the #{function_name} function has been added to your clipboard." unless @options[:mute]
+    end
+
+    # TODO: Hook client_context up and make sure it works. Think I've figure out how to sign client_context below.
+    # Client context must be a valid Base64-encoded JSON object
+    # Example: http://docs.aws.amazon.com/mobileanalytics/latest/ug/PutEvents.html
+    def client_context
+      context = {
+        "client" => {
+          "client_id" => "Jets",
+          "app_title" => "jets call cli",
+          "app_version_name" => Jets::VERSION,
+        },
+        "custom" => {},
+        "env" =>{
+          "platform" => RUBY_PLATFORM,
+          "platform_version" => RUBY_VERSION,
+        }
+      }
+      Base64.encode64(JSON.dump(context))
+    end
+
+    # For this class redirect puts to stderr so user can pipe output to tools like
+    # jq. Example:
+    #   jets call posts_controller-index '{"test":1}' | jq .
+    def puts(text)
+      $stderr.puts(text)
+    end
+
+    def lambda_client
+      opt = {}
+      opt = opt.merge({retry_limit: @options[:retry_limit]}) if @options[:retry_limit].present?
+      opt = opt.merge({http_read_timeout: @options[:read_timeout]}) if @options[:read_timeout].present?
+
+      if opt.empty?
+        aws_lambda
+      else
+        Aws::Lambda::Client.new(opt)
+      end
+    end
+  end
+end

data/lib/jets/commands/call/guesser.rb

@@ -25,7 +25,7 @@
 #
 # Now we're at a point where we can start guessing
 # function_name = detect_function_name(function_name)
-class Jets::Commands::Call
+module Jets::Commands::Call
   class Guesser
     delegate :class_name, :method_name, :error_message, :function_name,
       to: :delegate_guesser

data/lib/jets/commands/clean/base.rb

@@ -1,4 +1,4 @@
-class Jets::Commands::Clean
+module Jets::Commands::Clean
   class Base
     def initialize(options={})
       @options = options

data/lib/jets/commands/clean/build.rb

@@ -1,6 +1,6 @@
 require 'fileutils'
 
-class Jets::Commands::Clean
+module Jets::Commands::Clean
   class Build < Base
     def clean
       are_you_sure?("delete /tmp/jets")

data/lib/jets/commands/clean/clean_command.rb

@@ -0,0 +1,15 @@
+module Jets::Command
+  class CleanCommand < Base # :nodoc:
+    desc "log", "Cleans CloudWatch log groups assocated with app"
+    long_desc Help.text("clean/log")
+    def log
+      Jets::Commands::Clean::Log.new(options).clean
+    end
+
+    desc "build", "Cleans jets build"
+    long_desc Help.text("clean/build")
+    def build
+      Jets::Commands::Clean::Build.new(options).clean
+    end
+  end
+end

data/lib/jets/commands/clean/log.rb

@@ -8,7 +8,7 @@
 # log groups and we don't want to overly-aggressively delete them.
 #
 # The `keep_prefixes(log_group_names)` method calcuates the log groups to keep.
-class Jets::Commands::Clean
+module Jets::Commands::Clean
   class Log < Base
     extend Memoist
     include Jets::AwsServices

data/lib/jets/commands/configure/configure_command.rb

@@ -0,0 +1,9 @@
+module Jets::Command
+  class ConfigureCommand < Base # :nodoc:
+    desc "configure [TOKEN]", "configure token and updates ~/.jets/config.yml"
+    long_desc Help.text(:configure)
+    def perform(token=nil)
+      Jets::Api::Config.instance.update_token(token)
+    end
+  end
+end

data/lib/jets/commands/console/console_command.rb

@@ -0,0 +1,38 @@
+# frozen_string_literal: true
+
+require "irb"
+require "irb/completion"
+
+module Jets::Command
+  class ConsoleCommand < Base # :nodoc:
+    include EnvironmentArgument
+
+    desc "console", "REPL console with Jets environment loaded"
+    long_desc Help.text(:console)
+    def perform
+      extract_environment_option_from_argument
+      require_application_and_environment!
+      Console.new(options).run
+    end
+  end
+
+  class Console
+    attr_reader :environment
+
+    def initialize(environment)
+      @environment = environment
+    end
+
+    def run
+      puts Jets::Booter.message
+
+      # Thanks: https://mutelight.org/bin-console
+      require "irb"
+      require "irb/completion"
+
+      ARGV.clear # https://stackoverflow.com/questions/33070092/irb-start-not-starting/33136762
+      IRB.start
+    end
+  end
+
+end

data/lib/jets/commands/credentials/USAGE

@@ -0,0 +1,103 @@
+## Storing Encrypted Credentials in Source Control
+
+The Jets `credentials` commands provide access to encrypted credentials,
+so you can safely store access tokens, database passwords, and the like
+safely inside the app without relying on a mess of ENVs.
+
+This also allows for atomic deploys: no need to coordinate key changes
+to get everything working as the keys are shipped with the code.
+
+## Setup
+
+Applications after Jets 5 automatically have a basic credentials file generated
+that just contains the secret_key_base used by MessageVerifiers/MessageEncryptors, like the ones
+signing and encrypting cookies.
+
+For applications created prior to Jets 5, we'll automatically generate a new
+credentials file in `config/credentials.yml.enc` the first time you run `bin/jets credentials:edit`.
+If you didn't have a master key saved in `config/master.key`, that'll be created too.
+
+Don't lose this master key! Put it in a password manager your team can access.
+Should you lose it no one, including you, will be able to access any encrypted
+credentials.
+
+Don't commit the key! Add `config/master.key` to your source control's
+ignore file. If you use Git, Jets handles this for you.
+
+Jets also looks for the master key in `ENV["JETS_MASTER_KEY"]`, if that's easier to manage.
+
+You could prepend that to your server's start command like this:
+
+    JETS_MASTER_KEY="very-secret-and-secure" server.start
+
+## Set up Git to Diff Credentials
+
+Jets provides `bin/jets credentials:diff --enroll` to instruct Git to call
+`bin/jets credentials:diff` when `git diff` is run on a credentials file.
+
+Running the command enrolls the project such that all credentials files use the
+"jets_credentials" diff driver in .gitattributes.
+
+Additionally since Git requires the driver itself to be set up in a config file
+that isn't tracked Jets automatically ensures it's configured when running
+`credentials:edit`.
+
+Otherwise each co-worker would have to run enable manually, including on each new
+repo clone.
+
+To disenroll from this feature, run `bin/jets credentials:diff --disenroll`.
+
+## Editing Credentials
+
+This will open a temporary file in `$EDITOR` with the decrypted contents to edit
+the encrypted credentials.
+
+When the temporary file is next saved the contents are encrypted and written to
+`config/credentials.yml.enc` while the file itself is destroyed to prevent credentials
+from leaking.
+
+## Environment Specific Credentials
+
+The `credentials` command supports passing an `--environment` option to create an
+environment specific override. That override will take precedence over the
+global `config/credentials.yml.enc` file when running in that environment. So:
+
+    bin/jets credentials:edit --environment development
+
+will create `config/credentials/development.yml.enc` with the corresponding
+encryption key in `config/credentials/development.key` if the credentials file
+doesn't exist.
+
+The encryption key can also be put in `ENV["JETS_MASTER_KEY"]`, which takes
+precedence over the file encryption key.
+
+In addition to that, the default credentials lookup paths can be overridden through
+`config.credentials.content_path` and `config.credentials.key_path`.
+
+## Editor wait
+
+For editors that fork and exit immediately, it's important to pass a wait flag,
+otherwise the credentials will be saved immediately with no chance to edit.
+
+    EDITOR="code --wait" jets credentials:edit
+
+## Accessing in App
+
+Let's say you have credentials like so:
+
+    ❯ jets credentials:show
+    secret_key_base: somesecretvalue
+    foo: bar
+
+You can access them in the app like so:
+
+    ❯ jets console
+    > Jets.application.credentials.secret_key_base
+    => "somesecretvalue"
+    > Jets.application.credentials.foo
+    => "bar"
+    > Jets.application.credentials.does_not_exist
+    => nil
+
+Remember, when you deploy this to Lambda you should set the `JETS_MASTER_KEY`. You set it with [Env Files](https://rubyonjets.com/docs/env-files/). Otherwise the `Jets.application.credentials.xx` values will return `nil`.
+

data/lib/jets/commands/credentials/credentials_command/diffing.rb

@@ -0,0 +1,51 @@
+# frozen_string_literal: true
+
+module Jets::Command::CredentialsCommand::Diffing # :nodoc:
+  GITATTRIBUTES_ENTRY = <<~END
+    config/credentials/*.yml.enc diff=jets_credentials
+    config/credentials.yml.enc diff=jets_credentials
+  END
+
+  def enroll_project_in_credentials_diffing
+    if enrolled_in_credentials_diffing?
+      say "Project is already enrolled in credentials file diffing."
+    else
+      gitattributes.write(GITATTRIBUTES_ENTRY, mode: "a")
+
+      say "Enrolled project in credentials file diffing!"
+      say "Jets ensures the jets_credentials diff driver is set when running `credentials:edit`. See `credentials:help` for more."
+    end
+  end
+
+  def disenroll_project_from_credentials_diffing
+    if enrolled_in_credentials_diffing?
+      gitattributes.write(gitattributes.read.gsub(GITATTRIBUTES_ENTRY, ""))
+      gitattributes.delete if gitattributes.empty?
+
+      say "Disenrolled project from credentials file diffing!"
+    else
+      say "Project is not enrolled in credentials file diffing."
+    end
+  end
+
+  def ensure_diffing_driver_is_configured
+    configure_diffing_driver if enrolled_in_credentials_diffing? && !diffing_driver_configured?
+  end
+
+  private
+    def enrolled_in_credentials_diffing?
+      gitattributes.file? && gitattributes.read.include?(GITATTRIBUTES_ENTRY)
+    end
+
+    def diffing_driver_configured?
+      system "git config --get diff.jets_credentials.textconv", out: File::NULL
+    end
+
+    def configure_diffing_driver
+      system "git config diff.jets_credentials.textconv 'bin/jets credentials:diff'"
+    end
+
+    def gitattributes
+      Jets.root.join(".gitattributes")
+    end
+end

data/lib/jets/commands/credentials/credentials_command.rb

@@ -0,0 +1,139 @@
+# frozen_string_literal: true
+
+require "pathname"
+require "shellwords"
+require "active_support"
+
+module Jets
+  module Command
+    class CredentialsCommand < Jets::Command::Base # :nodoc:
+      include Helpers::Editor
+      include EnvironmentArgument
+
+      require_relative "credentials_command/diffing"
+      include Diffing
+
+      self.environment_desc = "Uses credentials from config/credentials/:environment.yml.enc encrypted by config/credentials/:environment.key key"
+
+      no_commands do
+        def help
+          say "Usage:\n  #{self.class.banner}"
+          say ""
+          say self.class.desc
+        end
+      end
+
+      def edit
+        extract_environment_option_from_argument(default_environment: nil)
+        require_application!
+
+        ensure_editor_available(command: "bin/jets credentials:edit") || (return)
+
+        ensure_encryption_key_has_been_added if credentials.key.nil?
+        ensure_credentials_have_been_added
+        ensure_diffing_driver_is_configured
+
+        catch_editing_exceptions do
+          change_credentials_in_system_editor
+        end
+
+        say "File encrypted and saved."
+      rescue ActiveSupport::MessageEncryptor::InvalidMessage
+        say "Couldn't decrypt #{content_path}. Perhaps you passed the wrong key?"
+      end
+
+      def show
+        extract_environment_option_from_argument(default_environment: nil)
+        require_application!
+
+        say credentials.read.presence || missing_credentials_message
+      end
+
+      option :enroll, type: :boolean, default: false,
+        desc: "Enrolls project in credentials file diffing with `git diff`"
+
+      option :disenroll, type: :boolean, default: false,
+        desc: "Disenrolls project from credentials file diffing"
+
+      def diff(content_path = nil)
+        if @content_path = content_path
+          extract_environment_option_from_argument(default_environment: extract_environment_from_path(content_path))
+          require_application!
+
+          say credentials.read.presence || credentials.content_path.read
+        else
+          require_application!
+          disenroll_project_from_credentials_diffing if options[:disenroll]
+          enroll_project_in_credentials_diffing if options[:enroll]
+        end
+      rescue ActiveSupport::MessageEncryptor::InvalidMessage
+        say credentials.content_path.read
+      end
+
+      private
+        def credentials
+          Jets.application.encrypted(content_path, key_path: key_path)
+        end
+
+        def ensure_encryption_key_has_been_added
+          encryption_key_file_generator.add_key_file(key_path)
+          encryption_key_file_generator.ignore_key_file(key_path)
+        end
+
+        def ensure_credentials_have_been_added
+          if options[:environment]
+            encrypted_file_generator.add_encrypted_file_silently(content_path, key_path)
+          else
+            credentials_generator.add_credentials_file_silently
+          end
+        end
+
+        def change_credentials_in_system_editor
+          credentials.change do |tmp_path|
+            system(*Shellwords.split(ENV["EDITOR"]), tmp_path.to_s)
+          end
+        end
+
+        def missing_credentials_message
+          if credentials.key.nil?
+            "Missing '#{key_path}' to decrypt credentials. See `bin/jets credentials:help`"
+          else
+            "File '#{content_path}' does not exist. Use `bin/jets credentials:edit` to change that."
+          end
+        end
+
+        def content_path
+          @content_path ||= options[:environment] ? "config/credentials/#{options[:environment]}.yml.enc" : "config/credentials.yml.enc"
+        end
+
+        def key_path
+          options[:environment] ? "config/credentials/#{options[:environment]}.key" : "config/master.key"
+        end
+
+        def extract_environment_from_path(path)
+          available_environments.find { |env| path.include? env } if path.end_with?(".yml.enc")
+        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 credentials_generator
+          require "rails/generators"
+          require "rails/generators/rails/credentials/credentials_generator"
+
+          Rails::Generators::CredentialsGenerator.new
+        end
+    end
+  end
+end

data/lib/jets/commands/db/system/change/change_command.rb

@@ -0,0 +1,24 @@
+# frozen_string_literal: true
+
+module Jets
+  module Command
+    module Db
+      module System
+        class ChangeCommand < Base # :nodoc:
+          class_option :to, desc: "The database system to switch to."
+
+          def initialize(positional_args, option_args, *)
+            @argv = positional_args + option_args
+            super
+          end
+
+          def perform
+            require "rails/generators"
+            require "rails/generators/rails/db/system/change/change_generator"
+            Rails::Generators::Db::System::ChangeGenerator.start(@argv)
+          end
+        end
+      end
+    end
+  end
+end