uffizzi-cli 2.2.0 → 2.2.2

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: c57cec1f82e6f54de217f0d1e17b88a8ce5bb2dd58eb702df2a10930508f1203
-  data.tar.gz: b904d36aef21a479dac014429f09eebd80cb1715dfd71cf2457fea34cb5f5175
+  metadata.gz: 9f1280afea82284077769e8545880e7420aede5c114a837f3ae2e21482637bac
+  data.tar.gz: e9f5235cb793d83b710c291c62f5027f0226d400aa836f9ea56c18f95b474d06
 SHA512:
-  metadata.gz: 9d5f9f27fab4efec5b44910d37e53ce60b65ba6995e89a5e65b1a7d60c0925899f7cce271c2670d728aeb66845da3c075cab9492baf1f2c45ac3d80504ae2b4f
-  data.tar.gz: c3b2a87f53468a55939cde535cf0389eaca7b2666b581312089ee0c51eed195a58366c7c763b16fad8da53ffe8ca9ba92b4cd4bfea88ccffc09397b4d6f39204
+  metadata.gz: ca04830842f417cb76799ae64c1106866a4d91a7774a07fa3c63fbbe726eac5ab78381c2059ef23a6157948b457984e723bc0e4273d6dbeda48d406379ebe3e4
+  data.tar.gz: 119bb3460dc17116351d4553400867b6225e6431614bdb6934d5f4dc1c532c0cf21b7d61a254210ac2a0eb0643d7183a6ac301b29ea352d81f6dc6feb6a339f2

data/lib/uffizzi/auth_helper.rb

@@ -16,7 +16,7 @@ module Uffizzi
         Uffizzi::Token.delete if Uffizzi::Token.exists?
       end
 
-      def check_login(project_option)
+      def check_login(project_option = nil)
         raise Uffizzi::Error.new('You are not logged in. Run `uffizzi login`.') unless signed_in?
         raise Uffizzi::Error.new('This command needs project to be set in config file') unless project_set?(project_option)
       end

data/lib/uffizzi/cli/cluster.rb

@@ -76,19 +76,18 @@ module Uffizzi
     def run(command, command_args = {})
       Uffizzi.ui.output_format = options[:output]
       Uffizzi::AuthHelper.check_login(options[:project])
-      project_slug = options[:project].nil? ? ConfigFile.read_option(:project) : options[:project]
 
       case command
       when 'list'
-        handle_list_command(project_slug)
+        handle_list_command
       when 'create'
-        handle_create_command(project_slug, command_args)
+        handle_create_command(command_args)
       when 'describe'
-        handle_describe_command(project_slug, command_args)
+        handle_describe_command(command_args)
       when 'delete'
-        handle_delete_command(project_slug, command_args)
+        handle_delete_command(command_args)
       when 'update-kubeconfig'
-        handle_update_kubeconfig_command(project_slug, command_args)
+        handle_update_kubeconfig_command(command_args)
       when 'disconnect'
         ClusterDisconnectService.handle(options)
       when 'sleep'
@@ -98,13 +97,12 @@ module Uffizzi
       end
     end
 
-    def handle_list_command(project_slug)
+    def handle_list_command
       is_all = options[:all]
       response = if is_all
-        get_account_clusters(ConfigFile.read_option(:server), ConfigFile.read_option(:account, :id))
+        get_account_clusters(server, ConfigFile.read_option(:account, :id))
       else
-        oidc_token = ConfigFile.read_option(:oidc_token)
-        get_project_clusters(ConfigFile.read_option(:server), project_slug, oidc_token: oidc_token)
+        get_project_clusters(server, project_slug, oidc_token: oidc_token)
       end
 
       if ResponseHelper.ok?(response)
@@ -115,7 +113,7 @@ module Uffizzi
     end
 
     # rubocop:disable Metrics/PerceivedComplexity
-    def handle_create_command(project_slug, command_args)
+    def handle_create_command(command_args)
       Uffizzi.ui.disable_stdout if Uffizzi.ui.output_format
 
       if options[:name]
@@ -125,23 +123,20 @@ module Uffizzi
       end
 
       cluster_name = command_args[:name] || options[:name] || ClusterService.generate_name
-      creation_source = options[:"creation-source"] || ClusterService::MANUAL_CREATION_SOURCE
-      k8s_version = options[:"k8s-version"]
       Uffizzi.ui.say_error_and_exit("Cluster name: #{cluster_name} is not valid.") unless ClusterService.valid_name?(cluster_name)
 
