kdep 0.4.8 → 0.5.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ed0d8de8dfb58cc372615340a068aecb3f8092aecafdbc6d1c6480c14477d57
-  data.tar.gz: 8dde50b29b917321144fcca1d0cb83cff8b66a702442c5bf19375ae527f4cf6e
+  metadata.gz: 6e1f1a30cdbd53c887f8cb3596553d8cadfd8c40a69654e233effb307d405bde
+  data.tar.gz: de0c60773483b9b9203463d807cd61af12a4aacdee78f71c834522ef38538116
 SHA512:
-  metadata.gz: 3669fafcc6315fcdb7af39bb0b31cb7314a953b3185988523af63e1d9ab1fb60a458ba141dc22e3735e00de5df8a821b862b657aaae68d36e8326e0a0f304f2b
-  data.tar.gz: 7cbb7445b6909b46e74f47245c88df5fa8d7d93617a949b14059aef3f50c2981941ed129d70f013dede5e2789ad363e55d8768698129059c412c03d631851b81
+  metadata.gz: 057d0b80e63baaae39146d5045ff33a1a152dcea0809aa27e59bf2e9e1bb08db846ef8146df7ce512b679612c05abf9777abd8c377156bee9cc2615d23000190
+  data.tar.gz: 32378759cf7fec1f2f81f3d4896059fba2383e2c095e500adafeee43be6270a756a1d787ec89a3395ba66127de6e22afbe5dbd1d3d7d0d4de134bf498556f58e

data/lib/kdep/commands/bump.rb

@@ -3,6 +3,10 @@ require "optparse"
 module Kdep
   module Commands
     class Bump
+      DEFAULT_ROLLOUT_TIMEOUT = "5m".freeze
+      # kubectl duration: 90s, 5m, 1h30m
+      DURATION_FORMAT = /\A(\d+(ms|s|m|h))+\z/
+
       def self.option_parser
         OptionParser.new do |opts|
           opts.banner = "Usage: kdep bump [deploy] [env]"
@@ -12,6 +16,8 @@ module Kdep
           opts.on("--skip-apply", "Build and push only, skip render+apply")
           opts.on("--dry-run", "Run full pipeline but skip kubectl apply")
           opts.on("--no-dashboard", "Skip TUI dashboard after deploy")
+          opts.on("--wait", "Wait for the rollout instead of the dashboard; exit 1 if it fails (for scripts/CI)")
+          opts.on("--timeout=DURATION", "Rollout wait timeout with --wait, e.g. 90s, 10m (default: #{DEFAULT_ROLLOUT_TIMEOUT}; 0 = forever)")
           opts.on("--platform=PLATFORM", "Target platform (e.g., linux/amd64)")
           opts.on("--init-state", "Seed state.yml at 0.0 when missing (non-interactive)")
           opts.on("--no-check", "Skip preflight check: validators")
@@ -29,6 +35,14 @@ module Kdep
         deploy_name = @args[0]
         env = @args[1]
 
+        # A malformed duration would only surface in `kubectl rollout status`,
+        # after build, push and apply -- reporting a good deploy as failed.
+        timeout = @command_options[:timeout]
+        if timeout && !(timeout == "0" || timeout.match?(DURATION_FORMAT))
+          @ui.error("--timeout=#{timeout}: expected a duration like 90s, 5m or 1h30m")
+          exit 1
+        end
+
         # Step 1: Discovery + config
         discovery = Kdep::Discovery.new
         kdep_dir = discovery.find_kdep_dir
@@ -58,6 +72,7 @@ module Kdep
         # (context guard, rollout tracking, etc.).
         preset = config["preset"]
         if preset == "helm"
+          @ui.warn("--wait is not supported for helm presets; the rollout is not awaited") if @command_options[:wait]
           run_helm_pipeline(deploy_dir, env)
           return
         elsif preset == "custom" || config["build"] == false
@@ -198,8 +213,13 @@ module Kdep
               # Save new tag to state.yml
               Kdep::State.write(deploy_dir, tag: next_version)
 
