add support for nodes query

Signed-off-by: blublinsky <[email protected]>

Author: blublinsky

pkg/kubernetes/nodes.go

@@ -0,0 +1,149 @@
+package kubernetes
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	v1 "k8s.io/api/core/v1"
+	metav1 "k8s.io/apimachinery/pkg/apis/meta/v1"
+	"k8s.io/apimachinery/pkg/apis/meta/v1/unstructured"
+	"k8s.io/apimachinery/pkg/runtime"
+	"k8s.io/apimachinery/pkg/runtime/schema"
+)
+
+func (k *Kubernetes) ListNodes(ctx context.Context, options ResourceListOptions) (runtime.Unstructured, error) {
+	return k.ResourcesList(ctx, &schema.GroupVersionKind{
+		Group: "", Version: "v1", Kind: "Node",
+	}, "", options)
+}
+
+func (k *Kubernetes) GetNodeAddress(ctx context.Context, name string) ([]interface{}, error) {
+	node, err := k.ResourcesGet(ctx, &schema.GroupVersionKind{
+		Group: "", Version: "v1", Kind: "Node",
+	}, "", name)
+	if err != nil {
+		return nil, err
+	}
+
+	// Extract addresses from node status
+	addresses, found, err := unstructured.NestedSlice(node.Object, "status", "addresses")
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return []interface{}{}, nil
+	}
+
+	return addresses, nil
+}
+
+func (k *Kubernetes) NodeCapacity(ctx context.Context, name string) (map[string]interface{}, error) {
+	node, err := k.ResourcesGet(ctx, &schema.GroupVersionKind{
+		Group: "", Version: "v1", Kind: "Node",
+	}, "", name)
+	if err != nil {
+		return nil, err
+	}
+
+	// Extract capacity from node status
+	capacity, found, err := unstructured.NestedMap(node.Object, "status", "capacity")
+	if err != nil {
+		return nil, err
+	}
+	if !found {
+		return map[string]interface{}{}, nil
+	}
+
+	return capacity, nil
+}
+
+func (k *Kubernetes) NodeLog(ctx context.Context, name string, logPath string, tail int64) (string, error) {
+	// Use the node proxy API to access logs from the kubelet
+	// Common log paths:
+	// - /var/log/kubelet.log - kubelet logs
+	// - /var/log/kube-proxy.log - kube-proxy logs
+	// - /var/log/containers/ - container logs
+
+	if logPath == "" {
+		logPath = "kubelet.log"
+	}
+
+	// Build the URL for the node proxy logs endpoint
+	url := []string{"api", "v1", "nodes", name, "proxy", "logs", logPath}
+
+	// Query parameters for tail
+	params := make(map[string]string)
+	if tail > 0 {
+		params["tailLines"] = fmt.Sprintf("%d", tail)
+	}
+
+	req := k.manager.discoveryClient.RESTClient().
+		Get().
+		AbsPath(url...)
+
+	// Add tail parameter if specified
+	for key, value := range params {
+		req.Param(key, value)
+	}
+
+	result := req.Do(ctx)
+	if result.Error() != nil {
+		return "", fmt.Errorf("failed to get node logs: %w", result.Error())
+	}
+
+	rawData, err := result.Raw()
+	if err != nil {
+		return "", fmt.Errorf("failed to read node log response: %w", err)
+	}
+
+	return string(rawData), nil
+}
+
+func (k *Kubernetes) NodeEvents(ctx context.Context, name string) ([]map[string]any, error) {
+	var eventMap []map[string]any
+
+	// Use field selector to filter events for the specific node
+	raw, err := k.ResourcesList(ctx, &schema.GroupVersionKind{
+		Group: "", Version: "v1", Kind: "Event",
+	}, "", ResourceListOptions{
+		ListOptions: metav1.ListOptions{
+			FieldSelector: fmt.Sprintf("involvedObject.kind=Node,involvedObject.name=%s", name),
+		},
+	})
+	if err != nil {
+		return eventMap, err
+	}
+
+	unstructuredList := raw.(*unstructured.UnstructuredList)
+	if len(unstructuredList.Items) == 0 {
+		return eventMap, nil
+	}
+
+	for _, item := range unstructuredList.Items {
+		event := &v1.Event{}
+		if err = runtime.DefaultUnstructuredConverter.FromUnstructured(item.Object, event); err != nil {
+			return eventMap, err
+		}
+
+		// Determine the most relevant timestamp
+		timestamp := event.EventTime.Time
+		if timestamp.IsZero() && event.Series != nil {
+			timestamp = event.Series.LastObservedTime.Time
+		} else if timestamp.IsZero() && event.Count > 1 {
+			timestamp = event.LastTimestamp.Time
+		} else if timestamp.IsZero() {
+			timestamp = event.FirstTimestamp.Time
+		}
+
+		eventMap = append(eventMap, map[string]any{
+			"Timestamp": timestamp.String(),
+			"Type":      event.Type,
+			"Reason":    event.Reason,
+			"Message":   strings.TrimSpace(event.Message),
+			"Count":     event.Count,
+		})
+	}
+
+	return eventMap, nil
+}