jets 5.0.14 → 6.0.0.beta1

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

@@ -1,33 +0,0 @@
-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)
-      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]
-    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

@@ -1,19 +0,0 @@
-# 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

@@ -1,60 +0,0 @@
-# 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

@@ -1,291 +0,0 @@
-# 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

@@ -1,39 +0,0 @@
-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

@@ -1,16 +0,0 @@
-module Jets::Command
-  class StatusCommand < Base
-    include Jets::AwsServices
-
-    desc "status", "Shows the current status of the Jets app"
-    long_desc Help.text(:status)
-    def perform
-      Jets.boot
-      cfn_status = Jets::Cfn::Status.new
-      success = cfn_status.run
-      unless success
-        cfn_status.failure_message!
-      end
-    end
-  end
-end

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

@@ -1,92 +0,0 @@
-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

@@ -1,11 +0,0 @@
-# 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

data/lib/jets/commands.rb

@@ -1,17 +0,0 @@
-# frozen_string_literal: true
-
-require "jets/command"
-
-aliases = {
-  "g"  => "generate",
-  "c"  => "console",
-  "s"  => "server",
-  "db" => "dbconsole",
-  "r"  => "runner",
-  "t"  => "test"
-}
-
-command = ARGV.shift
-command = aliases[command] || command
-
-Jets::Command.invoke command, ARGV