k8y 0.1.0 → 0.2.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 4af0d1dcdd836cab3430faa1d86ebad78e6aa9ed4d935a86a11ba0f4cc11f245
-  data.tar.gz: f79b384ede82574419718223ab399ca2b4b1ee778d001433a4c0e721529cac69
+  metadata.gz: 967e0fcf49dc5ff373df45925be7c14ee0d8da75d12f348373cc70c72621ff23
+  data.tar.gz: e02d82838c724f96557d3769421a2ba40557dba6501f012433b1be64ef4204f9
 SHA512:
-  metadata.gz: 3048c108fb78383700dbfbb3527645cde925ad2cd56dbe01f36d2728642240e9ce93ad6555150a519f16605f1c6d5337019e7dff6548fc416ec887bdf58f3390
-  data.tar.gz: 0af26a9f575cbbe9b785c6ecb761df8d1cd97f731905b33f98a5d462562a0d2117f69fbe235c4dae311d05d3b281854c3121480bae3ffe3d9164c6419c2fc16a
+  metadata.gz: 5937b19b84140f2a81c0935bce8892c92ae709eb8382ce658297911f65790b311e847c92ae71887d33a6920beca1f8f69d535ab32ce125d6f697cbad0dd99c51
+  data.tar.gz: c4635b0a99227890b7ef4dc7c88ab285771d83ea5926a53b599e90f6e5ff20965c5b51b72ad062f513716b598322422eea53825d908094c9441ae32eac54cc59

data/CHANGELOG.md

@@ -1 +1,17 @@
 ## next
