uffizzi-cli 1.0.4 → 2.0.29

data/lib/uffizzi/cli.rb

@@ -19,6 +19,7 @@ module Uffizzi
     desc 'login [OPTIONS]', 'Login to Uffizzi to view and manage your previews'
     method_option :server, required: false, aliases: '-s'
     method_option :username, required: false, aliases: '-u'
+    method_option :email, required: false, aliases: '-e'
     def login
       require_relative 'cli/login'
       Login.new(options).run
@@ -26,7 +27,8 @@ module Uffizzi
 
     desc 'login_by_identity_token [OPTIONS]', 'Login or register to Uffizzi to view and manage your previews'
     method_option :server, required: true, aliases: '-s'
-    method_option :token, required: true, aliases: '-t'
+    method_option :oidc_token, required: true, aliases: '-t'
+    method_option :access_token, required: false
     def login_by_identity_token
       require_relative 'cli/login_by_identity_token'
       LoginByIdentityToken.new(options).run
@@ -38,6 +40,10 @@ module Uffizzi
       Logout.new(options).run
     end
 
+    desc 'account', 'account'
+    require_relative 'cli/account'
+    subcommand 'account', Cli::Account
+
     desc 'project', 'project'
     require_relative 'cli/project'
     subcommand 'project', Cli::Project
@@ -46,10 +52,14 @@ module Uffizzi
     require_relative 'cli/config'
     subcommand 'config', Cli::Config
 
-    desc 'preview', 'preview'
+    desc 'compose', 'compose'
     method_option :project, required: false
     require_relative 'cli/preview'
-    subcommand 'preview', Cli::Preview
+    subcommand 'compose', Cli::Preview
+
+    desc 'cluster', 'cluster'
+    require_relative 'cli/cluster'
+    subcommand 'cluster', Cli::Cluster
 
     desc 'connect', 'connect'
     require_relative 'cli/connect'
@@ -61,6 +71,8 @@ module Uffizzi
       Disconnect.new.run(credential_type)
     end
 
+    map preview: :compose
+
     class << self
       protected
 
@@ -70,10 +82,8 @@ module Uffizzi
         return Common.show_manual(filename(args)) if show_help?(args, opts)
 
         super
-      rescue Interrupt
-        raise Uffizzi::Error.new('The command was interrupted')
-      rescue StandardError => e
-        raise Uffizzi::Error.new(e.message)
+      rescue Interrupt, StandardError => e
+        ci_workflow? ? handle_ci_exceptions(e) : handle_repl_exceptions(e)
       end
 
       private
@@ -89,6 +99,35 @@ module Uffizzi
         help_options = ['--help', '-h', '--help=true']
         args.empty? || args.include?('help') || opts.any? { |opt| help_options.include?(opt) }
       end
+
+      def ci_workflow?
+        !['', 'false', 'f', '0'].include?(ENV['CI_WORKFLOW'].to_s.downcase)
+      end
+
+      def handle_ci_exceptions(exception)
+        case exception
+        when Thor::Error
+          raise exception
+        when Interrupt
+          raise Uffizzi::CliError.new('CI process was interrupted')
+        else
+          Sentry.capture_exception(exception)
+          raise Uffizzi::CliError.new('System Fault')
+        end
+      end
+
+      def handle_repl_exceptions(exception)
+        case exception
+        when Thor::Error
+          raise exception
+        when Interrupt
+          raise Uffizzi::CliError.new('The command was interrupted')
+        when StandardError
+          raise Uffizzi::CliError.new(exception.message)
+        else
+          raise exception
+        end
+      end
     end
   end
 end

data/lib/uffizzi/clients/api/api_client.rb

@@ -4,6 +4,16 @@ require_relative 'api_routes'
 require_relative 'http_client'
 
 module ApiClient
+  class ResponseError < StandardError
+    attr_reader :response
+
+    def initialize(response)
+      @response = response
+
+      super(response.to_s)
+    end
+  end
+
   include ApiRoutes
 
   def create_session(server, params = {})
@@ -27,6 +37,13 @@ module ApiClient
     build_response(response)
   end
 
