Updates to testsuite according to cnf-testsuite/kubectl_client#17 (#31)

* Update kubectl_client version to v1.0.8

Signed-off-by: Rafal Lal <rafal.lal@tietoevry.com>

Author: rafal-lal

cluster_tools.cr

@@ -35,7 +35,7 @@ module ClusterTools
   end
 
   def self.ensure_namespace_exists!
-    namespaces = KubectlClient::Get.namespaces()
+    namespaces = KubectlClient::Get.resource("namespaces")
     namespace_array = namespaces["items"].as_a 
 
     Log.debug { "ClusterTools ensure_namespace_exists namespace_array: #{namespace_array}" }
@@ -68,72 +68,59 @@ module ClusterTools
 
     KubectlClient::Delete.file("cluster_tools.yml", namespace: self.namespace!)
     #todo make this work with cluster-tools-host-namespace
-    KubectlClient::Get.resource_wait_for_uninstall("Daemonset", "cluster-tools", namespace: self.namespace!)
+    KubectlClient::Wait.resource_wait_for_uninstall("Daemonset", "cluster-tools", namespace: self.namespace!)
   end
 
-  def self.exec(cli : String)
+  def self.exec(cli : String) : KubectlClient::CMDResult
     # todo change to get all pods, schedulable nodes is slow
     pods = KubectlClient::Get.pods_by_nodes(KubectlClient::Get.schedulable_nodes_list)
-    pods = KubectlClient::Get.pods_by_label(pods, "name", "cluster-tools")
+    pods = KubectlClient::Get.pods_by_labels(pods, {"name" => "cluster-tools"})
 
     cluster_tools_pod_name = pods[0].dig?("metadata", "name") if pods[0]?
     Log.info { "cluster_tools_pod_name: #{cluster_tools_pod_name}"}
 
-    cmd = "#{cluster_tools_pod_name} -- #{cli}"
-    KubectlClient.exec(cmd, namespace: self.namespace!)
+    KubectlClient::Utils.exec(cluster_tools_pod_name, cli, namespace: self.namespace!)
   end
 
+  def self.exec_by_node(cli : String, node_name : String) : KubectlClient::CMDResult?
+    Log.info { "exec_by_node: Called with String" }
 
-  def self.exec_by_node_construct_cli(cli : String, node : JSON::Any)
-    pods = KubectlClient::Get.pods_by_nodes([node])
-    # pods = KubectlClient::Get.pods_by_label(pods, "name", "cluster-tools-k8s")
-    pods = KubectlClient::Get.pods_by_label(pods, "name", "cluster-tools")
-
-    cluster_tools_pod_name = pods[0].dig?("metadata", "name") if pods[0]?
-    Log.debug { "cluster_tools_pod_name: #{cluster_tools_pod_name}"}
+    nodes = KubectlClient::Get.resource("nodes")["items"].as_a
 
-    full_cli = "#{cluster_tools_pod_name} -- #{cli}"
-    Log.debug { "ClusterTools exec full cli: #{full_cli}" }
-    return full_cli
-  end
+    node : JSON::Any | Nil
+    node = nodes.find{ |n| n.dig?("metadata", "name") == node_name }
 
-  def self.exec_by_node(cli : String, nodeName : String)
-    Log.info { "exec_by_node: Called with String" }
+    return self.exec_by_node(cli, node) if node
 
-    nodes = KubectlClient::Get.nodes["items"].as_a
+    Log.error { "exec_by_node failed, '#{node_name}' not matched to any existing nodes" }
+    nil
+  end
+  
+  private def self.get_cluster_tools_pod_on_node(node : JSON::Any)
+    pods = KubectlClient::Get.pods_by_nodes([node])
+    pods = KubectlClient::Get.pods_by_labels(pods, {"name" => "cluster-tools"})
 
-    node : JSON::Any | Nil
-    node = nodes.find{ |n| n.dig?("metadata", "name") == nodeName }
+    cluster_tools_pod_name = pods[0].dig?("metadata", "name") if pods[0]?
+    Log.debug { "cluster_tools_pod_name: #{cluster_tools_pod_name}"}
 