+
+## 0.2.0
+
+**Enhancements**
+
+- K8y::Client::from_in_cluster for easily building in-cluster clients [#23](https://github.com/tsontario/k8y/pull/23)
+
+**Testing**
+
+- Integration test suite to run against (KinD) cluster [#11](https://github.com/tsontario/k8y/pull/11)
+- Run integration tests in parallel [#22](https://github.com/tsontario/k8y/pull/22)
+
+**Design**
+
+- Move generated API methods (get_pods, delete_service, etc.) into separate API class, out of top-level K8y::Client::Client [#17](https://github.com/tsontario/k8y/pull/17)
+

data/k8y.gemspec

@@ -13,8 +13,6 @@ Gem::Specification.new do |spec|
   spec.homepage      = "https://github.com/tsontario/k8y"
   spec.required_ruby_version = Gem::Requirement.new(">= 2.7.0")
 
-  # spec.metadata["allowed_push_host"] = "TODO: Set to 'http://mygemserver.com'"
-
   spec.metadata["homepage_uri"] = spec.homepage
   spec.metadata["source_code_uri"] = spec.homepage
   spec.metadata["changelog_uri"] = spec.homepage
@@ -28,10 +26,10 @@ Gem::Specification.new do |spec|
   spec.executables   = spec.files.grep(%r{\Aexe/}) { |f| File.basename(f) }
   spec.require_paths = ["lib"]
 
+  spec.add_dependency("activesupport", "~> 6.0")
   spec.add_dependency("faraday", "~> 1.6")
-  spec.add_dependency("recursive-open-struct", "~>1.1")
   spec.add_dependency("railties", "~> 6.0")
-  spec.add_dependency("activesupport", "~> 6.0")
+  spec.add_dependency("recursive-open-struct", "~>1.1")
 
   spec.add_development_dependency("byebug", "~> 11")
   spec.add_development_dependency("minitest", "~> 5")

data/lib/k8y/client/api_builder.rb

@@ -27,12 +27,13 @@ module K8y
       end
 
       def build!
-        rest_client = RESTClient.new(config: config, context: context, path: api.path)
+        rest_config = REST::Config.from_kubeconfig(config, path: api.path)
+        rest_client = REST::Client.new(connection: REST::Connection.from_config(rest_config))
+
         response = rest_client.get(as: :raw)
         resource_descriptions = JSON.parse(response.body)["resources"].map do |resource_description|
           ResourceDescription.from_hash(resource_description)
         end
-
         resource_descriptions.each do |resource_description|
           next if resource_description.subresource?
 

data/lib/k8y/client/client.rb

@@ -1,6 +1,5 @@
 # frozen_string_literal: true
 
-require_relative "rest_client"
 require_relative "api_builder"
 require_relative "apis"
 
@@ -22,10 +21,6 @@ module K8y
         apis.each { |api| APIBuilder.new(api: api, config: config, context: context.name).build! }
       end
 
-      def set_context(context_name)
-        @context = config.context(context_name)
-      end
-
       def method_missing(method_name, *args, &block)
         candidate_apis = apis.apis_for_method(method_name)
         case candidate_apis.length

data/lib/k8y/client.rb

@@ -13,5 +13,10 @@ module K8y
     def self.from_config(config, context: nil, group_versions: DEFAULT_GROUP_VERSIONS)
       Client.new(config: config, context: context || config.current_context, group_versions: group_versions)
     end
+
+    def self.from_in_cluster(group_versions: DEFAULT_GROUP_VERSIONS)
+      config = Kubeconfig.in_cluster_config
+      Client.new(config: config, context: Kubeconfig::IN_CLUSTER_NAME, group_versions: group_versions)
+    end
   end
 end

data/lib/k8y/kubeconfig/auth_info.rb

@@ -18,9 +18,7 @@ module K8y
             as_user_extra: hash.fetch("as-user-extra", nil),
             username: hash.fetch("username", nil),
             password: hash.fetch("password", nil),
-            # TODO: this needs something like polymorphic classes, not just raw hash, eventually
             auth_provider: hash.fetch("auth-provider", nil),
-            # TODO: This will likely benefit from actual domain models eventually, as well.
             exec_options: hash.fetch("exec", nil),
             extensions: hash.fetch("extensions", nil)
           )

data/lib/k8y/kubeconfig/cluster.rb

@@ -23,7 +23,7 @@ module K8y
         @insecure_skip_tls_verify = insecure_skip_tls_verify
         @certificate_authority = certificate_authority
         @certificate_authority_data = certificate_authority_data
-        @server = URI.parse(server)
+        @server = server
       end
     end
   end

data/lib/k8y/kubeconfig/config.rb

@@ -28,7 +28,7 @@ module K8y
         raise Error, e
       end
 
-      def initialize(api_version:, kind:, preferences:, clusters:, contexts:, users:, current_context:)
+      def initialize(api_version: "v1", kind: "Config", preferences: {}, clusters:, contexts:, users:, current_context:)
         @api_version = api_version
         @kind = kind
         @preferences = preferences
@@ -38,9 +38,11 @@ module K8y
         @current_context = current_context
       end
 
-      def context(name)
-        context = contexts.find { |c| c.name == name }
-        raise ContextNotFoundError, "Could not find context #{name} in config" unless context
+      def context(context)
+        return context if context.is_a?(Context)
+
+        context = contexts.find { |c| c.name == context }
+        raise ContextNotFoundError, "Could not find context #{context} in config" unless context
         context
       end
 
@@ -56,13 +58,13 @@ module K8y
         user
       end
 
-      def cluster_for_context(context_name)
-        cluster_name = context(context_name).cluster
+      def cluster_for_context(context)
+        cluster_name = context(context).cluster
         cluster(cluster_name)
       end
 
-      def user_for_context(context_name)
-        user(context(context_name).user)
+      def user_for_context(context)
+        user(context(context).user)
       end
     end
   end

data/lib/k8y/kubeconfig.rb

@@ -5,12 +5,51 @@ require_relative "kubeconfig/config"
 module K8y
   module Kubeconfig
     Error = Class.new(Error)
+    NotInClusterError = Class.new(Error)
 
-    KUBECONFIG = ENV["KUBECONFIG"]
+    IN_CLUSTER_NAME = "in-cluster"
 
-    def self.from_file(file = File.open(KUBECONFIG))
+    TOKEN_FILE = "/var/run/secrets/kubernetes.io/serviceaccount/token"
+    ROOT_CA_FILE = "/var/run/secrets/kubernetes.io/serviceaccount/ca.crt"
+
+    def self.from_file(file = File.open(ENV["KUBECONFIG"]))
       hash = YAML.safe_load(file.read, permitted_classes: [Date, Time])
       Config.from_hash(hash)
     end
+
+    def self.in_cluster_config
+      host = ENV.fetch("KUBERNETES_SERVICE_HOST", nil)
+      port = ENV.fetch("KUBERNETES_SERVICE_PORT", nil)
+      raise NotInClusterError unless host && port
+
+      token_data = File.read(TOKEN_FILE)
+      auth_info = AuthInfo.new(token: token_data, token_file: TOKEN_FILE)
+      user = User.new(
+        name: IN_CLUSTER_NAME,
+        auth_info: auth_info
+      )
+
+      ca_data = Base64.encode64(File.read(ROOT_CA_FILE))
+      cluster = Cluster.new(
+        name: IN_CLUSTER_NAME,
+        insecure_skip_tls_verify: false,
+        certificate_authority: nil,
+        certificate_authority_data: ca_data,
+        server: "https://#{host}:#{port}",
+      )
+      context = Context.new(
+        name: IN_CLUSTER_NAME,
+        cluster: IN_CLUSTER_NAME,
+        namespace: nil,
+        user: IN_CLUSTER_NAME
+      )
+
+      Config.new(
+        clusters: [cluster],
+        contexts: [context],
+        current_context: context,
+        users: [user]
+      )
+    end
   end
 end

data/lib/k8y/rest/auth.rb

@@ -0,0 +1,77 @@
+# frozen_string_literal: true
+module K8y
+  module REST
+    class Auth
+      InvalidAuthTypeError = Class.new(Error)
+
+      class << self
+        def from_kubeconfig(kubeconfig, context: nil)
+          context = context ? context : kubeconfig.current_context
+          auth_info = kubeconfig.user_for_context(context).auth_info
+
+          new(token: token(auth_info), username: auth_info.username, password: auth_info.password,
+            auth_provider: auth_provider(auth_info), exec_provider: exec_provider(auth_info))
+        end
+
+        private
+
+        def token(auth_info)
+          return auth_info.token if auth_info.token
+          File.read(auth_info.token_file) if auth_info.token_file
+        end
+
+        def auth_provider(auth_info)
+          # TODO
+        end
+
+        def exec_provider(auth_info)
+          # TODO
+        end
+      end
+
+      def initialize(token: nil, username: nil, password: nil, auth_provider: nil, exec_provider: nil)
+        @token = token
+        @username = username
+        @password = password
+        @auth_provider = auth_provider
+        @exec_provider = exec_provider
+      end
+
+      def configure_connection(connection)
+        case auth_type
+        when :basic
+          connection.basic_auth(username, password)
+        when :token
+          connection.headers[:Authorization] = "Bearer #{token}"
+          # TODO...
+        end
+      end
+
+      private
+
+      attr_reader :token, :username, :password, :auth_provider, :exec_provider
+
+      def auth_type
+        if username && password
+          :basic
+        elsif token
+          :token
+        elsif auth_provider
+          :auth_provider
+        elsif exec_provider
+          :exec_provider
+        else
+          :none
+        end
+      end
+
+      def basic?
+        auth_type == :basic
+      end
+
+      def token?
+        auth_type == :token
+      end
+    end
+  end
+end

data/lib/k8y/rest/client.rb

@@ -0,0 +1,72 @@
+# frozen_string_literal: true
+
+require "faraday"
+require "base64"
+require "recursive_open_struct"
+
+require_relative "config"
+require_relative "connection"
+require_relative "response_formatter"
+
+module K8y
+  module REST
+    class Client
+      attr_reader :connection
+
+      class << self
+        def from_config(config)
+          new(
+            connection: Connection.new(
+              host: config.host,
+              ssl: config.transport.to_faraday_options,
+              auth: config.auth
+            )
+          )
+        end
+      end
+
+      def host
+        connection.host
+      end
+
+      def initialize(connection:)
+        @connection = connection
+      end
+
+      def get(path = "", headers: {}, as: :ros)
+        response = connection.get(formatted_uri(path))
+        format_response(response, as: as)
+      end
+
+      def post(path = "", data:, headers: {}, as: :ros)
+        response = connection.post(formatted_uri(path), data, headers)
+        format_response(response, as: as)
+      end
+
+      def put(path = "", data:, headers: {}, as: :ros)
+        response = connection.put(formatted_uri(path), data, headers)
+        format_response(response, as: as)
+      end
+
+      def patch(path = "", strategy:, data:, headers: {}, as: :ros)
+        response = connection.patch(formatted_uri(path), data, headers)
+        format_response(response, as: as)
+      end
+
+      def delete(path = "", headers: {}, as: :ros)
+        response = connection.delete(formatted_uri(path))
+        format_response(response, as: as)
+      end
+
+      private
+
+      def formatted_uri(path = "")
+        File.join(connection.host, path)
+      end
+
+      def format_response(response, as: :ros)
+        ResponseFormatter.new(response).format(as: as)
+      end
+    end
+  end
+end

data/lib/k8y/rest/config.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+require_relative "config_validator"
+require_relative "transport"
+require_relative "auth"
+
+module K8y
+  module REST
+    class Config
+      attr_reader :host, :transport, :auth
+
+      class << self
+        def from_kubeconfig(kubeconfig, path:)
+          context = context ? context : kubeconfig.current_context
+          ConfigValidator.new(kubeconfig, context: context).validate!
+
+          cluster = kubeconfig.cluster_for_context(context)
+          host = File.join(cluster.server, path)
+          transport = if URI(host).scheme == "https"
+            Transport.from_kubeconfig(kubeconfig, context: context)
+          end
+          auth = Auth.from_kubeconfig(kubeconfig, context: context)
+          new(
+            host: host,
+            transport: transport,
+            auth: auth
+          )
+        end
+      end
+
+      def initialize(host:, transport:, auth:)
+        @host = host
+        @transport = transport
+        @auth = auth
+      end
+    end
+  end
+end

data/lib/k8y/rest/config_validator.rb

@@ -0,0 +1,48 @@
+# frozen_string_literal: true
+module K8y
+  module REST
+    class ConfigValidator
+      class ValidationError < Error
+        def initialize(validation_errors)
+          super
+          @message = "Kubeconfig validation failed with the following errors: " + validation_errors.join(",")
+        end
+      end
+
+      VALIDATIONS = [
+        :validate_auth_info,
+        :validate_context,
+        :validate_cluster,
+        :validate_usable,
+      ].freeze
+
+      def initialize(kubeconfig, context:)
+        @kubeconfig = kubeconfig
+        @context = context
+      end
+
+      def validate!
+        errors = VALIDATIONS.map { |validation| send(validation) }.compact
+        raise ValidationError, errors if errors.present?
+      end
+
+      private
+
+      def validate_auth_info
+        # TODO
+      end
+
+      def validate_context
+        # TODO
+      end
+
+      def validate_cluster
+        # TODO
+      end
+
+      def validate_usable
+        # TODO
+      end
+    end
+  end
+end

data/lib/k8y/rest/connection.rb

@@ -0,0 +1,31 @@
+# frozen_string_literal: true
+
+require "forwardable"
+
+module K8y
+  module REST
+    class Connection
+      extend Forwardable
+
+      attr_reader :host, :connection
+
+      VERBS = [:get, :post, :put, :patch, :delete]
+      def_delegators(:connection, *VERBS)
+
+      class << self
+        # Initialize a Connection object using a provided REST::Config instance
+        def from_config(config)
+          new(host: config.host, ssl: config.transport.to_faraday_options, auth: config.auth)
+        end
+      end
+
+      def initialize(host:, ssl:, auth:, &conn_options)
+        @host = host
+        @connection = Faraday.new(host, ssl: ssl) do |connection|
+          auth.configure_connection(connection)
+          yield connection if block_given?
+        end
+      end
+    end
+  end
+end

data/lib/k8y/rest/error.rb

@@ -0,0 +1,6 @@
+# frozen_string_literal: true
+module K8y
+  module REST
+    Error = Class.new(Error)
+  end
+end

data/lib/k8y/{client → rest}/response_formatter.rb

@@ -1,6 +1,6 @@
 # frozen_string_literal: true
 module K8y
-  module Client
+  module REST
     class ResponseFormatter
       UnsupportedResponseTypeError = Class.new(Error)
 

data/lib/k8y/rest/transport.rb

@@ -0,0 +1,88 @@
+# frozen_string_literal: true
+module K8y
+  module REST
+    class Transport
+      attr_reader :cert_file, :key_file, :ca_file, :cert_data, :key_data, :ca_data
+
+      class << self
+        def from_kubeconfig(kubeconfig, context: nil)
+          context = context ? context : kubeconfig.current_context
+          cluster = kubeconfig.cluster_for_context(context)
+          auth_info = kubeconfig.user_for_context(context).auth_info
+
+          transport = new(cert_file: auth_info.client_certificate, key_file: auth_info.client_key,
+            ca_file: cluster.certificate_authority, cert_data: auth_info.client_certificate_data,
+            key_data: auth_info.client_key_data, ca_data: cluster.certificate_authority_data)
+          transport.reconcile!
+          transport
+        end
+      end
+
+      def initialize(cert_file: nil, key_file: nil, ca_file: nil, cert_data: nil, key_data: nil, ca_data: nil)
+        @cert_file = cert_file
+        @key_file = key_file
+        @ca_file = ca_file
+
+        @cert_data = cert_data
+        @key_data = key_data
+        @ca_data = ca_data
+      end
+
+      def reconcile!
+        return if reconciled?
+        reconcile_cert_data!
+        reconcile_key_data!
+        reconcile_ca_data!
+
+        @reconciled = true
+      end
+
+      def to_faraday_options
+        if ca_data
+          cert_store = OpenSSL::X509::Store.new
+          cert_store.add_cert(OpenSSL::X509::Certificate.new(ca_data))
+        end
+
+        {
+          client_cert: (OpenSSL::X509::Certificate.new(cert_data) if cert_data),
+          client_key: (OpenSSL::PKey::RSA.new(key_data) if key_data),
+          cert_store: cert_store,
+          verify: OpenSSL::SSL::VERIFY_PEER,
+        }
+      end
+
+      private
+
+      attr_reader :reconciled
+      attr_writer :cert_data, :key_data, :ca_data
+
+      def reconcile_cert_data!
+        @cert_data = if cert_data
+          Base64.decode64(cert_data)
+        elsif cert_file
+          File.read(cert_file)
+        end
+      end
+
+      def reconcile_key_data!
+        @key_data = if key_data
+          Base64.decode64(key_data)
+        elsif key_file
+          File.read(key_file)
+        end
+      end
+
+      def reconcile_ca_data!
+        @ca_data = if ca_data
+          Base64.decode64(ca_data)
+        elsif ca_file
+          File.read(ca_file)
+        end
+      end
+
+      def reconciled?
+        reconciled
+      end
+    end
+  end
+end

data/lib/k8y/rest.rb

@@ -0,0 +1,8 @@
+# frozen_string_literal: true
+require_relative "rest/error"
+require_relative "rest/client"
+
+module K8y
+  module REST
+  end
+end

data/lib/k8y/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module K8y
-  VERSION = "0.1.0"
+  VERSION = "0.2.0"
 end

data/lib/k8y.rb

@@ -7,3 +7,4 @@ require_relative "k8y/version"
 require_relative "k8y/kubeconfig"
 require_relative "k8y/group_version"
 require_relative "k8y/client"
+require_relative "k8y/rest"

metadata

@@ -1,43 +1,43 @@
 --- !ruby/object:Gem::Specification
 name: k8y
 version: !ruby/object:Gem::Version
-  version: 0.1.0
+  version: 0.2.0
 platform: ruby
 authors:
 - Timothy Smith
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2021-09-18 00:00:00.000000000 Z
+date: 2021-09-28 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
-  name: faraday
+  name: activesupport
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '6.0'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.6'
+        version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: recursive-open-struct
+  name: faraday
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.6'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '1.1'
+        version: '1.6'
 - !ruby/object:Gem::Dependency
   name: railties
   requirement: !ruby/object:Gem::Requirement
@@ -53,19 +53,19 @@ dependencies:
       - !ruby/object:Gem::Version
         version: '6.0'
 - !ruby/object:Gem::Dependency
-  name: activesupport
+  name: recursive-open-struct
   requirement: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '1.1'
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - "~>"
       - !ruby/object:Gem::Version
-        version: '6.0'
+        version: '1.1'
 - !ruby/object:Gem::Dependency
   name: byebug
   requirement: !ruby/object:Gem::Requirement
@@ -203,8 +203,6 @@ files:
 - lib/k8y/client/apis.rb
 - lib/k8y/client/client.rb
 - lib/k8y/client/resource_description.rb
-- lib/k8y/client/response_formatter.rb
-- lib/k8y/client/rest_client.rb
 - lib/k8y/error.rb
 - lib/k8y/group_version.rb
 - lib/k8y/kubeconfig.rb
@@ -213,6 +211,15 @@ files:
 - lib/k8y/kubeconfig/config.rb
 - lib/k8y/kubeconfig/context.rb
 - lib/k8y/kubeconfig/user.rb
+- lib/k8y/rest.rb
+- lib/k8y/rest/auth.rb
+- lib/k8y/rest/client.rb
+- lib/k8y/rest/config.rb
+- lib/k8y/rest/config_validator.rb
+- lib/k8y/rest/connection.rb
+- lib/k8y/rest/error.rb
+- lib/k8y/rest/response_formatter.rb
+- lib/k8y/rest/transport.rb
 - lib/k8y/version.rb
 homepage: https://github.com/tsontario/k8y
 licenses: []

data/lib/k8y/client/rest_client.rb

@@ -1,90 +0,0 @@
-# frozen_string_literal: true
-
-require "faraday"
-require "base64"
-require "recursive_open_struct"
-
-require_relative "response_formatter"
-
-module K8y
-  module Client
-    class RESTClient
-      attr_reader :context, :path
-
-      def initialize(config:, context:, path: "")
-        @config = config
-        @context = context
-        @path = path
-
-        # TODO: generically handle auth depending on provided config
-        hardcoded_auth
-      end
-
-      def get(sub_path = "", headers: {}, as: :ros)
-        response = connection.get(formatted_uri(host, path, sub_path))
-        format_response(response, as: as)
-      end
-
-      def post(sub_path = "", data:, headers: {}, as: :ros)
-        response = connection.post(formatted_uri(host, path, sub_path), data, headers)
-        format_response(response, as: as)
-      end
-
-      def put(sub_path = "", data:, headers: {}, as: :ros)
-        response = connection.put(formatted_uri(host, path, sub_path), data, headers)
-        format_response(response, as: as)
-      end
-
-      def patch(sub_path = "", strategy:, data:, headers: {}, as: :ros)
-        response = connection.patch(formatted_uri(host, path, sub_path), data, headers)
-        format_response(response, as: as)
-      end
-
-      def delete(sub_path = "", headers: {}, as: :ros)
-        response = connection.delete(formatted_uri(host, path, sub_path))
-        format_response(response, as: as)
-      end
-
-      private
-
-      attr_reader :config, :connection
-
-      def hardcoded_auth
-        cert_store = OpenSSL::X509::Store.new
-        cert_store.add_cert(OpenSSL::X509::Certificate.new(Base64.decode64(cluster.certificate_authority_data)))
-        @connection = Faraday.new(
-          host,
-          ssl: {
-            client_cert: OpenSSL::X509::Certificate.new(Base64.decode64(user.auth_info.client_certificate_data)),
-            client_key: OpenSSL::PKey::RSA.new(Base64.decode64(user.auth_info.client_key_data)),
-            cert_store: cert_store,
-          }
-        )
-      end
-
-      def host
-        cluster.server
-      end
-
-      def cluster
-        config.cluster_for_context(context)
-      end
-
-      def user
-        config.user_for_context(context)
-      end
-
-      def formatted_uri(host, path, sub_path = "")
-        if !sub_path.empty? && !path.end_with?("/")
-          URI.join(host, "#{path}/", sub_path)
-        else
-          URI.join(host, path, sub_path)
-        end
-      end
-
-      def format_response(response, as: :ros)
-        ResponseFormatter.new(response).format(as: as)
-      end
-    end
-  end
-end