jets 5.0.14 → 6.0.0.beta1

data/lib/jets/api/client.rb

@@ -0,0 +1,246 @@
+require "aws-sdk-core"
+require "open-uri"
+
+module Jets::Api
+  class Client
+    extend Memoist
+    include Jets::Api::Error::Handlers
+    include Jets::Util::Logging
+
+    @@max_retries = 3 # 4 attempts total
+
+    def execute_request(klass, path, data = {}, headers = {})
+      data = global_params(path).merge(data)
+      if klass == Net::HTTP::Get
+        path = path_with_query(path, data)
+        data = {}
+      end
+
+      url = url(path)
+      req = build_request(klass, url, data, headers)
+      http_resp = http_request(req)
+
+      resp = Jets::Api::Response.new(http_resp)
+      puts_debug_resp(url, resp)
+
+      if handle_as_error?(resp.http_status)
+        handle_error_response!(resp)
+      end
+
+      # Always translate Json Response to Ruby Hash
+      resp.data # JSON.parse(@http_resp.body) => Ruby hash
+    end
+
+    def build_request(klass, url, data = {}, headers = {})
+      req = klass.new(url) # url includes query string and uri.path does not, must used url
+      set_headers!(req)
+      if [Net::HTTP::Delete, Net::HTTP::Patch, Net::HTTP::Post, Net::HTTP::Put].include?(klass)
+        text = JSON.dump(data)
+        puts_debug_request(data)
+        req.body = text
+        req.content_length = text.bytesize
+        req.content_type = "application/json"
+      end
+      req
+    end
+
+    NETWORK_ERRORS = [
+      Errno::ECONNREFUSED,
+      Errno::ECONNRESET,
+      Errno::EHOSTUNREACH,
+      Errno::ETIMEDOUT,
+      Jets::Api::Error::Maintenance,
+      Jets::Api::Error::ServiceUnavailable, # mimic 503 Net::HTTPServiceUnavailable
+      Net::HTTPServiceUnavailable, # cannot rescue. Unsure why
+      Net::OpenTimeout,
+      Net::ReadTimeout,
+      OpenSSL::SSL::SSLError,
+      OpenURI::HTTPError,
+      SocketError
+    ]
+
+    def http_request(req, retries = 0)
+      resp = http.request(req) # send request. returns raw response
+      reraise_error_from_503!(req, resp)
+      resp
+    rescue *NETWORK_ERRORS => error
+      if retries < @@max_retries
+        delay = 2**retries
+        log.debug "Error: #{error.class} #{error.message} retrying after #{delay} seconds..."
+        sleep delay
+        retries += 1
+        retry
+      elsif error.is_a?(Jets::Api::Error::Maintenance)
+        # The Jets API is under maintenance
+        log.info error.message # message provides context already
+        exit 1
+      else
+        message = "Unexpected error #{error.class.name} communicating with the Jets API. "
+        message += " Request was attempted #{retries + 1} times."
+        raise Jets::Api::Error::Connection, message + "\nNetwork error: #{error.message}"
+      end
+    end
+
+    # For some reason, rescue Net::HTTPServiceUnavailable is not being caught.
+    # So mimic it.
+    # Can reproduce by using local Jets API service and not starting it up
+    def reraise_error_from_503!(req, resp)
+      return unless resp.code == "503" # Service Unavailable
+
+      if maintenance_mode?(resp.body)
+        payload = JSON.parse(resp.body)
+        raise Jets::Api::Error::Maintenance, payload["message"]
+      else
+        raise Jets::Api::Error::ServiceUnavailable, "Request #{req.path}"
+      end
+    end
+
+    def maintenance_mode?(body)
+      payload = JSON.parse(body)
+      payload["status"] == "maintenance"
+    rescue JSON::ParserError
+      false
+    end
+
+    def http
+      uri = URI(endpoint)
+      http = Net::HTTP.new(uri.host, uri.port)
+      http.open_timeout = http.read_timeout = 30
+      http.use_ssl = true if uri.scheme == "https"
+      http
+    end
+    memoize :http
+
+    def global_params(path)
+      args = ARGV.reject { |arg| arg.include?("-") }
+      params = {
+        account: Jets.aws.account,
+        command: command,
+        jets_env: Jets.env.to_s,
+        jets_extra: Jets.extra,
+        jets_go_version: ENV["JETS_GO_VERSION"],
+        jets_remote_version: ENV["JETS_REMOTE_VERSION"],
+        jets_version: Jets::VERSION,
+        region: Jets.aws.region,
+        ruby_version: RUBY_VERSION
+      }
+      if Jets::Thor::ProjectCheck.new(args).project? || command == "delete"
+        params[:project_namespace] = Jets.project.namespace
+        params[:project_name] = Jets.project.name
+      end
+
+      params.delete_if { |k, v| v.nil? }
+      params
+    end
+
+    def command
+      args = ARGV.reject { |arg| arg.include?("-") }
+      if args.first == "rollback" # IE: jets rollback 8
+        args.first
+      else
+        args.join(":")
+      end
+    end
+
+    # API does not include the /. IE: https://app.terraform.io/api/v2
+    def url(path)
+      path = "/#{path}" unless path.starts_with?("/")
+      "#{endpoint}#{path}"
+    end
+
+    def path_with_query(path, query = {})
+      return path if query.empty?
+      separator = path.include?("?") ? "&" : "?"
+      "#{path}#{separator}#{query.to_query}"
+    end
+
+    def set_headers!(req, headers = {})
+      headers.each { |k, v| req[k] = v }
+      req["Authorization"] = api_key if api_key
+      req["x-account"] = account if account
+      req["x-session"] = session if session
+      req
+    end
+
+    # 422 Unprocessable Entity: Server understands the content type of the request entity, and
+    # the syntax of the request entity is correct, but it was unable to process the contained
+    # instructions.
+    # TODO: remove? or rename to ha
+    def processable?(http_code)
+      http_code =~ /^2/ || http_code =~ /^4/
+    end
+
+    def session
+      session_path = "#{ENV["HOME"]}/.jets/session.yml"
+      if File.exist?(session_path)
+        data = YAML.load_file(session_path)
+        data["secret_token"]
+      end
+    end
+
+    def api_key
+      Jets::Api.api_key
+    end
+
+    def get(path, data = {})
+      execute_request(Net::HTTP::Get, path, data)
+    end
+
+    def post(path, data = {})
+      execute_request(Net::HTTP::Post, path, data)
+    end
+
+    def put(path, data = {})
+      execute_request(Net::HTTP::Put, path, data)
+    end
+
+    def patch(path, data = {})
+      execute_request(Net::HTTP::Patch, path, data)
+    end
+
+    def delete(path, data = {})
+      execute_request(Net::HTTP::Delete, path, data)
+    end
+
+    def account
+      sts.get_caller_identity.account
+    rescue
+      nil
+    end
+    memoize :account
+
+    def sts
+      Aws::STS::Client.new
+    end
+    memoize :sts
+
+    def endpoint
+      return ENV["JETS_API"] if ENV["JETS_API"]
+
+      major = Jets::VERSION.split(".").first.to_i
+      if major >= 6
+        "https://api.rubyonjets.com/v2"
+      else
+        "https://api.rubyonjets.com/v1"
+      end
+    end
+    memoize :endpoint
+
+    def puts_debug_resp(url, resp)
+      return unless ENV["JETS_DEBUG_API"]
+      puts "API Response for url #{url}"
+      begin
+        puts JSON.pretty_generate(resp.data)
+      rescue
+        puts "Cannot JSON pretty_generate resp #{resp.inspect}"
+        nil
+      end
+    end
+
+    def puts_debug_request(data)
+      return unless ENV["JETS_DEBUG_API"]
+      log.info "POST data:"
+      log.info JSON.pretty_generate(data)
+    end
+  end
+end