-              # Launch TUI dashboard for live monitoring
-              unless @command_options[:"no-dashboard"]
+              # Follow the rollout: --wait blocks on it (scripts/CI), otherwise
+              # the TUI dashboard when there is a terminal to draw it on.
+              if @command_options[:wait]
+                wait_for_rollout(config, deploy_dir, namespace)
+              elsif @command_options[:"no-dashboard"]
+                # explicitly opted out
+              elsif Kdep::Dashboard.interactive?
                 dashboard = Kdep::Dashboard.new(
                   "name" => config["name"],
                   "namespace" => namespace,
@@ -207,6 +227,8 @@ module Kdep
                   "image" => image
                 )
                 dashboard.run
+              else
+                @ui.warn("rollout not awaited -- pass --wait to block until it completes (exit 1 if it fails)")
               end
             end
           end
@@ -222,6 +244,29 @@ module Kdep
 
       private
 
+      def wait_for_rollout(config, deploy_dir, namespace)
+        deploy = File.basename(deploy_dir)
+        resources = Kdep::Workload.preset_resources(config["preset"], deploy_dir)
+        kinds = Kdep::Workload.rollout_kinds(resources)
+
+        if kinds.empty?
+          what = Kdep::Workload.batch_kind(resources) || "no deployment/statefulset/daemonset"
+          @ui.warn("--wait: preset '#{config["preset"]}' declares #{what}; no rollout to wait for")
+          return
+        end
+
+        timeout = @command_options[:timeout] || DEFAULT_ROLLOUT_TIMEOUT
+        kinds.each do |kind|
+          name = Kdep::Workload.name_for(kind, config)
+          @ui.info("waiting for #{kind}/#{name} rollout (timeout #{timeout})...")
+          next if Kdep::Kubectl.rollout_status(kind, name, namespace: namespace, timeout: timeout)
+
+          @ui.error("rollout of #{kind}/#{name} did not complete within #{timeout}. " \
+                    "Check `kdep status #{deploy}` and `kdep log #{deploy}`.")
+          exit 1
+        end
+      end
+
       # Feature E: helm-preset bump = helm-install pipeline. Preflight
       # already ran; context guard runs inside HelmInstall; rollout flush
       # and configmap overlays are internal to it.
@@ -268,6 +313,8 @@ module Kdep
             Kdep::Kubectl.apply(file_path, namespace: namespace)
             @ui.info("applied: #{File.basename(file_path)}")
           end
+
+          wait_for_rollout(config, deploy_dir, namespace) if @command_options[:wait]
         end
       end
 

data/lib/kdep/commands/dashboard.rb

@@ -39,6 +39,13 @@ module Kdep
         # Load config (nil env -- dashboard monitors live state)
         config = Kdep::Config.new(deploy_dir, nil).load
 
+        # Checked before any cluster access: nothing to show without a terminal
+        unless Kdep::Dashboard.interactive?
+          @ui.error("kdep dashboard needs an interactive terminal (stdin and stdout). " \
+                    "From a script, use `kdep status` or `kdep log`.")
+          exit 1
+        end
+
         # Validate context before any cluster operation
         begin
           Kdep::ContextGuard.new(config["context"]).validate!

data/lib/kdep/commands/log.rb

@@ -7,7 +7,7 @@ module Kdep
         OptionParser.new do |opts|
           opts.banner = "Usage: kdep log [deploy]"
           opts.separator ""
-          opts.separator "Streams pod logs with error highlighting."
+          opts.separator "Streams logs from all running pods (prefixed by pod) with error highlighting."
           opts.separator ""
           opts.on("-f", "--[no-]follow", "Follow log output (default: true)")
           opts.on("-c", "--container=NAME", "Container name for multi-container pods")
@@ -50,47 +50,37 @@ module Kdep
           exit 1
         end
 
-        # Find running pod
+        # Count matching pods (fails fast when none is running)
         namespace = config["namespace"]
         app_name = config["name"]