+  def fetch_accounts(server)
+    uri = accounts_uri(server)
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
   def fetch_projects(server)
     uri = projects_uri(server)
     response = http_client.make_get_request(uri)
@@ -34,6 +51,13 @@ module ApiClient
     build_response(response)
   end
 
+  def fetch_account_projects(server, account_id)
+    uri = account_projects_uri(server, account_id)
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
   def fetch_credentials(server, account_id)
     uri = credentials_uri(server, account_id)
 
@@ -49,13 +73,20 @@ module ApiClient
     build_response(response)
   end
 
-  def describe_project(server, project_slug)
+  def fetch_project(server, project_slug)
     uri = project_uri(server, project_slug)
     response = http_client.make_get_request(uri)
 
     build_response(response)
   end
 
+  def fetch_account(server, account_name)
+    uri = account_uri(server, account_name)
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
   def create_project(server, account_id, params)
     uri = create_projects_uri(server, account_id)
     response = http_client.make_post_request(uri, params)
@@ -210,6 +241,65 @@ module ApiClient
     build_response(response)
   end
 
+  def get_k8s_container_description(server, project_slug, deployment_id, container_name)
+    uri = k8s_container_description_uri(server, project_slug, deployment_id, container_name)
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
+  def get_project_clusters(server, project_slug, params = nil)
+    uri = project_clusters_uri(server, project_slug, oidc_token: params[:oidc_token])
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
+  def create_cluster(server, project_slug, params)
+    uri = project_clusters_uri(server, project_slug, oidc_token: nil)
+    response = http_client.make_post_request(uri, params)
+
+    build_response(response)
+  end
+
+  def create_access_token(server, session_id)
+    uri = access_tokens_url(server)
+
+    params = { session_id: session_id }
+
+    response = http_client.make_post_request(uri, params)
+
+    build_response(response)
+  end
+
+  def get_cluster(server, project_slug, params)
+    uri = cluster_uri(server, project_slug, cluster_name: params[:cluster_name], oidc_token: params[:oidc_token])
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
+  def get_access_token(server, code)
+    uri = access_token_url(server, code)
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
+  def delete_cluster(server, project_slug, params)
+    uri = cluster_uri(server, project_slug, cluster_name: params[:cluster_name], oidc_token: params[:oidc_token])
+    response = http_client.make_delete_request(uri)
+
+    build_response(response)
+  end
+
+  def get_account_clusters(server, account_id)
+    uri = account_clusters_uri(server, account_id)
+    response = http_client.make_get_request(uri)
+
+    build_response(response)
+  end
+
   private
 
   def http_client
@@ -221,7 +311,7 @@ module ApiClient
         params[:basic_auth_password] = Uffizzi::ConfigFile.read_option(:basic_auth_password)
       end
 
-      @http_client = Uffizzi::HttpClient.new(params[:cookie], params[:basic_auth_user], params[:basic_auth_password])
+      @http_client = Uffizzi::HttpClient.new(params)
     end
 
     @http_client

data/lib/uffizzi/clients/api/api_routes.rb

@@ -3,6 +3,14 @@
 require 'cgi'
 
 module ApiRoutes
+  def accounts_uri(server)
+    "#{server}/api/cli/v1/accounts"
+  end
+
+  def account_uri(server, account_name)
+    "#{server}/api/cli/v1/accounts/#{account_name}"
+  end
+
   def compose_file_uri(server, project_slug)
     "#{server}/api/cli/v1/projects/#{project_slug}/compose_file"
   end
@@ -15,6 +23,10 @@ module ApiRoutes
     "#{server}/api/cli/v1/projects"
   end
 
+  def account_projects_uri(server, account_id)
+    "#{server}/api/cli/v1/accounts/#{account_id}/projects"
+  end
+
   def create_projects_uri(server, account_id)
     "#{server}/api/cli/v1/accounts/#{account_id}/projects"
   end
@@ -81,4 +93,36 @@ module ApiRoutes
   def preview_service_logs_uri(server, project_slug, deployment_id, container_name)
     "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/containers/#{container_name}/logs"
   end