data/lib/jets/api/config.rb

@@ -0,0 +1,73 @@
+require "singleton"
+
+module Jets::Api
+  class Config
+    include Singleton
+    extend Memoist
+
+    def initialize(options = {})
+      @options = options
+      @config_path = "#{ENV["HOME"]}/.jets/config.yml"
+    end
+
+    def api_key
+      ENV["JETS_API_KEY"] || data["api_key"] || data["key"] # keep key for backwards compatibility
+    end
+
+    def api_key?
+      !!api_key
+    end
+
+    def clear_api_key
+      FileUtils.rm_f(@config_path)
+      puts "Removed #{@config_path.sub(ENV["HOME"], "~")}"
+    end
+
+    def data
+      @data ||= load
+    end
+
+    # Ensure a Hash is returned
+    def load
+      return {} unless File.exist?(@config_path)
+
+      data = YAML.load_file(@config_path)
+      if data.is_a?(Hash)
+        data
+      else
+        puts "WARN: #{@config_path} is not in the correct format. Loading an empty hash.".color(:yellow)
+        {}
+      end
+    end
+
+    def prompt
+      puts <<~EOL
+        You are about to configure your #{pretty_path(@config_path)}
+        You can get an api key from www.rubyonjets.com
+      EOL
+      print "Please provide your api key: "
+      $stdin.gets.strip
+    end
+
+    # interface method: do not remove
+    def update_api_key(api_key = nil)
+      api_key ||= prompt
+      write(
+        key: api_key,     # legacy jets 5 and below
+        api_key: api_key  # legacy jets 6 and above
+      ) # specify keys to allow
+    end
+
+    def write(values = {})
+      data = load
+      data.merge!(values.deep_stringify_keys)
+      FileUtils.mkdir_p(File.dirname(@config_path))
+      IO.write(@config_path, YAML.dump(data))
+      puts "Updated #{pretty_path(@config_path)}"
+    end
+
+    def pretty_path(path)
+      path.sub(ENV["HOME"], "~")
+    end
+  end
+end

