uffizzi-cli 1.0.5 → 2.0.27

data/lib/uffizzi/response_helper.rb

@@ -27,28 +27,47 @@ module Uffizzi
         response[:code] == Net::HTTPOK
       end
 
-      def handle_failed_response(response)
-        prepared_errors = prepare_errors(response[:body][:errors])
-        raise Uffizzi::Error.new(prepared_errors)
+      def handle_failed_response(response, addtional_errors = [])
+        errors = get_response_errors(response)
+        common_msg = errors_to_string(errors)
+        addtional_msg = errors_to_string(addtional_errors)
+        message = [common_msg, addtional_msg]
+          .reject { |m| m == '' }
+          .join("\n")
+          .concat("\n")
+
+        raise Uffizzi::ServerResponseError.new(message)
       end
 
       def handle_invalid_compose_response(response)
-        prepared_errors = prepare_errors(response[:body][:compose_file][:payload][:errors])
-        raise Uffizzi::Error.new(prepared_errors)
+        message = errors_to_string(response[:body][:compose_file][:payload][:errors])
+        raise Uffizzi::ServerResponseError.new(message)
+      end
+
+      def get_response_errors(response)
+        return response if response.is_a?(Array)
+        return [response.to_s] unless response.is_a?(Hash)
+
+        body = response.fetch(:body, response.to_s)
+        return [body.to_s] unless body.is_a?(Hash)
+
+        errors = body.fetch(:errors, body.to_s)
+        return [errors.to_s] unless [Hash, Array].include?(errors.class)
+
+        errors
       end
 
       private
 
-      def prepare_errors(errors)
-        errors.values.reduce('') do |acc, error_messages|
-          if error_messages.is_a?(Array)
-            error_messages.each { |error_message| acc = "#{acc}#{prepare_error_message(error_message)}\n" }
-          else
-            acc = "#{acc}#{prepare_error_message(error_message)}\n"
-          end
+      def errors_to_string(errors)
+        return errors.join("\n") if errors.is_a?(Array)
+        return errors.to_s unless errors.is_a?(Hash)
 
-          acc
-        end
+        errors
+          .values
+          .flatten
+          .map { |msg| prepare_error_message(msg.to_s) }
+          .join("\n")
       end
 
       def prepare_error_message(error_message)

data/lib/uffizzi/services/cluster_service.rb

@@ -0,0 +1,59 @@
+# frozen_string_literal: true
+
+require 'uffizzi/clients/api/api_client'
+
+class ClusterService
+  CLUSTER_STATE_DEPLOYING_NAMESPACE = 'deploying_namespace'
+  CLUSTER_STATE_DEPLOYING = 'deploying'
+  CLUSTER_STATE_DEPLOYED = 'deployed'
+  CLUSTER_STATE_FAILED_DEPLOY_NAMESPACE = 'failed_deploy_namespace'
+  CLUSTER_STATE_FAILED = 'failed'
+
+  class << self
+    include ApiClient
+
+    def deployed?(cluster_state)
+      cluster_state == CLUSTER_STATE_DEPLOYED
+    end
+
+    def deploying?(cluster_state)
+      [CLUSTER_STATE_DEPLOYING_NAMESPACE, CLUSTER_STATE_DEPLOYING].include?(cluster_state)
+    end
+
+    def failed?(cluster_state)
+      [CLUSTER_STATE_FAILED_DEPLOY_NAMESPACE, CLUSTER_STATE_FAILED].include?(cluster_state)
+    end
+
+    def wait_cluster_deploy(project_slug, cluster_name, oidc_token)
+      loop do
+        params = {
+          cluster_name: cluster_name,
+          oidc_token: oidc_token,
+        }
+        response = get_cluster(Uffizzi::ConfigFile.read_option(:server), project_slug, params)
+        return Uffizzi::ResponseHelper.handle_failed_response(response) unless Uffizzi::ResponseHelper.ok?(response)
+
+        cluster_data = response.dig(:body, :cluster)
+
+        return cluster_data unless deploying?(cluster_data[:state])
+
+        sleep(5)
+      end
+    end
+
+    def generate_name
+      name = [Faker::Name.first_name, Faker::Name.last_name].map(&:downcase).join('-')
+
+      return name if valid_name?(name)
+
+      generate_name
+    end
+
+    def valid_name?(name)
+      return false if name.nil?
+
+      regex = /\A[a-zA-Z0-9-]*\z/
+      regex.match?(name)
+    end
+  end
+end