+
+  def k8s_container_description_uri(server, project_slug, deployment_id, container_name)
+    "#{server}/api/cli/v1/projects/#{project_slug}/deployments/#{deployment_id}/containers/#{container_name}/k8s_container_description"
+  end
+
+  def project_clusters_uri(server, project_slug, oidc_token:)
+    return "#{server}/api/cli/v1/projects/#{project_slug}/clusters" if oidc_token.nil?
+
+    "#{server}/api/cli/v1/projects/#{project_slug}/clusters?token=#{oidc_token}"
+  end
+
+  def cluster_uri(server, project_slug, cluster_name:, oidc_token:)
+    return "#{server}/api/cli/v1/projects/#{project_slug}/clusters/#{cluster_name}" if oidc_token.nil?
+
+    "#{server}/api/cli/v1/projects/#{project_slug}/clusters/#{cluster_name}?token=#{oidc_token}"
+  end
+
+  def access_token_url(server, code)
+    "#{server}/api/cli/v1/access_tokens/#{code}"
+  end
+
+  def access_tokens_url(server)
+    "#{server}/api/cli/v1/access_tokens"
+  end
+
+  def browser_sign_in_url(server, session_id)
+    "#{server}/sign_in?session_id=#{session_id}"
+  end
+
+  def account_clusters_uri(server, account_id)
+    "#{server}/api/cli/v1/accounts/#{account_id}/clusters"
+  end
 end

data/lib/uffizzi/clients/api/http_client.rb

@@ -7,10 +7,10 @@ module Uffizzi
   class HttpClient
     attr_accessor :auth_cookie, :basic_auth_user, :basic_auth_password
 
-    def initialize(auth_cookie, basic_auth_user, basic_auth_password)
-      @auth_cookie = auth_cookie
-      @basic_auth_user = basic_auth_user
-      @basic_auth_password = basic_auth_password
+    def initialize(params)
+      @auth_cookie = params[:cookie]
+      @basic_auth_user = params[:basic_auth_user]
+      @basic_auth_password = params[:basic_auth_password]
     end
 
     def make_get_request(request_uri)
@@ -41,13 +41,17 @@ module Uffizzi
         http.request(request)
       end
 
-      raise Uffizzi::Error.new('Not authorized') if response.is_a?(Net::HTTPUnauthorized)
+      if response.is_a?(Net::HTTPUnauthorized)
+        Uffizzi::Token.delete if Uffizzi::Token.exists?
+        raise Uffizzi::Error.new('Not authorized')
+      end
 
       response
     end
 
     def build_request(uri, params, method)
-      headers = { 'Content-Type' => 'application/json' }
+      access_token = Uffizzi::Token.read
+      headers = get_headers(access_token)
       request = case method
                 when :get
                   Net::HTTP::Get.new(uri.request_uri, headers)
@@ -62,9 +66,17 @@ module Uffizzi
         request.body = params.to_json
       end
       request['Cookie'] = @auth_cookie
-      request.basic_auth(@basic_auth_user, @basic_auth_password)
+      request.basic_auth(@basic_auth_user, @basic_auth_password) unless access_token
 
       request
     end
+
+    def get_headers(access_token)
+      content_type_headers = { 'Content-Type' => 'application/json' }
+      auth_headers = access_token ? { 'Authorization' => "Bearer #{access_token}" } : {}
+      cli_version = { 'x-uffizzi-cli-version' => Uffizzi::VERSION }
+
+      content_type_headers.merge(auth_headers).merge(cli_version)
+    end
   end
 end

data/lib/uffizzi/config_file.rb

@@ -1,11 +1,11 @@
 # frozen_string_literal: true
 
 require 'json'
-require 'fileutils'
+require 'uffizzi/helpers/file_helper'
 
 module Uffizzi
   class ConfigFile
-    CONFIG_PATH = "#{Dir.home}/.config/uffizzi/config_default"
+    CONFIG_PATH = "#{Dir.home}/.config/uffizzi/config_default.json"
 
     class << self
       def config_path
@@ -20,23 +20,25 @@ module Uffizzi
         File.exist?(config_path)
       end
 
-      def read_option(option)
+      def read_option(option, nested_option = nil)
         data = read