data/lib/jets/api/error.rb

@@ -0,0 +1,70 @@
+module Jets::Api
+  class Error < StandardError
+    def initialize(message = nil, http_status: nil, http_body: nil,
+      json_body: nil, http_headers: nil, code: nil)
+      @message = message
+      @http_status = http_status
+      @http_body = http_body
+      @http_headers = http_headers || {}
+      @json_body = json_body
+      @code = code
+      @request_id = @http_headers["request-id"]
+      super(message)
+    end
+
+    module Handlers
+      def handle_as_error?(http_status)
+        http_status >= 400
+      end
+
+      def handle_error_response!(resp)
+        error = if resp.data[:error].nil?
+          general_api_error("Indeterminate error", resp.http_status)
+        elsif resp.data[:error].is_a?(String) # Internal Server Error
+          general_api_error(resp.data[:error], resp.http_status)
+        else
+          specific_api_error(resp)
+        end
+
+        raise error
+      end
+
+      def general_api_error(message, http_status)
+        Error.new(message, http_status: http_status)
+      end
+
+      def specific_api_error(resp)
+        message = resp.data[:error][:message]
+        http_status = resp.http_status
+
+        error_class = Jets::Api::Error.http_errors[http_status]
+        if error_class
+          Jets::Api::Error.const_get(error_class).new(message, http_status: http_status)
+        else
+          general_api_error(message, http_status)
+        end
+      end
+    end
+
+    cattr_reader :http_errors
+    @@http_errors = {
+      400 => "BadRequest",
+      401 => "Unauthorized",
+      403 => "Forbidden",
+      404 => "NotFound",
+      422 => "UnprocessableEntity",
+      429 => "TooManyRequests",
+      500 => "InternalServerError"
+    }
+    # Do not correspond to http status codes
+    @@other_errors = %w[
+      Connection
+      Maintenance
+      ServiceUnavailable
+    ]
+    @@error_classes = @@http_errors.values + @@other_errors
+    @@error_classes.each do |error_class|
+      Jets::Api::Error.const_set(error_class, Class.new(Error))
+    end
+  end
+end

data/lib/jets/api/ping.rb