data/lib/uffizzi/services/compose_file_service.rb

@@ -84,7 +84,7 @@ class ComposeFileService
       gzipped_file_size = Pathname.new(tmp_tar_path).size
 
       if gzipped_file_size > MAX_HOST_VOLUME_GZIP_FILE_SIZE
-        Uffizzi.ui.say("File/Directory too big by path: #{path}. Gzipped tar archive size is #{gzipped_file_size}")
+        raise Uffizzi::Error.new("File or directory is too large:: #{path}. Gzipped tar archive size is #{gzipped_file_size}")
       end
 
       Base64.encode64(File.binread(tmp_tar_path))
@@ -139,11 +139,12 @@ class ComposeFileService
     def parse_compose_content_to_object(compose_content)
       begin
         compose_data = Psych.safe_load(compose_content, aliases: true)
-      rescue Psych::SyntaxError
-        Uffizzi.ui.say('Invalid compose file')
+      rescue Psych::SyntaxError => e
+        err = [e.problem, e.context].compact.join(' ')
+        raise Uffizzi::Error.new("Syntax error: #{err} at line #{e.line} column #{e.column}")
       end
 
-      Uffizzi.ui.say('Unsupported compose file') if compose_data.nil?
+      raise Uffizzi::Error.new('Unsupported compose file') if compose_data.nil?
 
       compose_data
     end

data/lib/uffizzi/services/env_variables_service.rb

@@ -28,7 +28,7 @@ class EnvVariablesService
       else
         "Environment variable #{variable_name} doesn't exist"
       end
-      raise StandardError.new(error_message)
+      raise Uffizzi::Error.new(error_message)
     end
 
     def variable_has_default_value?(variable_content)

data/lib/uffizzi/services/github_service.rb

@@ -0,0 +1,21 @@
+# frozen_string_literal: true
+
+class GithubService
+  class << self
+    GITHUB_OUTPUT = 'GITHUB_OUTPUT'
+
+    def write_to_github_env(data)
+      return unless data.is_a?(Hash)
+
+      github_output = ENV.fetch(GITHUB_OUTPUT) { raise "#{GITHUB_OUTPUT} is not defined" }
+
+      File.open(github_output, 'a') do |f|
+        data.each { |(key, value)| f.puts("#{key}=#{value}") }
+      end
+    end
+
+    def github_actions_exists?
+      ENV['GITHUB_ACTIONS'].present?
+    end
+  end
+end

data/lib/uffizzi/services/kubeconfig_service.rb