-    if node
-      self.exec_by_node(cli, node)
-    else
-      ""
-    end
+    cluster_tools_pod_name
   end
-    
 
-  def self.exec_by_node(cli : String, node : JSON::Any)
+  def self.exec_by_node(cli : String, node : JSON::Any) : KubectlClient::CMDResult
     Log.info { "exec_by_node: Called with JSON" }
-    # todo change to get all pods, schedulable nodes is slow
-
-    # pods_by_nodes internally use KubectlClient::Get.pods which uses --all-namespaces option.
-    # So they do not have to be passed the namespace to perform operations.
-    full_cli = exec_by_node_construct_cli(cli, node)
-    exec = KubectlClient.exec(full_cli, namespace: self.namespace)
+    # 'pods_by_nodes' fetches pods from all namespaces so they
+    # do not have to be passed the namespace to perform operations.
+    pod_name = get_cluster_tools_pod_on_node(node)
+    exec = KubectlClient::Utils.exec(pod_name, cli, namespace: self.namespace)
     Log.debug { "ClusterTools exec: #{exec}" }
     exec
   end
 
-  def self.exec_by_node_bg(cli : String, node : JSON::Any)
-    # todo change to get all pods, schedulable nodes is slow
-
-    # pods_by_nodes internally use KubectlClient::Get.pods which uses --all-namespaces option.
-    # So they do not have to be passed the namespace to perform operations.
-    
-    full_cli = exec_by_node_construct_cli(cli, node)
-    Log.debug { "ClusterTools exec full cli: #{full_cli}" }
-    exec = KubectlClient.exec_bg(full_cli, namespace: self.namespace)
+  def self.exec_by_node_bg(cli : String, node : JSON::Any) : KubectlClient::BackgroundCMDResult
+    # 'pods_by_nodes' fetches pods from all namespaces so they
+    # do not have to be passed the namespace to perform operations.
+    pod_name = get_cluster_tools_pod_on_node(node)
+    exec = KubectlClient::Utils.exec_bg(pod_name, cli, namespace: self.namespace)
     Log.debug { "ClusterTools exec: #{exec}" }
     exec
   end
@@ -152,13 +139,13 @@ module ClusterTools
     Log.info {"node_pid_by_container_id container_id: #{container_id}" }
     short_container_id = parse_container_id(container_id)
     inspect = ClusterTools.exec_by_node("crictl inspect #{short_container_id}", node)
-    Log.debug {"node_pid_by_container_id inspect: #{inspect[:output]}" }
-    if inspect[:status].success?
-      pid = "#{JSON.parse(inspect[:output]).dig?("info", "pid")}"
-    else
+    unless inspect[:status].success?
       Log.error {"container_id not found for: #{container_id}" }
-      pid = nil
+      return nil
     end
+
+    Log.debug {"node_pid_by_container_id inspect: #{inspect[:output]}" }
+    pid = "#{JSON.parse(inspect[:output]).dig?("info", "pid")}"
     Log.info {"node_pid_by_container_id pid: #{pid}" }
     pid 
   end
@@ -168,7 +155,7 @@ module ClusterTools
 		case kind
 		when  "deployment","statefulset","pod","replicaset", "daemonset"
 			resource_yaml = KubectlClient::Get.resource(resource[:kind], resource[:name], resource[:namespace])
-			pods = KubectlClient::Get.pods_by_resource(resource_yaml, resource[:namespace])
+			pods = KubectlClient::Get.pods_by_resource_labels(resource_yaml, resource[:namespace])
 			pid_log_names  = [] of String
 			pod_resp = pods.map do |pod|
 				pod_name = pod.dig("metadata", "name")
@@ -211,10 +198,17 @@ module ClusterTools
 						node_name = node.dig("metadata", "name").as_s
 						Log.info { "node name : #{node_name}" }
 						if only_container_pids 