-        pod_name = find_pod(namespace, app_name)
+        pod_count = count_pods(namespace, app_name)
 
-        # Stream logs
-        stream_logs(pod_name, namespace)
+        # Stream logs from every pod matching the app label
+        stream_logs(namespace, app_name, pod_count)
       end
 
       private
 
-      def find_pod(namespace, app_name)
-        data = Kdep::Kubectl.run_json(
-          "get", "pods",
-          "-n", namespace,
-          "-l", "app=#{app_name}",
-          "--field-selector", "status.phase=Running"
-        )
-        pods = data["items"]
+      def count_pods(namespace, app_name)
+        pod_count, running = Kdep::PodLogs.count(namespace, app_name)
 
-        if pods.nil? || pods.empty?
+        if running.zero?
           @ui.error("No running pods found for #{app_name} in #{namespace}")
           exit 1
         end
 
-        pods[0]["metadata"]["name"]
+        pod_count
       end
 
-      def stream_logs(pod_name, namespace)
-        follow = @command_options.fetch(:follow, true)
-        tail = @command_options.fetch(:tail, 100)
-        container = @command_options[:container]
-
-        args = ["kubectl", "logs", pod_name, "-n", namespace]
-        args << "-f" if follow
-        args << "--tail=#{tail}"
-
-        if container
-          args << "-c"
-          args << container
-        end
+      def stream_logs(namespace, app_name, pod_count)
+        args = Kdep::PodLogs.kubectl_args(
+          namespace: namespace,
+          app_name: app_name,
+          pod_count: pod_count,
+          tail: @command_options.fetch(:tail, 100),
+          follow: @command_options.fetch(:follow, true),
+          container: @command_options[:container]
+        )
 
         io = IO.popen(args, "r")
 

data/lib/kdep/commands/restart.rb

@@ -3,9 +3,6 @@ require "optparse"
 module Kdep
   module Commands
     class Restart
-      WORKLOAD_KINDS = %w[deployment statefulset daemonset].freeze
-      NON_RESTARTABLE_KINDS = %w[job cronjob].freeze
-
       def self.option_parser
         OptionParser.new do |opts|
           opts.banner = "Usage: kdep restart [deploy] [--type TYPE]"
@@ -73,10 +70,7 @@ module Kdep
 
       private
 
-      # The preset file lists the resources kdep applies, so the workload kind
-      # is declared there -- deriving it from the preset *name* got every
-      # non-Deployment target wrong (daemonset, statefulset, custom). Reading
-      # the list also handles `custom`, whose resources live in the deploy dir.
+      # Kind comes from the preset's resource list (see Kdep::Workload).
       def determine_resource_type(preset, deploy_dir)
         if @command_options[:type]
           return @command_options[:type]
@@ -86,14 +80,14 @@ module Kdep
       end
 
       def resource_type_for_preset(preset, deploy_dir)
-        resources = preset_resources(preset, deploy_dir)
+        resources = Kdep::Workload.preset_resources(preset, deploy_dir)
 
-        if (kind = resources.find { |r| NON_RESTARTABLE_KINDS.include?(r) })
+        if (kind = Kdep::Workload.batch_kind(resources))
           @ui.error("#{kind} workloads cannot be restarted (use --type to override)")
           exit 1
         end
 
-        found = resources & WORKLOAD_KINDS
+        found = Kdep::Workload.rollout_kinds(resources)
 
         if found.size > 1
           @ui.error("Multiple workloads in preset '#{preset}': #{found.join(', ')}. Use --type to pick one.")
@@ -106,12 +100,6 @@ module Kdep
         found.first || "deployment"
       end
 
-      def preset_resources(preset, deploy_dir)
-        Kdep::Preset.new(preset, deploy_dir).resources
-      rescue StandardError
-        []
-      end
-
       def resolve_deploy_dir(kdep_dir, deploy_name, discovery)
         if deploy_name
           deploy_dir = File.join(kdep_dir, deploy_name)

data/lib/kdep/dashboard.rb

