kubetailrb 0.1.0 → 0.3.0

data/lib/kubetailrb/k8s_pod_reader.rb

@@ -1,83 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'with_k8s_client'
-require_relative 'validated'
-require_relative 'json_formatter'
-
-module Kubetailrb
-  # Read Kubernetes pod logs.
-  class K8sPodReader
-    include Validated
-    include WithK8sClient
-
-    attr_reader :pod_name, :opts
-
-    def initialize(pod_name:, formatter:, opts:, k8s_client: nil)
-      validate(pod_name, formatter, opts)
-
-      @k8s_client = k8s_client
-      @pod_name = pod_name
-      @formatter = formatter
-      @opts = opts
-    end
-
-    def read
-      pod_logs = read_pod_logs
-      unless @opts.follow?
-        print_logs pod_logs
-        return
-      end
-
-      # NOTE: The watch method from kubeclient does not accept `tail_lines`
-      # argument, so I had to resort to some hack... by using the first log to
-      # print out. Not ideal, since it's not really the N last nb lines, and
-      # assume every logs are different, which may not be true.
-      # But it does the job for most cases.
-      first_log_to_display = pod_logs.to_s.split("\n").first
-      should_print_logs = false
-
-      k8s_client.watch_pod_log(@pod_name, @opts.namespace) do |line|
-        # NOTE: Is it good practice to update a variable that is outside of a
-        # block? Can we do better?
-        should_print_logs = true if line == first_log_to_display
-
-        print_logs(line) if should_print_logs
-      end
-    end
-
-    private
-
-    def validate(pod_name, formatter, opts)
-      raise_if_blank pod_name, 'Pod name not set.'
-
-      raise ArgumentError, 'Formatter not set.' if formatter.nil?
-
-      raise ArgumentError, 'Opts not set.' if opts.nil?
-    end
-
-    def print_logs(logs)
-      if logs.to_s.include?("\n")
-        logs.to_s.split("\n").each { |log| print_logs(log) }
-        return
-      end
-
-      if @opts.raw?
-        puts @formatter.format(logs)
-      else
-        puts "#{@pod_name} - #{@formatter.format logs}"
-      end
-      $stdout.flush
-    end
-
-    def read_pod_logs
-      # The pod may still not up/ready, so small hack to retry 120 times (number
-      # taken randomly) until the pod returns its logs.
-      120.times do
-        return k8s_client.get_pod_log(@pod_name, @opts.namespace, tail_lines: @opts.last_nb_lines)
-      rescue Kubeclient::HttpError => e
-        puts e.message
-        sleep 1
-      end
-    end
-  end
-end

data/lib/kubetailrb/k8s_pods_reader.rb

@@ -1,86 +0,0 @@
-# frozen_string_literal: true
-
-require_relative 'k8s_opts'
-require_relative 'k8s_pod_reader'
-require_relative 'with_k8s_client'
-
-module Kubetailrb
-  # Read multiple pod logs.
-  class K8sPodsReader
-    include Validated
-    include WithK8sClient
-
-    attr_reader :pod_query, :opts
-
-    def initialize(pod_query:, formatter:, opts:, k8s_client: nil)
-      validate(pod_query, formatter, opts)
-
-      @k8s_client = k8s_client
-      @pod_query = Regexp.new(pod_query)
-      @formatter = formatter
-      @opts = opts
-    end
-
-    def read
-      pods = find_pods
-      watch_for_new_pod_events if @opts.follow?
-
-      threads = pods.map do |pod|
-        # NOTE: How much memory does a Ruby Thread takes? Can we spawn hundreds
-        # to thoudsands of Threads without issue?
-        Thread.new { create_reader(pod.metadata.name).read }
-      end
-
-      # NOTE: '&:' is a shorthand way of calling 'join' method on each thread.
-      # It's equivalent to: threads.each { |thread| thread.join }
-      threads.each(&:join)
-    end
-
-    private
-
-    def validate(pod_query, formatter, opts)
-      raise_if_blank pod_query, 'Pod query not set.'
-
-      raise ArgumentError, 'Formatter not set.' if formatter.nil?
-
-      raise ArgumentError, 'Opts not set.' if opts.nil?
-    end
-
-    def find_pods
-      k8s_client
-        .get_pods(namespace: @opts.namespace)
-        .select { |pod| applicable?(pod) }
-    end
-
-    def create_reader(pod_name)
-      K8sPodReader.new(
-        k8s_client: k8s_client,
-        pod_name: pod_name,
-        formatter: @formatter,
-        opts: @opts
-      )
-    end
-
-    #
-    # Watch any pod events, and if there's another pod that validates the pod
-    # query, then let's read the pod logs!
-    #
-    def watch_for_new_pod_events
-      k8s_client.watch_pods(namespace: @opts.namespace) do |notice|
-        if new_pod_event?(notice) && applicable?(notice.object)
-          # NOTE: We are in another thread (are we?), so no sense to use
-          # 'Thread.join' here.
-          Thread.new { create_reader(notice.object.metadata.name).read }
-        end
-      end
-    end
-
-    def applicable?(pod)
-      pod.metadata.name.match?(@pod_query)
-    end
-
-    def new_pod_event?(notice)
-      notice.type == 'ADDED' && notice.object.kind == 'Pod'
-    end
-  end
-end

data/lib/kubetailrb/no_op_formatter.rb

@@ -1,10 +0,0 @@
-# frozen_string_literal: true
-
-module Kubetailrb
-  # Formatter that does nothing except return what's given to it.
-  class NoOpFormatter
-    def format(log)
-      log
-    end
-  end
-end

data/lib/kubetailrb/with_k8s_client.rb

@@ -1,25 +0,0 @@
-# frozen_string_literal: true
-
-require 'kubeclient'
-
-module Kubetailrb
-  # Add behavior to get a k8s client by using composition.
-  # NOTE: Is it the idiomatic way? Or shall I use a factory? Or is there a
-  # better way?
-  module WithK8sClient
-    def k8s_client
-      @k8s_client ||= create_k8s_client
-    end
-
-    def create_k8s_client
-      config = Kubeclient::Config.read(ENV['KUBECONFIG'] || "#{ENV["HOME"]}/.kube/config")
-      context = config.context
-      Kubeclient::Client.new(
-        context.api_endpoint,
-        'v1',
-        ssl_options: context.ssl_options,
-        auth_options: context.auth_options
-      )
-    end
-  end
-end