-                                                  pids = KernelIntrospection::K8s::Node.pids_by_container(container_id, node)
-                                                else
-                                                  pids = KernelIntrospection::K8s::Node.pids(node)
-                                                end
+              pids = KernelIntrospection::K8s::Node.pids_by_container(container_id, node)
+            else
+              pids = KernelIntrospection::K8s::Node.pids(node)
+            end
+
+            if pids.empty?
+              Log.info { "pids empty #{pids}" }
+              false
+              next
+            end
+
 						Log.info { "parsed pids: #{pids}" }
 						proc_statuses = KernelIntrospection::K8s::Node.all_statuses_by_pids(pids, node)
 
@@ -237,8 +231,7 @@ module ClusterTools
 
   def self.wait_for_cluster_tools
     Log.info { "ClusterTools wait_for_cluster_tools" }
-    KubectlClient::Get.resource_wait_for_install("Daemonset", "cluster-tools", namespace: self.namespace!, wait_count: 300)
-    # KubectlClient::Get.resource_wait_for_install("Daemonset", "cluster-tools-k8s", namespace: self.namespace)
+    KubectlClient::Wait.resource_wait_for_install("Daemonset", "cluster-tools", namespace: self.namespace!, wait_count: 300)
   end
 
   # https://windsock.io/explaining-docker-image-ids/
@@ -264,33 +257,56 @@ module ClusterTools
     JSON.parse(%({}))
   end
 
-  def self.local_match_by_image_name(image_names : Array(String), nodes=KubectlClient::Get.nodes["items"].as_a )
+  def self.local_match_by_image_name(image_names : Array(String), nodes=KubectlClient::Get.resource("nodes")["items"].as_a )
     image_names.map{|x| local_match_by_image_name(x, nodes)}.flatten.find{|m|m[:found]==true}
   end
-  def self.local_match_by_image_name(image_name, nodes=KubectlClient::Get.nodes["items"].as_a )
+  def self.local_match_by_image_name(image_name, nodes=KubectlClient::Get.resource("nodes")["items"].as_a )
     Log.info { "local_match_by_image_name image_name: #{image_name}" }
     nodes = KubectlClient::Get.nodes["items"].as_a
     local_match_by_image_name(image_name, nodes)
   end
 
+  # TODO (rafal-lal): add spec for it
   def self.local_match_by_image_name(image_name, nodes : Array(JSON::Any))
     Log.info { "local_match_by_image_name image_name: #{image_name}" }
 
     match = Hash{:found => false, :digest => "", :release_name => ""}
-    #todo get name of pod and match against one pod instead of getting all pods and matching them
-    tag = KubectlClient::Get.container_tag_from_image_by_nodes(image_name, nodes)
+    # Group all imageIDs on passed 'nodes' into array.
+    # If 'image_name' matches the name with tag, save its first occurence.
+    # node.status.images is in following format:
+    #  {
+    #  "names": [
+    #    "registry.k8s.io/kube-state-metrics/kube-state-metrics@sha256:37d84129932.......",
+    #    "registry.k8s.io/kube-state-metrics/kube-state-metrics:v2.14.0"
+    #  ],
+    #  "sizeBytes": 51212837
+    #  }
+    tag = ""
+    imageIDs = [] of String
+    nodes.each do |node|
+      begin
+        images = node.dig("status", "images").as_a.each do |image|
+          image.dig("names").as_a.each do |name|
+            if name.as_s.includes?("sha256")
+              imageIDs << name.as_s
+            else
+              next unless name.as_s.includes?(image_name)
+              tag = DockerClient.parse_image(name.as_s)["tag"] if tag.empty?
+            end
+          end
+        end
+      rescue
+        next
+      end
+    end
 
-    if tag
+    if !tag.empty?
       Log.info { "container tag: #{tag}" }
-
-      pods = KubectlClient::Get.pods_by_nodes(nodes)
-
-      #todo container_digests_by_pod (use pod from previous image search) --- performance enhancement
-      imageids = KubectlClient::Get.container_digests_by_nodes(nodes)
-      resp = ClusterTools.official_content_digest_by_image_name(image_name + ":" + tag )
+  
+      resp = ClusterTools.official_content_digest_by_image_name(image_name + ":" + tag)
       sha_list = [{"name" => image_name, "manifest_digest" => resp["Digest"].as_s}]
       Log.info { "jaeger_pods sha_list : #{sha_list}"}