@@ -7,6 +7,7 @@ require "kdep/dashboard/log_panel"
 require "kdep/dashboard/resources_panel"
 require "kdep/dashboard/health_panel"
 require "kdep/kubectl"
+require "kdep/pod_logs"
 
 module Kdep
   class Dashboard
@@ -14,6 +15,13 @@ module Kdep
     PANEL_NAMES = { rollout: "Rollout", logs: "Logs", resources: "Resources", health: "Health" }.freeze
     REFRESH_INTERVAL = 0.25
 
+    # The dashboard reads keys through $stdin.raw and draws on $stdout, so
+    # both must be terminals -- a script with a piped or /dev/null stdin
+    # still has a TTY stdout and used to crash with Errno::ENOTTY.
+    def self.interactive?
+      $stdin.tty? && $stdout.tty?
+    end
+
     def initialize(config)
       @config = config
       @name = config["name"]
@@ -29,8 +37,8 @@ module Kdep
     end
 
     def run
-      unless $stdout.tty?
-        puts "Dashboard skipped: not a TTY"
+      unless self.class.interactive?
+        puts "Dashboard skipped: not an interactive terminal"
         return
       end
 
@@ -152,8 +160,9 @@ module Kdep
     def start_log_thread
       t = Thread.new do
         begin
-          cmd = ["kubectl", "logs", "-n", @namespace, "-l", "app=#{@name}",
-                 "-f", "--tail=50", "--all-containers", "--prefix"]
+          pod_count, _running = PodLogs.count(@namespace, @name)
+          cmd = PodLogs.kubectl_args(namespace: @namespace, app_name: @name, pod_count: pod_count,
+                                     tail: 50, all_containers: true)
           io = IO.popen(cmd, "r", err: [:child, :out])
           @mutex.synchronize { @ios << io }
           while @running && (line = io.gets)

data/lib/kdep/kubectl.rb

@@ -40,6 +40,12 @@ module Kdep
       end
     end
 
+    # Streams kubectl's own progress to the terminal; true when the rollout
+    # completed within the timeout.
+    def self.rollout_status(kind, name, namespace:, timeout:)
+      system("kubectl", "rollout", "status", "#{kind}/#{name}", "-n", namespace, "--timeout=#{timeout}")
+    end
+
     # Declarative rollout-restart helper used by Kdep::RolloutTracker (Feature F).
     def self.rollout_restart(kind, name, namespace:)
       run("rollout", "restart", "#{kind}/#{name}", "-n", namespace)

data/lib/kdep/pod_logs.rb

@@ -0,0 +1,42 @@
+require "kdep/kubectl"
+
+module Kdep
+  # Shared by `kdep log` and the dashboard log panel: both stream every pod
+  # behind the app label instead of picking one.
+  module PodLogs
+    # kubectl refuses to follow more than --max-log-requests streams (default 5)
+    MIN_LOG_REQUESTS = 5
+    # The count and `kubectl logs -l` are two selector lookups. Right after a
+    # bump the ReplicaSet is creating surge pods between them, so a limit equal
+    # to the count gets refused -- leave room for a full surge.
+    SURGE_HEADROOM = 2
+
+    # kubectl logs -l streams every pod the selector matches, whatever its
+    # phase (Completed leftovers, Pending surge pods), so the stream limit
+    # must count all of them. Returns [matching, running].
+    def self.count(namespace, app_name)
+      data = Kdep::Kubectl.run_json("get", "pods", "-n", namespace, "-l", "app=#{app_name}")
+      pods = data["items"] || []
+      running = pods.count { |pod| pod.dig("status", "phase") == "Running" }
+      [pods.length, running]
+    end
+
+    # --ignore-errors keeps one pod still in ContainerCreating from ending
+    # every other stream mid-rollout.
+    def self.kubectl_args(namespace:, app_name:, pod_count:, tail:, follow: true, container: nil, all_containers: false)
+      args = ["kubectl", "logs", "-n", namespace, "-l", "app=#{app_name}", "--prefix", "--ignore-errors"]
+      args << "--max-log-requests=#{[pod_count * SURGE_HEADROOM, MIN_LOG_REQUESTS].max}"
+      args << "-f" if follow
+      args << "--tail=#{tail}"
+
+      if container
+        args << "-c"
+        args << container
+      elsif all_containers
+        args << "--all-containers"
+      end
+
+      args
+    end
+  end
+end