@@ -0,0 +1,132 @@
+# frozen_string_literal: true
+
+require 'uffizzi/clients/api/api_client'
+require 'psych'
+
+class KubeconfigService
+  class InvalidKubeconfigError < StandardError
+    def initialize(file_path)
+      msg = "Invalid kubeconfig at path '#{file_path}'"
+
+      super(msg)
+    end
+  end
+
+  KUBECONFIG_GENERAL_KEYS = ['apiVersion', 'clusters', 'contexts', 'current-context', 'kind', 'users'].freeze
+
+  class << self
+    include ApiClient
+
+    def merge(target_kubeconfig, source_kubeconfig)
+      return source_kubeconfig.deep_dup if target_kubeconfig.nil?
+
+      new_cluster_name = get_current_cluster_name(source_kubeconfig)
+
+      if cluster_exists_in_kubeconfig?(target_kubeconfig, new_cluster_name)
+        replace_by_cluster_name(target_kubeconfig, source_kubeconfig, new_cluster_name)
+      else
+        add(target_kubeconfig, source_kubeconfig)
+      end
+    end
+
+    def exclude(target_kubeconfig, source_kubeconfig)
+      return if target_kubeconfig.nil?
+
+      excludable_cluster_name = get_current_cluster_name(source_kubeconfig)
+      exclude_by_cluster_name(target_kubeconfig, excludable_cluster_name)
+    end
+
+    def get_current_context(kubeconfig)
+      kubeconfig['current-context']
+    end
+
+    def get_first_context(kubeconfig)
+      kubeconfig.fetch('contexts', [])[0]
+    end
+
+    def get_current_cluster_name(kubeconfig)
+      kubeconfig['contexts']
+        .detect { |c| c['name'] == get_current_context(kubeconfig) }
+        .dig('context', 'cluster')
+    end
+
+    def update_current_context(kubeconfig, current_context)
+      new_kubeconfig = kubeconfig.deep_dup
+      new_kubeconfig['current-context'] = current_context
+
+      new_kubeconfig
+    end
+
+    def save_to_filepath(filepath, kubeconfig)
+      real_file_path = File.expand_path(filepath)
+      target_kubeconfig = File.exist?(real_file_path) ? Psych.safe_load(File.read(real_file_path)) : nil
+
+      if target_kubeconfig.present? && !valid_kubeconfig?(target_kubeconfig)
+        raise InvalidKubeconfigError.new(filepath)
+      end
+
+      new_kubeconfig = block_given? ? yield(target_kubeconfig) : kubeconfig
+      return if new_kubeconfig.nil?
+
+      dir_path = File.dirname(real_file_path)
+      FileUtils.mkdir_p(dir_path) unless File.directory?(dir_path)
+      File.write(real_file_path, new_kubeconfig.to_yaml)
+    end
+
+    def default_path
+      kubeconfig_env_path || Uffizzi.configuration.default_kubeconfig_path
+    end
+
+    private
+
+    def cluster_exists_in_kubeconfig?(kubeconfig, cluster_name)
+      clusters = kubeconfig['clusters'] || []
+      clusters.detect { |c| c['name'] == cluster_name }.present?
+    end
+
+    def add(target_kubeconfig, source_kubeconfig)
+      new_kubeconfig = target_kubeconfig.deep_dup
+      new_kubeconfig['clusters'] << source_kubeconfig['clusters'][0]
+      new_kubeconfig['contexts'] << source_kubeconfig['contexts'][0]
+      new_kubeconfig['users'] << source_kubeconfig['users'][0]
+
+      new_kubeconfig
+    end
+
+    def replace_by_cluster_name(target_kubeconfig, source_kubeconfig, cluster_name)
+      new_kubeconfig = exclude_by_cluster_name(target_kubeconfig, cluster_name)
+
+      add(new_kubeconfig, source_kubeconfig)
+    end
+
+    def exclude_by_cluster_name(kubeconfig, cluster_name)
+      clusters = kubeconfig['clusters']
+      contexts = kubeconfig['contexts']
+      users = kubeconfig['users']
+
+      return kubeconfig if clusters.empty? || contexts.empty? || users.empty?
+
+      target_user = contexts.detect { |c| c.dig('context', 'cluster') == cluster_name }.dig('context', 'user')
+      new_clusters = clusters.reject { |c| c['name'] == cluster_name }
+      new_contexts = contexts.reject { |c| c.dig('context', 'cluster') == cluster_name }
+      new_users = users.reject { |c| c['name'] == target_user }
+
+      kubeconfig.merge({ 'clusters' => new_clusters, 'contexts' => new_contexts, 'users' => new_users })
+    end
+
+    def kubeconfig_env_path
+      file_paths = ENV['KUBECONFIG']
+      return if file_paths.blank?
+
+      file_paths.split(':').first
+    end
+
+    def valid_kubeconfig?(data)
+      return false unless data.is_a?(Hash)
+
+      data_keys = data.keys.map(&:to_s)
+
+      KUBECONFIG_GENERAL_KEYS.all? { |k| data_keys.include?(k) }
+    end
+  end
+end

data/lib/uffizzi/services/preview_service.rb

@@ -3,6 +3,9 @@
 require 'uffizzi/clients/api/api_client'
 
 class PreviewService