-      match = DockerClient::K8s.local_digest_match(sha_list, imageids)
+      match = DockerClient::K8s.local_digest_match(sha_list, imageIDs)
       Log.info { "local_match_by_image_name match : #{match}"}
     else
       Log.info { "local_match_by_image_name tag: #{tag} match : #{match}"}
@@ -299,14 +315,14 @@ module ClusterTools
     Log.info { "local_match_by_image_name match: #{match}" }
     match
   end
-
+  
   def self.pod_name()
-    KubectlClient::Get.pod_status("cluster-tools", namespace: self.namespace!).split(",")[0]
+    KubectlClient::Get.match_pods_by_prefix("cluster-tools", namespace: self.namespace!).first?
   end
 
   def self.pod_by_node(node)
     resource = KubectlClient::Get.resource("Daemonset", "cluster-tools", namespace: self.namespace!)
-    pods = KubectlClient::Get.pods_by_resource(resource, namespace: self.namespace!)
+    pods = KubectlClient::Get.pods_by_resource_labels(resource, namespace: self.namespace!)
     cluster_pod = pods.find do |pod|
       pod.dig("spec", "nodeName") == node
     end

shard.lock

@@ -6,7 +6,7 @@ shards:
 
   kubectl_client:
     git: https://github.com/cnf-testsuite/kubectl_client.git
-    version: 1.0.1
+    version: 1.0.8
 
   popcorn:
     git: https://github.com/icyleaf/popcorn.git

shard.yml

@@ -15,7 +15,7 @@ crystal: '>= 1.0.0'
 dependencies:
   kubectl_client:
     github: cnf-testsuite/kubectl_client
-    version: '~> 1.0.0'
+    version: '~> 1.0.8'
   docker_client:
     github: cnf-testsuite/docker_client
     version: '~> 1.0.0'

spec/cluster_tools_spec.cr

@@ -5,29 +5,29 @@ require "../cluster_tools.cr"
 describe "ClusterTools" do
   before_all do
     begin
-      is_namespace_created =  KubectlClient::Create.namespace(ClusterTools.namespace)
-      (is_namespace_created).should be_true
+      KubectlClient::Apply.namespace(ClusterTools.namespace)
       Log.info { "#{ClusterTools.namespace} namespace created" }
-    rescue e : KubectlClient::Create::AlreadyExistsError
+    rescue e : KubectlClient::ShellCMD::AlreadyExistsError
       Log.info { "#{ClusterTools.namespace} namespace already exists on the Kubernetes cluster" }
     end
   end
   after_all do
     ClusterTools.uninstall
   end
+
   describe "pre install" do
     it "ensure_namespace_exists!" do
       (ClusterTools.ensure_namespace_exists!).should be_true
 
-      KubectlClient::Delete.command("namespace #{ClusterTools.namespace}")
+      KubectlClient::Delete.resource("namespace", "#{ClusterTools.namespace}")
 
       expect_raises(ClusterTools::NamespaceDoesNotExistException, "ClusterTools Namespace #{ClusterTools.namespace} does not exist") do
         ClusterTools.ensure_namespace_exists!
       end
     end
 
     it "install" do
-      KubectlClient::Create.namespace(ClusterTools.namespace)
+      KubectlClient::Apply.namespace(ClusterTools.namespace)
 
       (ClusterTools.install).should be_true
 
@@ -39,14 +39,12 @@ describe "ClusterTools" do
     before_all do
       ClusterTools.install
     end
-    it "ensure_namespace_exists!",  do
+    it "ensure_namespace_exists!" do
       (ClusterTools.ensure_namespace_exists!).should be_true
     end
 
-    it "pod_name",  do
+    it "pod_name" do
       (/cluster-tools/ =~ ClusterTools.pod_name).should_not be_nil
     end
   end
-
 end
-