jets 3.1.0 → 5.0.0

data/lib/jets/commands/rake/rake_command.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+module Jets
+  module Command
+    class RakeCommand < Base # :nodoc:
+      extend Jets::Command::Actions
+
+      namespace "rake"
+
+      class << self
+        def printing_commands
+          formatted_rake_tasks.map(&:first)
+        end
+
+        def perform(task, args, config)
+          Jets.boot
+          require_rake
+          # Wonder if there's a better way to do this.
+          # We do not use the rask_task block to require dummy/rails
+          # because don't want Rails const to be defined for other rake tasks
+          # like jets:assets:precompile. We want the Rails const to be defined
+          # lazily at runtime only for db rake tasks.
+          require "jets/overrides/dummy/rails" if task.include?("db:")
+
+          Rake.with_application do |rake|
+            rake.init("jets", [task, *args])
+            rake.load_rakefile
+            if Jets.respond_to?(:root)
+              rake.options.suppress_backtrace_pattern = /\A(?!#{Regexp.quote(Jets.root.to_s)})/
+            end
+            rake.standard_exception_handling { rake.top_level }
+          end
+        end
+
+        private
+          def rake_tasks
+            require_rake
+
+            return @rake_tasks if defined?(@rake_tasks)
+
+            require_application!
+
+            Rake::TaskManager.record_task_metadata = true
+            Rake.application.instance_variable_set(:@name, "jets")
+            load_tasks
+            @rake_tasks = Rake.application.tasks.select(&:comment)
+          end
+
+          def formatted_rake_tasks
+            rake_tasks.map { |t| [ t.name_with_args, t.comment ] }
+          end
+
+          def require_rake
+            require "rake" # Defer booting Rake until we know it's needed.
+          end
+      end
+    end
+  end
+end

data/lib/jets/commands/releases/releases_command.rb

@@ -0,0 +1,72 @@
+module Jets::Command
+  class ReleasesCommand < Base # :nodoc:
+    desc "history", "List releases"
+    long_desc Help.text(:history)
+    paging_options(order: 'desc').call
+    def perform
+      Release.new(options.merge(paging_params)).list
+    end
+  end
+
+  class Release
+    include Jets::Command::ApiHelpers
+    def initialize(options={})
+      @options = options
+    end
+
+    def list
+      no_token_exit!
+      resp = Jets::Api::Stack.retrieve(:current)
+      if resp["error"] == "not_found"
+        puts "No release history. Stack not found: #{Jets.project_namespace}"
+        # Return early and avoid calling Jets::Api::Release.list if stack not found
+        # Note: Jets::Api::Release.list also checks for no stack found
+        return
+      end
+
+      name = "#{resp['name']} #{resp['location']}"
+      resp = Jets::Api::Release.list(@options)
+      check_for_error_message!(resp) # can also return "Stack not found #{name}" message
+      data = resp["data"]
+      if data.empty?
+        $stderr.puts "No releases found for stack: #{name}"
+      else
+        $stderr.puts "Releases for stack: #{name}"
+        show_items(data)
+      end
+    rescue Jets::Api::RequestError => e
+      puts "ERROR: Unable to list history. #{e.class}: #{e.message}"
+    end
+
+    def show_items(items)
+      presenter = CliFormat::Presenter.new
+      presenter.header = ["Version", "Status", "Released At", "Message"]
+      items.each do |item|
+        version = item["version"]
+        status = item["stack_status"]
+        released_at = item["pretty_created_at"] || item["created_at"]
+        message = item["message"] || "Deployed"
+
+        row = [version, status, format_time(released_at), message]
+        presenter.rows << row
+      end
+      presenter.show
+    end
+
+    def format_time(string)
+      if string.include?("ago") # IE: 5 minutes ago
+        string
+      else
+        time = Time.parse(string)
+        time.in_time_zone(Time.zone)
+      end
+    end
+
+    def get(version)
+      resp = Jets::Api::Release.retrieve(version)
+      check_for_error_message!(resp)
+    rescue Jets::Api::RequestError => e
+      puts "ERROR: Unable to get history. #{e.class}: #{e.message}"
+    end
+  end
+end

data/lib/jets/commands/rollback/rollback_command.rb

@@ -0,0 +1,41 @@
+require "jets/commands/releases/releases_command"
+
+module Jets::Command
+  class RollbackCommand < Base # :nodoc:
+    desc "rollback", "Rollback to a previous release"
+    long_desc Help.text(:rollback)
+    def perform(version=nil)
+      Rollback.new(options.merge(version: version)).run
+    end
+  end
+
+  class Rollback
+    include Jets::Command::ApiHelpers
+    attr_reader :version
+    def initialize(options={})
+      @options = options
+      @version = options[:version]
+      # Handle more gracefully than the way Jets does it currently
+      if @version.nil?
+        puts <<~EOL
+          ERROR: version required
+          Usage: jets rollback VERSION
+        EOL
+        exit 1
+      end
+    end
+
+    def run
+      no_token_exit!
+      Jets.boot
+      payload = Release.new(@options).get(version)
+      check_for_error_message!(payload)
+
+      puts "Rolling back to version #{version}"
+      # Download previous cfn templates
+      Jets::Cfn::Download.new.download_templates(version)
+      # Run cloudformation update
+      Jets::Cfn::Ship.new(@options.merge(rollback_version: version)).run # also creates the Jets Api deployment record
+    end
+  end
+end

data/lib/jets/commands/routes/routes_command.rb

@@ -0,0 +1,19 @@
+# frozen_string_literal: true
+
+require "cli-format"
+
+module Jets::Command
+  class RoutesCommand < Base # :nodoc:
+    option :controller, aliases: :c, desc: "Filter by a specific controller, e.g. PostsController or Admin::PostsController"
+    option :format, default: "table", desc: "Output formats: #{CliFormat.formats.join(', ')}" # csv, equal, json, space, table, tab
+    option :grep, aliases: :g, desc: "Grep routes by a specific pattern"
+    option :reject, aliases: :r, desc: "Reject filter routes by a specific pattern"
+
+    desc "routes", "Print out your application routes"
+    long_desc Help.text(:routes)
+    def perform(*)
+      require_application_and_environment!
+      Jets::Router::Help.new(options).print
+    end
+  end
+end

data/lib/jets/commands/runner/runner_command.rb

@@ -0,0 +1,60 @@
+# frozen_string_literal: true
+
+module Jets
+  module Command
+    class RunnerCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      self.environment_desc = "The environment for the runner to operate under (test/development/production)"
+
+      no_commands do
+        def help
+          super
+          say self.class.desc
+        end
+      end
+
+      def self.banner(*)
+        "#{super} [<'Some.ruby(code)'> | <filename.rb> | -]"
+      end
+
+      desc "runner", "Run Ruby code in the context of Jets app non-interactively"
+      long_desc Help.text(:runner)
+      def perform(code_or_file = nil, *command_argv)
+        extract_environment_option_from_argument
+
+        unless code_or_file
+          help
+          exit 1
+        end
+
+        require_application_and_environment!
+        Jets.application.load_runner
+
+        args = command_argv
+
+        ARGV.replace(command_argv)
+
+        if code_or_file == "-"
+          eval($stdin.read, TOPLEVEL_BINDING, "stdin")
+        elsif File.exist?(code_or_file)
+          expanded_file_path = File.expand_path code_or_file
+          $0 = expanded_file_path
+          Kernel.load expanded_file_path
+        else
+          begin
+            # Jets changed TOPLEVEL_BINDING to binding to have access to args
+            # To keep args working https://github.com/boltops-tools/jets/pull/669
+            eval(code_or_file, binding, __FILE__, __LINE__)
+          rescue SyntaxError, NameError => e
+            error "Please specify a valid ruby command or the path of a script to run."
+            error "Run '#{self.class.executable} -h' for help."
+            error ""
+            error e
+            exit 1
+          end
+        end
+      end
+    end
+  end
+end

data/lib/jets/commands/server/server_command.rb

@@ -0,0 +1,291 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "action_dispatch"
+require "jets"
+require "active_support/core_ext/string/filters"
+
+module Jets
+  class Server < ::Rack::Server
+    class Options
+      def parse!(args)
+        Jets::Command::ServerCommand.new([], args).server_options
+      end
+    end
+
+    def initialize(options = nil)
+      @default_options = options || {}
+      super(@default_options)
+      set_environment
+    end
+
+    def opt_parser
+      Options.new
+    end
+
+    def set_environment
+      ENV["JETS_ENV"] ||= options[:environment]
+    end
+
+    def start(after_stop_callback = nil)
+      trap(:INT) { exit }
+      create_tmp_directories
+      setup_dev_caching
+      # TODO: should this be commented out? Think it needs to be because Lambda will
+      # not run through the server...
+      # However, need to test puma and see if this will surface errors when there's an app error.
+      # log_to_stdout if options[:log_stdout]
+
+      super()
+    ensure
+      after_stop_callback.call if after_stop_callback
+    end
+
+    def serveable? # :nodoc:
+      server
+      true
+    rescue LoadError, NameError
+      false
+    end
+
+    def middleware
+      Hash.new([])
+    end
+
+    def default_options
+      super.merge(@default_options)
+    end
+
+    def served_url
+      "#{options[:SSLEnable] ? 'https' : 'http'}://#{options[:Host]}:#{options[:Port]}" unless use_puma?
+    end
+
+    private
+      def setup_dev_caching
+        if options[:environment] == "development"
+          Jets::DevCaching.enable_by_argument(options[:caching])
+        end
+      end
+
+      def create_tmp_directories
+        %w(cache pids sockets).each do |dir_to_make|
+          FileUtils.mkdir_p(File.join(Jets.root, "tmp", dir_to_make))
+        end
+      end
+
+      def log_to_stdout
+        wrapped_app # touch the app so the logger is set up
+
+        console = ActiveSupport::Logger.new(STDOUT)
+        console.formatter = Jets.logger.formatter
+        console.level = Jets.logger.level
+
+        unless ActiveSupport::Logger.logger_outputs_to?(Jets.logger, STDOUT)
+          Jets.logger.extend(ActiveSupport::Logger.broadcast(console))
+        end
+      end
+
+      def use_puma?
+        server.to_s == "Rack::Handler::Puma"
+      end
+  end
+
+  module Command
+    class ServerCommand < Base # :nodoc:
+      include EnvironmentArgument
+
+      # Hard-coding a bunch of handlers here as we don't have a public way of
+      # querying them from the Rack::Handler registry.
+      RACK_SERVERS = %w(cgi fastcgi webrick lsws scgi thin puma unicorn falcon)
+
+      DEFAULT_PORT = 8888
+      DEFAULT_PIDFILE = "tmp/pids/server.pid"
+
+      class_option :port, aliases: "-p", type: :numeric,
+        desc: "Runs Jets on the specified port - defaults to 8888.", banner: :port
+      class_option :binding, aliases: "-b", type: :string,
+        desc: "Binds Jets to the specified IP - defaults to 'localhost' in development and '0.0.0.0' in other environments'.",
+        banner: :IP
+      class_option :config, aliases: "-c", type: :string, default: "config.ru",
+        desc: "Uses a custom rackup configuration.", banner: :file
+      class_option :daemon, aliases: "-d", type: :boolean, default: false,
+        desc: "Runs server as a Daemon."
+      class_option :using, aliases: "-u", type: :string,
+        desc: "Specifies the Rack server used to run the application (thin/puma/webrick).", banner: :name
+      class_option :pid, aliases: "-P", type: :string,
+        desc: "Specifies the PID file - defaults to #{DEFAULT_PIDFILE}."
+      class_option :dev_caching, aliases: "-C", type: :boolean, default: nil,
+        desc: "Specifies whether to perform caching in development."
+      class_option :restart, type: :boolean, default: nil, hide: true
+      class_option :early_hints, type: :boolean, default: nil, desc: "Enables HTTP/2 early hints."
+      class_option :log_to_stdout, type: :boolean, default: nil, optional: true,
+        desc: "Whether to log to stdout. Enabled by default in development when not daemonized."
+
+      def initialize(args, local_options, *)
+        super
+
+        @original_options = local_options - %w( --restart )
+      end
+
+      desc "server", "Runs a local server that mimics API Gateway for development"
+      long_desc Help.text(:server)
+      def perform
+        extract_environment_option_from_argument
+        set_application_directory!
+        prepare_restart
+
+        Jets::Server.new(server_options).tap do |server|
+          # Require application after server sets environment to propagate
+          # the --environment option.
+          # require APP_PATH
+          Jets.boot
+          Dir.chdir(Jets.application.root)
+
+          if server.serveable?
+            print_boot_information(server.server, server.served_url)
+            after_stop_callback = -> { say "Exiting" unless options[:daemon] }
+            server.start(after_stop_callback)
+          else
+            say rack_server_suggestion(options[:using])
+          end
+        end
+      end
+
+      no_commands do
+        def server_options
+          {
+            user_supplied_options: user_supplied_options,
+            server:                options[:using],
+            log_stdout:            log_to_stdout?,
+            Port:                  port,
+            Host:                  host,
+            DoNotReverseLookup:    true,
+            config:                options[:config],
+            environment:           environment,
+            daemonize:             options[:daemon],
+            pid:                   pid,
+            caching:               options[:dev_caching],
+            restart_cmd:           restart_command,
+            early_hints:           early_hints
+          }
+        end
+      end
+
+      private
+        def user_supplied_options
+          @user_supplied_options ||= begin
+            # Convert incoming options array to a hash of flags
+            #   ["-p3001", "-C", "--binding", "127.0.0.1"] # => {"-p"=>true, "-C"=>true, "--binding"=>true}
+            user_flag = {}
+            @original_options.each do |command|
+              if command.start_with?("--")
+                option = command.split("=")[0]
+                user_flag[option] = true
+              elsif command =~ /\A(-.)/
+                user_flag[Regexp.last_match[0]] = true
+              end
+            end
+
+            # Collect all options that the user has explicitly defined so we can
+            # differentiate them from defaults
+            user_supplied_options = []
+            self.class.class_options.select do |key, option|
+              if option.aliases.any? { |name| user_flag[name] } || user_flag["--#{option.name}"]
+                name = option.name.to_sym
+                case name
+                when :port
+                  name = :Port
+                when :binding
+                  name = :Host
+                when :dev_caching
+                  name = :caching
+                when :daemonize
+                  name = :daemon
+                end
+                user_supplied_options << name
+              end
+            end
+            user_supplied_options << :Host if ENV["HOST"] || ENV["BINDING"]
+            user_supplied_options << :Port if ENV["PORT"]
+            user_supplied_options << :pid if ENV["PIDFILE"]
+            user_supplied_options.uniq
+          end
+        end
+
+        def port
+          options[:port] || ENV.fetch("PORT", DEFAULT_PORT).to_i
+        end
+
+        def host
+          if options[:binding]
+            options[:binding]
+          else
+            default_host = environment == "development" ? "localhost" : "0.0.0.0"
+
+            ENV.fetch("BINDING", default_host)
+          end
+        end
+
+        def environment
+          options[:environment] || Jets::Command.environment
+        end
+
+        def restart_command
+          "jets server #{@original_options.join(" ")} --restart"
+        end
+
+        def early_hints
+          options[:early_hints]
+        end
+
+        def log_to_stdout?
+          options.fetch(:log_to_stdout) do
+            options[:daemon].blank? && environment == "development"
+          end
+        end
+
+        def pid
+          File.expand_path(options[:pid] || ENV.fetch("PIDFILE", DEFAULT_PIDFILE))
+        end
+
+        def self.banner(*)
+          "jets server -u [thin/puma/webrick] [options]"
+        end
+
+        def prepare_restart
+          FileUtils.rm_f(pid) if options[:restart]
+        end
+
+        def rack_server_suggestion(server)
+          if server.in?(RACK_SERVERS)
+            <<~MSG
+              Could not load server "#{server}". Maybe you need to the add it to the Gemfile?
+
+                gem "#{server}"
+
+              Run `jets server --help` for more options.
+            MSG
+          else
+            error = CorrectableError.new("Could not find server '#{server}'.", server, RACK_SERVERS)
+            if error.respond_to?(:detailed_message)
+              formatted_message = error.detailed_message
+            else
+              formatted_message = error.message
+            end
+            <<~MSG
+              #{formatted_message}
+              Run `jets server --help` for more options.
+            MSG
+          end
+        end
+
+        def print_boot_information(server, url)
+          say <<~MSG
+            => Booting #{ActiveSupport::Inflector.demodulize(server)}
+            => Jets #{Jets.version} application starting in #{Jets.env} #{url}
+            => Run `jets server --help` for more startup options
+          MSG
+        end
+    end
+  end
+end

data/lib/jets/commands/stacks/stacks_command.rb

@@ -0,0 +1,39 @@
+module Jets::Command
+  class StacksCommand < Base # :nodoc:
+    desc "stacks", "List deployed stacks"
+    long_desc Help.text(:stacks)
+    paging_options.call
+    option :all_projects, desc: "Show all stacks across all projects", type: :boolean, default: false
+    def perform
+      name = Jets.project_name
+      no_token_exit!
+      params = paging_params.merge(options)
+      resp = Jets::Api::Stack.list(params)
+      check_for_error_message!(resp)
+
+      data = resp["data"]
+      if data.empty?
+        $stderr.puts "No stacks deployed yet: #{name}"
+      else
+        message = if options[:all_projects]
+                    "Stacks for all projects:"
+                  else
+                    "Stacks for project: #{name}"
+                  end
+        $stderr.puts message
+        show_items(data)
+      end
+    rescue Jets::Api::RequestError => e
+      puts "WARNING: Unable to list stacks. #{e.class}: #{e.message}"
+    end
+
+  private
+    def show_items(items)
+      presenter = CliFormat::Presenter.new
+      presenter.header = ["Name"]
+      items.each do |item|
+        puts "#{item['name']} #{item['location']}"
+      end
+    end
+  end
+end

data/lib/jets/commands/status/status_command.rb

@@ -0,0 +1,9 @@
+module Jets::Command
+  class StatusCommand < Base
+    desc "status", "Shows the current status of the Jets app"
+    long_desc Help.text(:status)
+    def perform
+      Jets::Cfn::Status.new(options).run
+    end
+  end
+end

data/lib/jets/commands/url/url_command.rb

@@ -0,0 +1,92 @@
+module Jets::Command
+  class UrlCommand < Base # :nodoc:
+    option :format, aliases: :f, desc: "Output format: json or text", default: "text"
+
+    desc "url", "App url if routes are defined"
+    long_desc Help.text(:url)
+    def url(*)
+      Url.new(options).display
+    end
+  end
+
+  class Url
+    include Jets::AwsServices
+
+    def initialize(options)
+      @options = options
+    end
+
+    def display
+      Jets.boot
+      stack_name = Jets::Names.parent_stack_name
+      unless stack_exists?(stack_name)
+        $stderr.puts "Stack for #{Jets.project_name.color(:green)} project for environment #{Jets.env.color(:green)}.  Couldn't find #{stack_name.color(:green)} stack."
+        exit 1
+      end
+
+      stack = cfn.describe_stacks(stack_name: stack_name).stacks.first
+
+      data = {}
+
+      api_gateway_stack_arn = lookup(stack[:outputs], "ApiGateway")
+      if api_gateway_stack_arn && endpoint_available?
+        data[:api_gateway_endpoint] = get_gateway_endpoint(api_gateway_stack_arn)
+        get_custom_domain!(data)
+      end
+
+      if data.empty?
+        $stderr.puts "API Gateway not found. This jets app does have an API Gateway associated with it.  Please double check your config/routes.rb if you were expecting to see a url for the app. Also check that #{stack_name.color(:green)} is a jets app."
+        exit 1
+      end
+
+      if @options[:format] == "json"
+        puts data.to_json
+      else
+        puts "API Gateway Endpoint: #{data[:api_gateway_endpoint]}"
+        puts "Custom Domain: #{data[:custom_domain]}" if data[:custom_domain]
+        puts "App Domain: #{data[:app_domain]}" if data[:app_domain]
+      end
+    end
+
+    def get_gateway_endpoint(api_gateway_stack_arn)
+      stack = cfn.describe_stacks(stack_name: api_gateway_stack_arn).stacks.first
+      rest_api = lookup(stack[:outputs], "RestApi")
+      region_id = lookup(stack[:outputs], "Region")
+      stage_name = Jets::Cfn::Resource::ApiGateway::Deployment.stage_name
+
+      # https://docs.aws.amazon.com/apigateway/latest/developerguide/how-to-call-api.html
+      # https://my-api-id.execute-api.region-id.amazonaws.com/stage-name/{resourcePath}
+      "https://#{rest_api}.execute-api.#{region_id}.amazonaws.com/#{stage_name}"
+    end
+
+    def get_custom_domain!(data)
+      return unless endpoint_available? && Jets.custom_domain? && Jets.config.domain.route53
+
+      domain_name = Jets::Cfn::Resource::ApiGateway::DomainName.new
+      # Looks funny but its right.
+      # domain_name is a method on the Jets::Cfn::Resource::ApiGateway::Domain instance
+      url = "https://#{domain_name.domain_name}"
+      data[:custom_domain] = url
+      data[:app_domain] = "https://#{Jets.config.app.domain}" if Jets.config.app.domain
+    end
+
+    def endpoint_unavailable?
+      return false if Jets::Router.no_routes?
+      resp, status = stack_status
+      return false if status.include?("ROLLBACK")
+    end
+
+    def endpoint_available?
+      !endpoint_unavailable?
+    end
+
+    # All CloudFormation states listed here:
+    # http://docs.aws.amazon.com/AWSCloudFormation/latest/UserGuide/using-cfn-describing-stacks.html
+    def stack_status
+      resp = cfn.describe_stacks(stack_name: @parent_stack_name)
+      status = resp.stacks[0].stack_status
+      [resp, status]
+    end
+
+  end
+end

data/lib/jets/commands/version/version_command.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+module Jets::Command
+  class VersionCommand < Base # :nodoc:
+    desc "version", "Prints Jets version"
+    long_desc Help.text(:version)
+    def perform
+      puts Jets.version
+    end
+  end
+end