+  ACTIVITY_ITEM_STATE_FAILED = 'failed'
+  ACTIVITY_ITEM_STATE_DEPLOYED = 'deployed'
+
   class << self
     include ApiClient
 
@@ -18,7 +21,8 @@ class PreviewService
 
     def run_containers_deploy(project_slug, deployment)
       deployment_id = deployment[:id]
-      params = { id: deployment_id }
+      oidc_token = Uffizzi::ConfigFile.read_option(:oidc_token)
+      params = { id: deployment_id, token: oidc_token }
 
       response = deploy_containers(server_url, project_slug, deployment_id, params)
 
@@ -42,9 +46,7 @@ class PreviewService
 
       activity_items = []
       loop do
-        response = get_activity_items(server_url, project_slug, deployment[:id])
-        handle_activity_items_response(response, spinner)
-        activity_items = response[:body][:activity_items]
+        activity_items = fetch_activity_items(project_slug, deployment[:id])
         break if activity_items.count == deployment[:containers].count
 
         sleep(5)
@@ -52,9 +54,13 @@ class PreviewService
 
       spinner.success
 
-      Uffizzi.ui.say('Done')
+      Uffizzi.ui.say('Deployed')
+      Uffizzi.ui.say("Deployment url: https://#{deployment[:preview_url]}")
+      Uffizzi.ui.say("Deployment proxy url: https://#{deployment[:proxy_preview_url]}")
 
       activity_items
+    rescue ApiClient::ResponseError => e
+      Uffizzi::ResponseHelper.handle_failed_response(e.response)
     end
 
     def wait_containers_deploy(deployment, project_slug, activity_items)
@@ -66,16 +72,25 @@ class PreviewService
       containers_spinners = create_containers_spinners(activity_items, spinner)
 
       loop do
-        response = get_activity_items(server_url, project_slug, deployment[:id])
-        handle_activity_items_response(response, spinner)
-        activity_items = response[:body][:activity_items]
+        activity_items = fetch_activity_items(project_slug, deployment[:id])
         update_containers_spinners!(activity_items, containers_spinners)
-        break if activity_items.all? { |activity_item| activity_item[:state] == 'deployed' || activity_item[:state] == 'failed' }
+        break if activity_items.all? { |activity_item| activity_item_finished?(activity_item) }
 
         sleep(5)
       end
 
       spinner.success?
+    rescue ApiClient::ResponseError => e
+      spinner.error
+
+      descriptions = fetch_k8s_containers_descriptions(deployment, project_slug)
+      containers_last_state_messages = descriptions.map do |description|
+        container_name = "Last State for container '#{description[:container_name]}':"
+        states = description[:last_state].map { |k, v| " #{k}: #{v}" }.join("\n")
+        [container_name, states].join("\n")
+      end
+
+      Uffizzi::ResponseHelper.handle_failed_response(e.response, containers_last_state_messages)
     end
 
     def create_containers_spinners(activity_items, spinner)
@@ -90,27 +105,46 @@ class PreviewService
     end
 
     def update_containers_spinners!(activity_items, containers_spinners)
-      finished_activity_items = activity_items.filter do |activity_item|
-        activity_item[:state] == 'deployed' || activity_item[:state] == 'failed'
-      end
+      finished_activity_items = activity_items.filter { |activity_item| activity_item_finished?(activity_item) }
 
       finished_activity_items.each do |activity_item|
         container_spinner = containers_spinners.detect { |spinner| spinner[:name] == activity_item[:name] }
         spinner = container_spinner[:spinner]
         case activity_item[:state]
-        when 'deployed'
+        when ACTIVITY_ITEM_STATE_DEPLOYED
           spinner.success
-        when 'failed'
+        when ACTIVITY_ITEM_STATE_FAILED
           spinner.error
         end
       end
     end
 