@@ -0,0 +1,9 @@
+module Jets::Api
+  class Ping < Base
+    class << self
+      def create(params = {})
+        api.post("/pings", params)
+      end
+    end
+  end
+end

data/lib/jets/api/project.rb

@@ -0,0 +1,9 @@
+module Jets::Api
+  class Project < Base
+    class << self
+      def list(params = {})
+        api.get("/projects", params)
+      end
+    end
+  end
+end

data/lib/jets/api/release.rb

@@ -0,0 +1,17 @@
+module Jets::Api
+  class Release < Base
+    class << self
+      def list(params = {})
+        api.get("/releases", params)
+      end
+
+      def retrieve(id, params = {})
+        api.get("/releases/#{id}", params)
+      end
+
+      def create(params = {})
+        api.post("/releases", params)
+      end
+    end
+  end
+end

data/lib/jets/api/response.rb

@@ -0,0 +1,27 @@
+require "hashie"
+
+module Jets::Api
+  class Response
+    attr_reader(
+      :http_resp,
+      :http_body,
+      :http_headers,
+      :http_status,
+      :request_id
+    )
+    def initialize(http_resp)
+      @http_resp = http_resp
+      @http_body = http_resp.body
+      @http_headers = http_resp.to_hash
+      @http_status = http_resp.code.to_i
+      @request_id = http_resp["request-id"]
+    end
+
+    def data
+      data = JSON.parse(@http_resp.body, symbolize_names: true)
+      Hashie::Mash.new(data)
+    rescue JSON::ParserError
+      raise Jets::Api::Error, http_resp
+    end
+  end
+end

data/lib/jets/api/sig.rb

@@ -0,0 +1,13 @@
+module Jets::Api
+  class Sig < Base
+    class << self
+      def create(params = {})
+        api.post("/sigs", params)
+      end
+
+      def update(id, params = {})
+        api.put("sigs/#{id}", params)
+      end
+    end
+  end
+end

data/lib/jets/api/stack.rb

@@ -0,0 +1,14 @@
+module Jets::Api
+  class Stack < Base
+    class << self
+      def list(params = {})
+        api.get("/stacks", params)
+      end
+
+      def retrieve(id, params = {})
+        id = Jets.project.namespace if id == :current
+        api.get("/stacks/#{id}", params)
+      end
+    end
+  end
+end

data/lib/jets/api.rb

@@ -0,0 +1,17 @@
+module Jets
+  module Api
+    extend Memoist
+    extend self
+
+    def api
+      Jets::Api::Client.new
+    end
+    memoize :api
+
+    def api_key
+      Jets::Api::Config.instance.api_key
+    end
+  end
+end
+
+require "jets/api/error" # load all error classes

data/lib/jets/autoloaders/gem.rb

@@ -1,69 +1,58 @@
-require "zeitwerk"
-
 module Jets
   class Autoloaders
-    class GemInflector < Zeitwerk::Inflector
-      def camelize(basename, _abspath)
-        map = {
-          cli: "CLI",
-          io: "IO",
-          version: "VERSION"
-        }
-        map[basename.to_sym] || super
-      end
-    end
-
     # for jets gem itself
     class Gem
-      def autoloader
-        loader = Zeitwerk::Loader.new
-        loader.tag = "jets.gem"
-        loader.inflector = GemInflector.new
-        loader.push_dir(lib)
-        loader.do_not_eager_load(do_not_eager_load)
-        loader.ignore(ignore_paths) # loader.ignore requires full dir or path
-        # loader.log!
-        loader
-      end
+      class << self
+        extend Memoist
 
-      def lib
-        File.expand_path("#{__dir__}/../..") # jets/lib
-      end
+        def loader
+          loader = Zeitwerk::Loader.new
+          loader.tag = "jets.gem"
+          loader.inflector = Inflector.new
+          loader.push_dir(lib)
+          loader.do_not_eager_load(do_not_eager_load)
+          loader.ignore(ignore_paths) # loader.ignore requires full dir or path
+          # loader.log!
+          loader
+        end
+        memoize :loader
+
+        def setup
+          loader.setup
+        end
+
+        def lib
+          File.expand_path("#{__dir__}/../..") # jets/lib
+        end
+
+        def do_not_eager_load
+          paths = %w[]
+          paths.map { |path| "#{lib}/#{path}" } # do_not_eager_load requires full dir or path
+        end
 