-        return nil unless data.is_a?(Hash)
 
-        data[option]
+        value = data[option]
+        return value.presence if nested_option.nil?
+        return nil unless value.is_a?(Hash)
+
+        value[nested_option].presence
       end
 
       def option_has_value?(option)
         data = read
-        return false if !data.is_a?(Hash) || !option_exists?(option)
+        return false unless option_exists?(option)
 
-        !data[option].empty?
+        data[option].present?
       end
 
       def write_option(key, value)
         data = exists? ? read : {}
-        return nil unless data.is_a?(Hash)
 
         data[key] = value
         write(data)
@@ -44,7 +46,7 @@ module Uffizzi
 
       def unset_option(key)
         data = read
-        return nil unless data.is_a?(Hash) || !option_exists?(key)
+        return unless option_exists?(key)
 
         data[key] = ''
         write(data)
@@ -56,7 +58,6 @@ module Uffizzi
 
       def list
         data = read
-        return nil unless data.is_a?(Hash)
 
         content = data.reduce('') do |acc, pair|
           property, value = pair
@@ -70,7 +71,6 @@ module Uffizzi
 
       def option_exists?(option)
         data = read
-        return false unless data.is_a?(Hash)
 
         data.key?(option)
       end
@@ -79,43 +79,18 @@ module Uffizzi
 
       def read
         data = File.read(config_path)
-        options = data.split("\n")
-        options.reduce({}) do |acc, option|
-          key, value = option.split('=', 2)
-          acc.merge({ key.strip.to_sym => value.strip })
-        end
+        JSON.parse(data).deep_symbolize_keys
       rescue Errno::ENOENT => e
         file_path = e.message.split(' ').last
         message = "Configuration file not found: #{file_path}\n" \
         'To configure the uffizzi CLI interactively, run $ uffizzi config'
         raise Uffizzi::Error.new(message)
+      rescue JSON::ParserError
+        {}
       end
 
       def write(data)
-        prepared_data = prepare_data(data)
-
-        lock(config_path) { atomic_write(config_path, "#{config_path}.tmp", prepared_data) }
-      end
-
-      def prepare_data(data)
-        data.reduce('') do |acc, option|
-          key, value = option
-          "#{acc}#{key} = #{value}\n"
-        end
-      end
-
-      def atomic_write(path, temp_path, content)
-        File.open(temp_path, 'w') { |f| f.write(content) }
-        FileUtils.mv(temp_path, path)
-      end
-
-      def lock(path)
-        dir = File.dirname(path)
-        FileUtils.mkdir_p(dir) unless File.directory?(dir)
-
-        File.open(path).flock(File::LOCK_EX) if File.exist?(path)
-        yield
-        File.open(path).flock(File::LOCK_UN)
+        Uffizzi::FileHelper.write_with_lock(config_path, data.to_json)
       end
     end
   end

data/lib/uffizzi/error.rb

@@ -1,5 +1,20 @@
 # frozen_string_literal: true
 
 module Uffizzi
+  RESPONSE_SERVER_ERROR_HEADER = "Server Error:\n"
+  CLI_ERROR_HEADER = "CLI Error:\n"
+
   class Error < Thor::Error; end
+
+  class ServerResponseError < Thor::Error
+    def initialize(message)
+      super("#{RESPONSE_SERVER_ERROR_HEADER}#{message}")
+    end
+  end
+
+  class CliError < Thor::Error
+    def initialize(message)
+      super("#{CLI_ERROR_HEADER}#{message}")
+    end
+  end
 end

data/lib/uffizzi/helpers/config_helper.rb