-    def handle_activity_items_response(response, spinner)
-      unless Uffizzi::ResponseHelper.ok?(response)
-        spinner.error
-        Uffizzi::ResponseHelper.handle_failed_response(response)
+    def fetch_activity_items(project_slug, deployment_id)
+      response = get_activity_items(server_url, project_slug, deployment_id)
+      raise ApiClient::ResponseError.new(response) unless Uffizzi::ResponseHelper.ok?(response)
+
+      response[:body][:activity_items]
+    end
+
+    def fetch_k8s_containers_descriptions(deployment, project_slug)
+      descriptions = []
+
+      deployment[:containers].each do |container|
+        container_name = container[:service_name]
+        response = get_k8s_container_description(server_url, project_slug, deployment[:id], container_name)
+
+        Uffizzi::ResponseHelper.handle_failed_response(response) unless Uffizzi::ResponseHelper.ok?(response)
+        last_state = response[:body][:last_state]
+        next if last_state.nil?
+
+        descriptions << { container_name: container_name, last_state: last_state }
       end
+
+      descriptions
+    end
+
+    def activity_item_finished?(activity_item)
+      activity_item[:state] == ACTIVITY_ITEM_STATE_DEPLOYED || activity_item[:state] == ACTIVITY_ITEM_STATE_FAILED
     end
   end
 end

data/lib/uffizzi/shell.rb

@@ -5,28 +5,22 @@ require 'awesome_print'
 module Uffizzi
   module UI
     class Shell
+      class ExitError < Thor::Error; end
       attr_accessor :output_format
 
       PRETTY_JSON = 'pretty-json'
       REGULAR_JSON = 'json'
-      GITHUB_ACTION = 'github-action'
 
       def initialize
         @shell = Thor::Shell::Basic.new
       end
 
       def say(message)
-        formatted_message = case output_format
-                            when PRETTY_JSON
-                              format_to_pretty_json(message)
-                            when REGULAR_JSON
-                              format_to_json(message)
-                            when GITHUB_ACTION
-                              format_to_github_action(message)
-                            else
-                              message
-        end
-        @shell.say(formatted_message)
+        @shell.say(format_message(message))
+      end
+
+      def say_error_and_exit(message)
+        raise ExitError.new(format_message(message))
       end
 
       def print_in_columns(messages)
@@ -56,6 +50,10 @@ module Uffizzi
         $stdout = IO.new(1, 'w')
       end
 
+      def stdout_pipe?
+        $stdout.stat.pipe?
+      end
+
       private
 
       def format_to_json(data)
@@ -66,10 +64,15 @@ module Uffizzi
         JSON.pretty_generate(data)
       end
 
-      def format_to_github_action(data)
-        return '' unless data.is_a?(Hash)
-
-        data.reduce('') { |acc, (key, value)| "#{acc}::set-output name=#{key}::#{value}\n" }
+      def format_message(message)
+        case output_format
+        when PRETTY_JSON
+          format_to_pretty_json(message)
+        when REGULAR_JSON
+          format_to_json(message)
+        else
+          message
+        end
       end
     end
   end

data/lib/uffizzi/token.rb

@@ -0,0 +1,37 @@
+# frozen_string_literal: true
+
+require 'json'
+require 'uffizzi/helpers/file_helper'
+
+module Uffizzi
+  class Token
+    TOKEN_PATH = "#{Dir.home}/.config/uffizzi/token"
+
+    class << self
+      def token_path
+        TOKEN_PATH
+      end
+
+      def delete
+        File.truncate(token_path, 0) if exists?
+      end
+
+      def exists?
+        File.exist?(token_path) && !read.nil?
+      end
+
+      def read
+        content = File.read(token_path)
+        content.presence
+      rescue Errno::ENOENT
+        nil
+      end
+
+      def write(token)
+        return nil unless token.is_a?(String)
+
+        Uffizzi::FileHelper.write_with_lock(token_path, token)
+      end
+    end
+  end
+end

data/lib/uffizzi/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Uffizzi
-  VERSION = '1.0.5'
+  VERSION = '2.0.27'
 end

data/lib/uffizzi.rb

@@ -2,6 +2,10 @@
 
 require 'io/console'
 require 'tty-spinner'