-      params = cluster_creation_params(
-        name: cluster_name,
-        creation_source: creation_source,
-        manifest_file_path: options[:manifest],
-        k8s_version: k8s_version,
-      )
-      response = create_cluster(ConfigFile.read_option(:server), project_slug, params)
+      unless ClusterService.valid_name?(cluster_name)
+        Uffizzi.ui.say_error_and_exit("Cluster name: #{cluster_name} is not valid.")
+      end
+
+      params = cluster_creation_params(cluster_name)
+      response = create_cluster(server, project_slug, params)
 
       return ResponseHelper.handle_failed_response(response) unless ResponseHelper.created?(response)
 
       spinner = TTY::Spinner.new("[:spinner] Creating cluster #{cluster_name}...", format: :dots)
       spinner.auto_spin
-      cluster_data = ClusterService.wait_cluster_deploy(project_slug, cluster_name, ConfigFile.read_option(:oidc_token))
+      cluster_data = ClusterService.wait_cluster_deploy(project_slug, cluster_name, oidc_token)
 
       if ClusterService.failed?(cluster_data[:state])
         spinner.error
@@ -151,26 +146,28 @@ module Uffizzi
       spinner.success
       handle_succeed_create_response(cluster_data)
     rescue SystemExit, Interrupt, SocketError
-      handle_interrupt_creation(cluster_name, ConfigFile.read_option(:server), project_slug)
+      handle_interrupt_creation(cluster_name)
     end
     # rubocop:enable Metrics/PerceivedComplexity
 
-    def handle_describe_command(project_slug, command_args)
-      cluster_data = fetch_cluster_data(project_slug, command_args[:cluster_name])
+    def handle_describe_command(command_args)
+      cluster_data = ClusterService.fetch_cluster_data(command_args[:cluster_name], **cluster_api_connection_params)
+      render_data = ClusterService.build_render_data(cluster_data)
 
-      handle_succeed_describe(cluster_data)
+      Uffizzi.ui.output_format = Uffizzi::UI::Shell::PRETTY_LIST
+      Uffizzi.ui.say(render_data)
     end
 
-    def handle_delete_command(project_slug, command_args)
+    def handle_delete_command(command_args)
       cluster_name = command_args[:cluster_name]
       is_delete_kubeconfig = options[:'delete-config']
 
-      return handle_delete_cluster(project_slug, cluster_name) unless is_delete_kubeconfig
+      return handle_delete_cluster(cluster_name) unless is_delete_kubeconfig
 
-      cluster_data = fetch_cluster_data(project_slug, cluster_name)
+      cluster_data = ClusterService.fetch_cluster_data(cluster_name, **cluster_api_connection_params)
       kubeconfig = parse_kubeconfig(cluster_data[:kubeconfig])
 
-      handle_delete_cluster(project_slug, cluster_name)
+      handle_delete_cluster(cluster_name)
       exclude_kubeconfig(cluster_data[:id], kubeconfig) if kubeconfig.present?
     end
 
@@ -194,12 +191,12 @@ module Uffizzi
       end
     end
 
-    def handle_delete_cluster(project_slug, cluster_name)
+    def handle_delete_cluster(cluster_name)
       params = {
         cluster_name: cluster_name,
-        oidc_token: ConfigFile.read_option(:oidc_token),
+        oidc_token: oidc_token,
       }
-      response = delete_cluster(ConfigFile.read_option(:server), project_slug, params)
+      response = delete_cluster(server, project_slug, params)
 
       if ResponseHelper.no_content?(response)
         Uffizzi.ui.say("Cluster #{cluster_name} deleted")
@@ -208,10 +205,10 @@ module Uffizzi
       end
     end
 
-    def handle_update_kubeconfig_command(project_slug, command_args)
+    def handle_update_kubeconfig_command(command_args)
       kubeconfig_path = options[:kubeconfig] || KubeconfigService.default_path
       cluster_name = command_args[:cluster_name]
-      cluster_data = fetch_cluster_data(project_slug, cluster_name)
+      cluster_data = ClusterService.fetch_cluster_data(cluster_name, **cluster_api_connection_params)
 
       unless cluster_data[:kubeconfig].present?
         say_error_update_kubeconfig(cluster_data)
@@ -289,13 +286,15 @@ module Uffizzi
       end
     end
 