@@ -0,0 +1,49 @@
+# frozen_string_literal: true
+
+module Uffizzi
+  module ConfigHelper
+    CLUSTER_PARAMS = [:kubeconfig_path].freeze
+
+    class ConfigParamsError < StandardError
+      def initialize(unavailable_params, key)
+        msg = "These params #{unavailable_params.join(', ')} is not available for #{key}"
+
+        super(msg)
+      end
+    end
+
+    class << self
+      def read_option_from_config(option)
+        ConfigFile.option_has_value?(option) ? ConfigFile.read_option(option) : nil
+      end
+
+      def account_config(id, name = nil)
+        { id: id, name: name }
+      end
+
+      def update_clusters_config_by_id(id, params)
+        unavailable_params = params.keys - CLUSTER_PARAMS
+        raise ConfigParamsError.new(unavailable_params, :cluster) if unavailable_params.present?
+
+        current_cluster = cluster_config_by_id(id) || {}
+        new_current_cluster = current_cluster.merge({ id: id }).merge(params)
+
+        clusters_config_without(id) << new_current_cluster
+      end
+
+      def clusters_config_without(id)
+        clusters.reject { |c| c[:id] == id }
+      end
+
+      def cluster_config_by_id(id)
+        clusters.detect { |c| c[:id] == id }
+      end
+
+      private
+
+      def clusters
+        read_option_from_config(:clusters) || []
+      end
+    end
+  end
+end

data/lib/uffizzi/helpers/file_helper.rb

@@ -0,0 +1,25 @@
+# frozen_string_literal: true
+
+module Uffizzi
+  module FileHelper
+    class << self
+      def write_with_lock(path, data)
+        lock(path) { atomic_write(path, "#{path}.tmp", data) }
+      end
+
+      def atomic_write(path, temp_path, content)
+        File.open(temp_path, 'w') { |f| f.write(content) }
+        FileUtils.mv(temp_path, path)
+      end
+
+      def lock(path)
+        dir = File.dirname(path)
+        FileUtils.mkdir_p(dir) unless File.directory?(dir)
+
+        File.open(path).flock(File::LOCK_EX) if File.exist?(path)
+        yield
+        File.open(path).flock(File::LOCK_UN)
+      end
+    end
+  end
+end

data/lib/uffizzi/helpers/login_helper.rb

@@ -0,0 +1,33 @@
+# frozen_string_literal: true
+
+require 'uffizzi/helpers/config_helper'
+
+module Uffizzi
+  module LoginHelper
+    class << self
+      def prepare_request_params(username, password)
+        {
+          user: {
+            email: username,
+            password: password,
+          },
+        }
+      end
+
+      def set_server(options)
+        config_server = ConfigFile.exists? ? Uffizzi::ConfigHelper.read_option_from_config(:server) : nil
+        server_address = (options[:server] || config_server || Uffizzi.ui.ask('Server:')).sub(/\/+$/, '')
+        server_address.start_with?('http:', 'https:') ? server_address : "https://#{server_address}"
+      end
+
+      def set_username(options)
+        config_username = ConfigFile.exists? ? Uffizzi::ConfigHelper.read_option_from_config(:username) : nil
+        options[:username] || config_username || Uffizzi.ui.ask('Username:')
+      end
+
+      def set_password
+        ENV['UFFIZZI_PASSWORD'] || Uffizzi.ui.ask('Password:', echo: false)
+      end
+    end
+  end
+end

data/lib/uffizzi/helpers/project_helper.rb

@@ -1,9 +1,20 @@
 # frozen_string_literal: true
 
+require 'faker'
+
 module Uffizzi
   module ProjectHelper
     SLUG_ENDING_LENGTH = 6
     class << self
+      def generate_default_params
+        name = generate_name
+        {
+          name: name,
+          description: default_description,
+          slug: generate_slug(name),
+        }
+      end
+
       def generate_slug(name)
         formatted_name = name.downcase.gsub(/ /, '-').gsub(/[^\w-]+/, '')
         slug_ending = generate_random_string(SLUG_ENDING_LENGTH)
@@ -17,6 +28,14 @@ module Uffizzi
         hexatridecimal_base = 36
         rand(hexatridecimal_base**length).to_s(hexatridecimal_base)
       end
+
+      def default_description
+        'Project generated by Uffizzi'
+      end
+
+      def generate_name
+        Faker::Lorem.word
+      end
     end
   end
 end

data/lib/uffizzi/promt.rb

@@ -16,6 +16,10 @@ module Uffizzi
       def ask(message, **args)
         @prompt.ask(message, **args)
       end
+
+      def yes?(message)
+        @prompt.yes?(message)
+      end
     end
   end
 end