+require 'sentry-ruby'
+require 'active_support'
+require 'active_support/core_ext/hash/indifferent_access'
+require 'active_support/core_ext/object/blank'
 
 require 'thor'
 require 'uffizzi/error'
@@ -11,8 +15,14 @@ require 'uffizzi/version'
 require 'uffizzi/clients/api/api_client'
 require 'uffizzi/clients/api/api_routes'
 require 'uffizzi/config_file'
+require 'uffizzi/token'
 require_relative '../config/uffizzi'
 
+Sentry.init do |config|
+  config.dsn = Base64.decode64(ENV['LOGGER_KEY'].to_s)
+  config.logger = Sentry::Logger.new(nil)
+end
+
 module Uffizzi
   class << self
     def ui

data/man/uffizzi

@@ -1,6 +1,6 @@
 .\" generated with Ronn-NG/v0.9.1
 .\" http://github.com/apjanke/ronn-ng/tree/0.9.1
-.TH "UFFIZZI" "" "May 2022" ""
+.TH "UFFIZZI" "" "September 2023" ""
 .SH "NAME"
 \fBuffizzi\fR \- manage Uffizzi resources
 .SH "SYNOPSIS"
@@ -13,11 +13,13 @@ The uffizzi CLI manages authentication, configuration, and
 interaction with Uffizzi APIs\.
 
 For more information on the uffizzi CLI, see:
-https://github\.com/UffizziCloud/uffizzi_cli
+https://docs\.uffizzi\.com/references/cli/
 .fi
 .SH "GROUP"
 .nf
 GROUP is one of the following:
+ cluster
+     Manage virtual clusters
 
  config
      Configure the uffizzi CLI
@@ -25,12 +27,12 @@ GROUP is one of the following:
  connect
      Grant a Uffizzi user account access to external services
 
- preview
-     Manage Uffizzi previews and view logs
+ compose
+     Manage Uffizzi compose environments (previews) and view logs
 
  project
      Manage Uffizzi project resources including compose files for
-     specifying preview configurations and secrets
+     specifying compose environment (preview) configurations and secrets
 .fi
 .SH "COMMAND"
 .nf

data/man/uffizzi-account

@@ -0,0 +1,29 @@
+.\" generated with Ronn-NG/v0.9.1
+.\" http://github.com/apjanke/ronn-ng/tree/0.9.1
+.TH "UFFIZZI\-ACCOUNT" "" "August 2023" ""
+.SH "NAME"
+\fBuffizzi\-account\fR \- manage Uffizzi accounts
+.SH "SYNOPSIS"
+.nf
+uffizzi account COMMAND [UFFIZZI_WIDE_FLAG \|\.\|\.\|\.]
+.fi
+.SH "DESCRIPTION"
+.nf
+Manage Uffizzi accounts
+
+For more information on Uffizzi accounts, see:
+https://docs\.uffizzi\.com/references/cli/
+.fi
+.SH "COMMANDS"
+.nf
+COMMAND is one of the following:
+
+ list
+    List all accounts associated with the user\'s credentials
+
+ set\-default
+    Set the default account in the uffizzi configuration\. Also see
+    $ uffizzi config help for details\.
+.fi
+.P
+Run $ uffizzi account COMMAND \-\-help for more information on a command\.

data/man/uffizzi-account-list

@@ -0,0 +1,26 @@
+.\" generated with Ronn-NG/v0.9.1
+.\" http://github.com/apjanke/ronn-ng/tree/0.9.1
+.TH "UFFIZZI\-ACCOUNT\-LIST" "" "August 2023" ""
+.SH "NAME"
+\fBuffizzi\-account\-list\fR \- list the accounts of the user
+.SH "SYNOPSIS"
+.nf
+uffizzi account list
+.fi
+.SH "DESCRIPTION"
+.nf
+This command lists all accounts (not projects) for the associated user
+
+This command can fail for the following reasons:
+    \- The user is not authenticated
+
+For more information on preview services, see:
+https://docs\.uffizzi\.com/references/cli/
+.fi
+.SH "EXAMPLES"
+.nf
+The following command lists the user\'s accounts:
+
+    $ uffizzi account list
+.fi
+