-    def cluster_creation_params(name:, creation_source:, manifest_file_path:, k8s_version:)
+    def cluster_creation_params(cluster_name)
+      creation_source = options[:"creation-source"] || ClusterService::MANUAL_CREATION_SOURCE
+      manifest_file_path = options[:manifest]
+      k8s_version = options[:"k8s-version"]
       manifest_content = load_manifest_file(manifest_file_path)
-      oidc_token = Uffizzi::ConfigFile.read_option(:oidc_token)
 
       {
         cluster: {
-          name: name,
+          name: cluster_name,
           manifest: manifest_content,
           creation_source: creation_source,
           k8s_version: k8s_version,
@@ -312,7 +311,7 @@ module Uffizzi
       raise Uffizzi::Error.new(e.message)
     end
 
-    def handle_interrupt_creation(cluster_name, server, project_slug)
+    def handle_interrupt_creation(cluster_name)
       deletion_response = delete_cluster(server, project_slug, cluster_name: cluster_name)
       deletion_message = if ResponseHelper.no_content?(deletion_response)
         "The cluster #{cluster_name} has been disabled."
@@ -348,24 +347,6 @@ module Uffizzi
       end.join("\n")
     end
 
-    def handle_succeed_describe(cluster_data)
-      prepared_cluster_data = {
-        name: cluster_data[:name],
-        status: cluster_data[:state],
-        created: Time.strptime(cluster_data[:created_at], '%Y-%m-%dT%H:%M:%S.%N').strftime('%a %b %d %H:%M:%S %Y'),
-        url: cluster_data[:host],
-        k8s_version: cluster_data[:k8s_version],
-      }
-
-      rendered_cluster_data = if Uffizzi.ui.output_format.nil?
-        prepared_cluster_data.map { |k, v| "- #{k.to_s.upcase}: #{v}" }.join("\n").strip
-      else
-        prepared_cluster_data
-      end
-
-      Uffizzi.ui.say(rendered_cluster_data)
-    end
-
     def handle_succeed_create_response(cluster_data)
       kubeconfig_path = options[:kubeconfig] || KubeconfigService.default_path
       is_update_current_context = options[:'update-current-context']
@@ -432,20 +413,6 @@ module Uffizzi
       Psych.safe_load(Base64.decode64(kubeconfig))
     end
 
-    def fetch_cluster_data(project_slug, cluster_name)
-      params = {
-        cluster_name: cluster_name,
-        oidc_token: ConfigFile.read_option(:oidc_token),
-      }
-      response = get_cluster(ConfigFile.read_option(:server), project_slug, params)
-
-      if ResponseHelper.ok?(response)
-        response.dig(:body, :cluster)
-      else
-        ResponseHelper.handle_failed_response(response)
-      end
-    end
-
     def save_previous_current_context(kubeconfig_path, current_context)
       return if kubeconfig_path.nil? || ConfigHelper.previous_current_context_by_path(kubeconfig_path).present?
 
@@ -458,5 +425,25 @@ module Uffizzi
       Uffizzi.ui.say('Please update the current context or provide a cluster name.')
       Uffizzi.ui.say('$uffizzi cluster sleep my-cluster')
     end
+
+    def cluster_api_connection_params
+      {
+        server: server,
+        project_slug: project_slug,
+        oidc_token: oidc_token,
+      }
+    end
+
+    def oidc_token
+      @oidc_token ||= ConfigFile.read_option(:oidc_token)
+    end
+
+    def project_slug
+      @project_slug ||= options[:project].nil? ? ConfigFile.read_option(:project) : options[:project]
+    end
+
+    def server
+      @server ||= ConfigFile.read_option(:server)
+    end
   end
 end

data/lib/uffizzi/cli/dev.rb

@@ -15,67 +15,110 @@ module Uffizzi
     method_option :kubeconfig, type: :string
     method_option :'k8s-version', required: false, type: :string
     def start(config_path = 'skaffold.yaml')
-      Uffizzi::AuthHelper.check_login(options[:project])
+      run('start', config_path: config_path)
+    end
+
+    desc 'stop', 'Stop dev environment'
+    def stop
+      run('stop')
+    end
+
+    desc 'describe', 'Describe dev environment'
+    def describe
+      run('describe')
+    end
+
+    desc 'delete', 'Delete dev environment'
+    def delete
+      run('delete')
+    end
+
+    private
+
+    def run(command, command_args = {})
+      Uffizzi::AuthHelper.check_login
+
+      case command
+      when 'start'
+        handle_start_command(command_args)
+      when 'stop'
+        handle_stop_command
+      when 'describe'
+        handle_describe_command
+      when 'delete'
+        handle_delete_command
+      end
+    end
+
+    def handle_start_command(command_args)
+      config_path = command_args[:config_path]
       DevService.check_skaffold_existence
-      DevService.check_running_daemon if options[:quiet]
+      DevService.check_no_running_process!
       DevService.check_skaffold_config_existence(config_path)
-      cluster_id, cluster_name = start_create_cluster
-      kubeconfig = wait_cluster_creation(cluster_name)
+
+      if dev_environment.empty?
+        DevService.set_startup_state
+        cluster_name = start_create_cluster
+        wait_cluster_creation(cluster_name)
+        DevService.set_dev_environment_config(cluster_name, config_path, options)
+        DevService.set_cluster_deployed_state
+      end
 
       if options[:quiet]
         launch_demonise_skaffold(config_path)
       else
-        DevService.start_basic_skaffold(config_path, options)
-      end
-    ensure
-      if defined?(cluster_name).present? && defined?(cluster_id).present?
-        kubeconfig = defined?(kubeconfig).present? ? kubeconfig : nil
-        handle_delete_cluster(cluster_id, cluster_name, kubeconfig)
+        launch_basic_skaffold(config_path)
       end
     end
 
-    desc 'stop', 'Stop dev environment'
-    def stop
-      return Uffizzi.ui.say('Uffizzi dev is not running') unless File.exist?(DevService.pid_path)
+    def handle_stop_command
+      DevService.check_running_process!
+      DevService.stop_process
+      Uffizzi.ui.say('Uffizzi dev was stopped')
+    end
 
-      pid = File.read(DevService.pid_path).to_i
-      File.delete(DevService.pid_path)
+    def handle_describe_command
+      DevService.check_environment_exist!
 
-      Uffizzi.process.kill('QUIT', pid)
-      Uffizzi.ui.say('Uffizzi dev was stopped')
-    rescue Errno::ESRCH
-      Uffizzi.ui.say('Uffizzi dev is not running')
-      File.delete(DevService.pid_path)
+      cluster_data = fetch_dev_env_cluster!
+      cluster_render_data = ClusterService.build_render_data(cluster_data)
+      dev_environment_render_data = cluster_render_data.merge(config_path: dev_environment[:config_path])
+
+      Uffizzi.ui.output_format = Uffizzi::UI::Shell::PRETTY_LIST
+      Uffizzi.ui.say(dev_environment_render_data)
     end
 
-    private
+    def handle_delete_command
+      DevService.check_environment_exist!
+
+      if DevService.process_running?
+        DevService.stop_process
+        Uffizzi.ui.say('Uffizzi dev was stopped')
+      end
+
+      cluster_data = fetch_dev_env_cluster!
+      handle_delete_cluster(cluster_data)
+      DevService.clear_dev_environment_config
+    end
 
     def start_create_cluster
-      params = cluster_creation_params(
-        name: ClusterService.generate_name,
-        creation_source: ClusterService::MANUAL_CREATION_SOURCE,
-        k8s_version: options[:"k8s-version"],
-      )
+      params = cluster_creation_params
       Uffizzi.ui.say('Start creating a cluster')
-      response = create_cluster(ConfigFile.read_option(:server), project_slug, params)
+      response = create_cluster(server, project_slug, params)
       return ResponseHelper.handle_failed_response(response) unless ResponseHelper.created?(response)
 
-      cluster_id = response.dig(:body, :cluster, :id)
-      cluster_name = response.dig(:body, :cluster, :name)
-
-      [cluster_id, cluster_name]
+      response.dig(:body, :cluster, :name)
     end
 
     def wait_cluster_creation(cluster_name)
       Uffizzi.ui.say('Checking the cluster status...')
-      cluster_data = ClusterService.wait_cluster_deploy(project_slug, cluster_name, ConfigFile.read_option(:oidc_token))
+      cluster_data = ClusterService.wait_cluster_deploy(project_slug, cluster_name, oidc_token)
 
       if ClusterService.failed?(cluster_data[:state])
         Uffizzi.ui.say_error_and_exit("Cluster with name: #{cluster_name} failed to be created.")
       end
 
       handle_succeed_cluster_creation(cluster_data)
-      parse_kubeconfig(cluster_data[:kubeconfig])
     end
 
     def handle_succeed_cluster_creation(cluster_data)
@@ -109,30 +152,30 @@ module Uffizzi
       ConfigFile.write_option(:clusters, clusters_config)
     end
 
-    def cluster_creation_params(name:, creation_source:, k8s_version:)
-      oidc_token = Uffizzi::ConfigFile.read_option(:oidc_token)
-
+    def cluster_creation_params
       {
         cluster: {
-          name: name,
+          name: ClusterService.generate_name,
           manifest: nil,
-          creation_source: creation_source,
-          k8s_version: k8s_version,
+          creation_source: ClusterService::MANUAL_CREATION_SOURCE,
+          k8s_version: options[:"k8s-version"],
         },
         token: oidc_token,
       }
     end
 
-    def handle_delete_cluster(cluster_id, cluster_name, kubeconfig)
-      return if cluster_id.nil? || cluster_name.nil?
+    def handle_delete_cluster(cluster_data)
+      cluster_id = cluster_data[:id]
+      cluster_name = cluster_data[:name]
+      kubeconfig = parse_kubeconfig(cluster_data[:kubeconfig])
 
       exclude_kubeconfig(cluster_id, kubeconfig) if kubeconfig.present?
 
       params = {
         cluster_name: cluster_name,
-        oidc_token: ConfigFile.read_option(:oidc_token),
+        oidc_token: oidc_token,
       }
-      response = delete_cluster(ConfigFile.read_option(:server), project_slug, params)
+      response = delete_cluster(server, project_slug, params)
 
       if ResponseHelper.no_content?(response)
         Uffizzi.ui.say("Cluster #{cluster_name} deleted")
@@ -179,20 +222,59 @@ module Uffizzi
     def launch_demonise_skaffold(config_path)
       Uffizzi.process.daemon(true)
 
-      at_exit do
-        File.delete(DevService.pid_path) if File.exist?(DevService.pid_path)
+      Uffizzi.at_exit do
+        DevService.stop_process
       end
 
+      DevService.save_pid
       File.delete(DevService.logs_path) if File.exist?(DevService.logs_path)
-      File.write(DevService.pid_path, Uffizzi.process.pid)
       DevService.start_check_pid_file_existence
       DevService.start_demonised_skaffold(config_path, options)
     rescue StandardError => e
       File.open(DevService.logs_path, 'a') { |f| f.puts(e.message) }
     end
 
+    def launch_basic_skaffold(config_path)
+      Uffizzi.at_exit do
+        DevService.stop_process
+      end
+
+      DevService.save_pid
+      DevService.start_check_pid_file_existence
+      DevService.start_basic_skaffold(config_path, options)
+    end
+
+    def fetch_dev_env_cluster!
+      if DevService.startup?
+        Uffizzi.ui.say_error_and_exit('Dev environment not started yet')
+      end
+
+      cluster_name = dev_environment[:cluster_name]
+      ClusterService.fetch_cluster_data(cluster_name, **cluster_api_connection_params)
+    end
+
+    def dev_environment
+      @dev_environment ||= DevService.dev_environment
+    end
+
+    def cluster_api_connection_params
+      {
+        server: server,
+        project_slug: project_slug,
+        oidc_token: oidc_token,
+      }
+    end
+
     def project_slug
       @project_slug ||= ConfigFile.read_option(:project)
     end
+
+    def oidc_token
+      @oidc_token ||= ConfigFile.read_option(:oidc_token)
+    end
+
+    def server
+      @server ||= ConfigFile.read_option(:server)
+    end
   end
 end

data/lib/uffizzi/helpers/config_helper.rb

@@ -52,6 +52,14 @@ module Uffizzi
         cluster_previous_current_contexts.detect { |c| c[:kubeconfig_path] == path }
       end
 
+      def set_dev_environment(cluster_name, params = {})
+        { cluster_name: cluster_name }.merge(params)
+      end
+
+      def dev_environment
+        read_option_from_config(:dev_environment) || {}
+      end
+
       private
 
       def clusters

data/lib/uffizzi/services/cluster_service.rb

@@ -1,5 +1,6 @@
 # frozen_string_literal: true
 
+require 'uffizzi/response_helper'
 require 'uffizzi/clients/api/api_client'
 
 class ClusterService
@@ -104,5 +105,28 @@ class ClusterService
       regex = /\A[a-zA-Z0-9-]*\z/
       regex.match?(name)
     end
+
+    def fetch_cluster_data(cluster_name, server:, project_slug:, oidc_token:)
+      params = {
+        cluster_name: cluster_name,
+        oidc_token: oidc_token,
+      }
+      response = get_cluster(server, project_slug, params)
+
+      if Uffizzi::ResponseHelper.ok?(response)
+        response.dig(:body, :cluster)
+      else
+        Uffizzi::ResponseHelper.handle_failed_response(response)
+      end
+    end
+
+    def build_render_data(cluster_data)
+      {
+        name: cluster_data[:name],
+        status: cluster_data[:state],
+        created: Time.strptime(cluster_data[:created_at], '%Y-%m-%dT%H:%M:%S.%N').strftime('%a %b %d %H:%M:%S %Y'),
+        url: cluster_data[:host],
+      }
+    end
   end
 end

data/lib/uffizzi/services/dev_service.rb

@@ -3,27 +3,70 @@
 require 'uffizzi/clients/api/api_client'
 
 class DevService
+  DEFAULT_REGISTRY_REPO = 'registry.uffizzi.com'
+  STARTUP_STATE = 'startup'
+  CLUSTER_DEPLOYED_STATE = 'cluster_deployed'
+
   class << self
     include ApiClient
 
-    DEFAULT_REGISTRY_REPO = 'registry.uffizzi.com'
+    def check_no_running_process!
+      if process_running?
+        Uffizzi.ui.say_error_and_exit("You have already started uffizzi dev. To stop the process do 'uffizzi dev stop'")
+      end
+    end
 
-    def check_running_daemon
-      return unless File.exist?(pid_path)
+    def check_running_process!
+      unless process_running?
+        Uffizzi.ui.say_error_and_exit('Uffizzi dev is not running')
+      end
+    end
 
-      pid = File.read(pid_path)
-      File.delete(pid_path) if pid.blank?
-      Uffizzi.process.kill(0, pid.to_i)
+    def check_environment_exist!
+      if dev_environment.empty?
+        Uffizzi.ui.say_error_and_exit('Uffizzi dev does not exist')
+      end
+    end
 
-      Uffizzi.ui.say_error_and_exit("You have already started uffizzi dev as daemon. To stop the process do 'uffizzi dev stop'")
+    def stop_process
+      dev_pid = running_pid
+      skaffold_pid = running_skaffold_pid
+
+      begin
+        Uffizzi.process.kill('INT', skaffold_pid)
+      rescue Errno::ESRCH
+      end
+
+      wait_process_stop(skaffold_pid)
+      delete_pid
+
+      Uffizzi.process.kill('INT', dev_pid)
     rescue Errno::ESRCH
-      File.delete(pid_path)
+      delete_pid
+    end
+
+    def wait_process_stop(pid)
+      loop do
+        Uffizzi.process.kill(0, pid)
+        sleep(1)
+      end
+    rescue Errno::ESRCH
+    end
+
+    def process_running?
+      pid = running_pid
+      return false unless pid.positive?
+
+      Uffizzi.process.kill(0, pid.to_i)
+      true
+    rescue Errno::ESRCH
+      false
     end
 
     def start_check_pid_file_existence
-      Thread.new do
+      Uffizzi.thread.new do
         loop do
-          Uffizzi.process.kill('QUIT', Uffizzi.process.pid) unless File.exist?(pid_path)
+          stop_process unless File.exist?(pid_path)
           sleep(1)
         end
       end
@@ -33,7 +76,12 @@ class DevService
       Uffizzi.ui.say('Start skaffold')
       cmd = build_skaffold_dev_command(config_path, options)
 
+      Uffizzi.signal.trap('INT') {}
+
       Uffizzi.ui.popen2e(cmd) do |_stdin, stdout_and_stderr, wait_thr|
+        pid = wait_thr.pid
+        skaffold_pid = find_skaffold_pid(pid)
+        save_skaffold_pid(skaffold_pid)
         stdout_and_stderr.each { |l| Uffizzi.ui.say(l) }
         wait_thr.value
       end
@@ -44,6 +92,10 @@ class DevService
       cmd = build_skaffold_dev_command(config_path, options)
 
       Uffizzi.ui.popen2e(cmd) do |_stdin, stdout_and_stderr, wait_thr|
+        pid = wait_thr.pid
+        skaffold_pid = find_skaffold_pid(pid)
+        save_skaffold_pid(skaffold_pid)
+
         File.open(logs_path, 'a') do |f|
           stdout_and_stderr.each do |line|
             f.puts(line)
@@ -80,6 +132,10 @@ class DevService
       File.join(Uffizzi::ConfigFile::CONFIG_DIR, 'uffizzi_dev.pid')
     end
 
+    def skaffold_pid_path
+      File.join(Uffizzi::ConfigFile::CONFIG_DIR, 'skaffold_dev.pid')
+    end
+
     def logs_path
       File.join(Uffizzi::ConfigFile::CONFIG_DIR, 'uffizzi_dev.log')
     end
@@ -104,5 +160,83 @@ class DevService
 
       File.expand_path(path)
     end
+
+    def running_pid
+      return nil.to_i unless File.exist?(pid_path)
+
+      File.read(pid_path).to_i
+    end
+
+    def save_pid
+      File.write(pid_path, Uffizzi.process.pid)
+    end
+
+    def delete_pid
+      File.delete(pid_path) if File.exist?(pid_path)
+      File.delete(skaffold_pid_path) if File.exist?(skaffold_pid_path)
+    end
+
+    def running_skaffold_pid
+      return nil.to_i unless File.exist?(skaffold_pid_path)
+
+      File.read(skaffold_pid_path).to_i
+    end
+
+    def save_skaffold_pid(pid)
+      File.write(skaffold_pid_path, pid)
+    end
+
+    def set_dev_environment_config(cluster_name, config_path, options)
+      params = options.merge(config_path: File.expand_path(config_path))
+      new_dev_environment = Uffizzi::ConfigHelper.set_dev_environment(cluster_name, params)
+      Uffizzi::ConfigFile.write_option(:dev_environment, new_dev_environment)
+    end
+
+    def set_startup_state
+      new_dev_environment = dev_environment.merge(state: STARTUP_STATE)
+      Uffizzi::ConfigFile.write_option(:dev_environment, new_dev_environment)
+    end
+
+    def set_cluster_deployed_state
+      new_dev_environment = dev_environment.merge(state: CLUSTER_DEPLOYED_STATE)
+      Uffizzi::ConfigFile.write_option(:dev_environment, new_dev_environment)
+    end
+
+    def startup?
+      dev_environment[:state] == STARTUP_STATE
+    end
+
+    def clear_dev_environment_config
+      Uffizzi::ConfigFile.write_option(:dev_environment, {})
+    end
+
+    def dev_environment
+      Uffizzi::ConfigHelper.dev_environment
+    end
+
+    def find_skaffold_pid(pid)
+      pid_regex = /\w*#{pid}.*skaffold dev/
+      io = Uffizzi.ui.popen('ps -ef')
+      processes = io.readlines.select { |l| l.match?(pid_regex) }
+
+      if processes.count.zero?
+        raise StandardError.new('Can\'t find skaffold process pid')
+      end
+
+      # HACK: For MacOS
+      if processes.count == 1
+        current_pid = processes[0].gsub(/\s+/, ' ').lstrip.split[1]
+        return pid if current_pid.to_s == pid.to_s
+
+        raise StandardError.new('Can\'t find skaffold process pid')
+      end
+
+      # HACK: For Linux
+      parent_process = processes
+        .map { |ps| ps.gsub(/\s+/, ' ').lstrip.split }
+        .detect { |ps| ps[2].to_s == pid.to_s }
+
+      parent_process[1]
+    end
   end
 end

data/lib/uffizzi/shell.rb

@@ -11,6 +11,7 @@ module Uffizzi
 
       PRETTY_JSON = 'pretty-json'
       REGULAR_JSON = 'json'
+      PRETTY_LIST = 'pretty-list'
 
       def initialize
         @shell = Thor::Shell::Basic.new
@@ -55,6 +56,10 @@ module Uffizzi
         $stdout.stat.pipe?
       end
 
+      def popen(command)
+        IO.popen(command)
+      end
+
       def popen2e(command, &block)
         Open3.popen2e(command, &block)
       end
@@ -73,12 +78,25 @@ module Uffizzi
         JSON.pretty_generate(data)
       end
 
+      def format_to_pretty_list(data)
+        case data
+        when Array
+          data.map { |v| format_to_pretty_list(v) }.join("\n\n")
+        when Hash
+          data.map { |k, v| "- #{k.to_s.upcase}: #{v}" }.join("\n").strip
+        else
+          data
+        end
+      end
+
       def format_message(message)
         case output_format
         when PRETTY_JSON
           format_to_pretty_json(message)
         when REGULAR_JSON
           format_to_json(message)
+        when PRETTY_LIST
+          format_to_pretty_list(message)
         else
           message
         end

data/lib/uffizzi/version.rb

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

data/lib/uffizzi.rb

@@ -38,7 +38,19 @@ module Uffizzi
     end
 
     def process
-      @process ||= Process
+      Process
+    end
+
+    def signal
+      Signal
+    end
+
+    def thread
+      Thread
+    end
+
+    def at_exit(&block)
+      Kernel.at_exit(&block)
     end
   end
 end

data/man/uffizzi

@@ -33,6 +33,9 @@ GROUP is one of the following:
  project
      Manage Uffizzi project resources including compose files for
      specifying compose environment (preview) configurations and secrets
+
+ dev
+     Creates a Uffizzi cluster preconfigured for development workflows
 .fi
 .SH "COMMAND"
 .nf

data/man/uffizzi-dev-describe

@@ -0,0 +1,36 @@
+.\" generated with Ronn-NG/v0.9.1
+.\" http://github.com/apjanke/ronn-ng/tree/0.9.1
+.TH "UFFIZZI\-DEV\-DESCRIBE" "" "October 2023" ""
+.SH "NAME"
+\fBuffizzi\-dev\-describe\fR
+.P
+$ uffizzi dev describe \-h uffizzi\-dev\-describe \- show metadata for a dev environment ================================================================
+.SH "SYNOPSIS"
+.nf
+uffizzi dev describe <NAME>
+.fi
+.SH "DESCRIPTION"
+.nf
+Shows metadata for a dev environment
+
+This command can fail for the following reasons:
+    \- The dev environment specified does not exist\.
+    \- The dev environment specified belongs to a different project\.
+
+For more information on Uffizzi clusters, see:
+https://docs\.uffizzi\.com/references/cli/
+.fi
+.SH "POSITIONAL ARGUMENTS"
+.nf
+[NAME]
+    NAME for the dev environment you want to describe\.
+    This is an optional argument\.
+.fi
+.SH "EXAMPLES"
+.nf
+The following command prints metadata for the dev
+environment:
+
+    $ uffizzi dev describe
+.fi
+

data/man/uffizzi-dev-describe.ronn

@@ -0,0 +1,27 @@
+$ uffizzi dev describe -h
+uffizzi-dev-describe - show metadata for a dev environment
+================================================================
+
+## SYNOPSIS
+    uffizzi dev describe <NAME>
+
+## DESCRIPTION
+    Shows metadata for a dev environment
+
+    This command can fail for the following reasons:
+        - The dev environment specified does not exist.
+        - The dev environment specified belongs to a different project.
+
+    For more information on Uffizzi clusters, see:
+    https://docs.uffizzi.com/references/cli/
+
+## POSITIONAL ARGUMENTS
+    [NAME]
+        NAME for the dev environment you want to describe.
+        This is an optional argument.
+
+## EXAMPLES
+    The following command prints metadata for the dev
+    environment:
+
+        $ uffizzi dev describe

data/man/uffizzi.ronn

@@ -29,6 +29,9 @@ uffizzi - manage Uffizzi resources
          Manage Uffizzi project resources including compose files for
          specifying compose environment (preview) configurations and secrets
 
+     dev
+         Creates a Uffizzi cluster preconfigured for development workflows
+
 ## COMMAND
     COMMAND is one of the following:
 

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: uffizzi-cli
 version: !ruby/object:Gem::Version
-  version: 2.2.0
+  version: 2.2.2
 platform: ruby
 authors:
 - Josh Thurman
@@ -9,7 +9,7 @@ authors:
 autorequire: 
 bindir: exe
 cert_chain: []
-date: 2023-10-19 00:00:00.000000000 Z
+date: 2023-10-25 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: activesupport
@@ -522,6 +522,8 @@ files:
 - man/uffizzi-connect-ghcr.ronn
 - man/uffizzi-connect.ronn
 - man/uffizzi-dev
+- man/uffizzi-dev-describe
+- man/uffizzi-dev-describe.ronn
 - man/uffizzi-dev-start
 - man/uffizzi-dev-start.ronn
 - man/uffizzi-dev-stop