data/lib/kdep/version.rb

@@ -1,3 +1,3 @@
 module Kdep
-  VERSION = "0.4.8"
+  VERSION = "0.5.0"
 end

data/lib/kdep/workload.rb

@@ -0,0 +1,37 @@
+require "kdep/preset"
+
+module Kdep
+  # The preset file lists the resources kdep applies, so the workload kind is
+  # declared there -- deriving it from the preset *name* got every
+  # non-Deployment target wrong (daemonset, statefulset, custom). Reading the
+  # list also handles `custom`, whose resources live in the deploy dir.
+  # Shared by `kdep restart` and `kdep bump --wait`.
+  module Workload
+    KINDS = %w[deployment statefulset daemonset].freeze
+    BATCH_KINDS = %w[job cronjob].freeze
+
+    def self.preset_resources(preset, deploy_dir)
+      Kdep::Preset.new(preset, deploy_dir).resources
+    rescue StandardError
+      []
+    end
+
+    # Workloads that have a rollout (restart / rollout status)
+    def self.rollout_kinds(resources)
+      resources & KINDS
+    end
+
+    # The workload's metadata.name, resolved exactly as the templates do.
+    def self.name_for(kind, config)
+      case kind
+      when "statefulset" then config["statefulset_name"] || config["deployment_name"] || config["name"]
+      when "daemonset"   then config["daemonset_name"] || config["name"]
+      else                    config["deployment_name"] || config["name"]
+      end
+    end
+
+    def self.batch_kind(resources)
+      resources.find { |r| BATCH_KINDS.include?(r) }
+    end
+  end
+end

data/lib/kdep.rb

@@ -5,6 +5,7 @@ require "kdep/yaml_compat"
 require "kdep/defaults"
 require "kdep/config"
 require "kdep/preset"
+require "kdep/workload"
 require "kdep/discovery"
 require "kdep/template_context"
 require "kdep/renderer"
@@ -12,6 +13,7 @@ require "kdep/validator"
 require "kdep/writer"
 require "kdep/old_format"
 require "kdep/kubectl"
+require "kdep/pod_logs"
 require "kdep/context_guard"
 require "kdep/cluster_health"
 require "kdep/docker"

metadata

@@ -1,14 +1,14 @@
 --- !ruby/object:Gem::Specification
 name: kdep
 version: !ruby/object:Gem::Version
-  version: 0.4.8
+  version: 0.5.0
 platform: ruby
 authors:
 - Leadfy
 autorequire:
 bindir: exe
 cert_chain: []
-date: 2026-08-15 00:00:00.000000000 Z
+date: 2026-10-10 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: envspec
@@ -131,6 +131,7 @@ files:
 - lib/kdep/kubectl.rb
 - lib/kdep/old_format.rb
 - lib/kdep/path_resolver.rb
+- lib/kdep/pod_logs.rb
 - lib/kdep/preset.rb
 - lib/kdep/registry.rb
 - lib/kdep/renderer.rb
@@ -143,6 +144,7 @@ files:
 - lib/kdep/validator.rb
 - lib/kdep/version.rb
 - lib/kdep/version_tagger.rb
+- lib/kdep/workload.rb
 - lib/kdep/writer.rb
 - lib/kdep/yaml_compat.rb
 - lib/kdep/yaml_duplicate_keys.rb
@@ -189,7 +191,7 @@ required_rubygems_version: !ruby/object:Gem::Requirement
     - !ruby/object:Gem::Version
       version: '0'
 requirements: []
-rubygems_version: 3.2.32
+rubygems_version: 3.5.19
 signing_key:
 specification_version: 4
 summary: Kubernetes deployment CLI