-      # For jets/info.rb see Jets::Info property Middleware for why we do not eager load.
-      def do_not_eager_load
-        paths = %w[
-          jets/info.rb
-          jets/spec_helpers
-          jets/spec_helpers.rb
-          jets/commands
-          jets/commands.rb
-          jets/generators
-          jets/generators.rb
-        ]
-        paths.map { |path| "#{lib}/#{path}" } # do_not_eager_load requires full dir or path
+        def ignore_paths
+          # commands
+          paths = %w[
+            jets/cli/generate/templates
+            jets/cli/init/templates
+            jets/core_ext
+            jets/core_ext.rb
+            jets/overrides
+            jets/shim/template
+          ]
+          paths.map { |path| "#{lib}/#{path}" }
+        end
       end
 
-      def ignore_paths
-        # commands
-        paths = %w[
-          jets/application/dummy_config.rb
-          jets/application/dummy_erb_compiler.rb
-          jets/builders/rackup_wrappers
-          jets/builders/templates
-          jets/commands/templates
-          jets/controller/middleware/webpacker_setup.rb
-          jets/core_ext
-          jets/core_ext.rb
-          jets/generator
-          jets/overrides
-          jets/ruby_version_check.rb
-          jets/cli.rb
-          jets/commands.rb
-          jets/generators/jets/app/ignore
-          jets/tasks.rb
-        ]
-        paths.map { |path| "#{lib}/#{path}" }
+      class Inflector < Zeitwerk::Inflector
+        def camelize(basename, _abspath)
+          map = {
+            cli: "CLI",
+            io: "IO",
+            version: "VERSION"
+          }
+          map[basename.to_sym] || super
+        end
       end
     end
   end

data/lib/jets/autoloaders/main.rb

@@ -0,0 +1,64 @@
+module Jets
+  class Autoloaders
+    # For app code files. IE: app/events
+    class Main
+      class << self
+        extend Memoist
+        delegate :config, to: "Jets.project"
+
+        def loader
+          loader = Zeitwerk::Loader.new
+          loader.tag = "jets.main"
+          loader
+        end
+        memoize :loader
+
+        def configure(root = Jets.root)
+          all_loaders = Zeitwerk::Registry.loaders
+          already_configured_dirs = all_loaders.map(&:dirs).flatten
+
+          full_path = proc { |path| "#{root}/#{path}" }
+          autoload_paths = config.autoload_paths.map(&full_path)
+          extension_paths = config.extension_paths.map(&full_path)
+          load_paths = autoload_paths + extension_paths
+
+          load_paths.each do |path|
+            next if already_configured_dirs.include?(path)
+            next unless File.directory?(path)
+            loader.push_dir(path)
+          end
+
+          ignore_paths = config.ignore_paths.map(&full_path)
+          ignore_paths.each do |path|
+            loader.ignore(path)
+          end
+        end
+
+        # Call at end
+        def setup
+          loader.on_load do |cpath, value, abspath|
+            next unless abspath.include?("/extensions/")
+            if abspath.include?("/app")
+              Jets::Lambda::Functions.extend(value)
+            elsif abspath.include?("/shared")
+              Jets::Stack.extend(value)
+            end
+          end
+
+          loader.setup
+
+          # Eager load extensions first
+          full_path = proc { |path| "#{Jets.root}/#{path}" }
+          extension_paths = config.extension_paths.map(&full_path)
+          extension_paths.each do |path|
+            loader.eager_load_dir(path) if File.directory?(path)
+          end
+
+          # Eager load rest of jets managed code.
+          # Needed for CloudFormation templates.
+          loader.eager_load
+        end
+      end
+    end
+  end
+end