rebase: update kubernetes to 1.30

updating kubernetes to 1.30 release

Signed-off-by: Madhu Rajanna <madhupr007@gmail.com>

vendor/k8s.io/kubernetes/pkg/util/filesystem/util.go

@@ -0,0 +1,27 @@
+/*
+Copyright 2024 The Kubernetes Authors.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package filesystem
+
+import (
+	"path/filepath"
+)
+
+// IsPathClean will replace slashes to Separator (which is OS-specific).
+// This will make sure that all slashes are the same before comparing.
+func IsPathClean(path string) bool {
+	return filepath.ToSlash(filepath.Clean(path)) == filepath.ToSlash(path)
+}

vendor/k8s.io/kubernetes/pkg/util/filesystem/util_unix.go

@@ -22,6 +22,7 @@ package filesystem
 import (
 	"fmt"
 	"os"
+	"path/filepath"
 )
 
 // IsUnixDomainSocket returns whether a given file is a AF_UNIX socket file
@@ -35,3 +36,8 @@ func IsUnixDomainSocket(filePath string) (bool, error) {
 	}
 	return true, nil
 }
+
+// IsAbs is same as filepath.IsAbs on Unix.
+func IsAbs(path string) bool {
+	return filepath.IsAbs(path)
+}

vendor/k8s.io/kubernetes/pkg/util/filesystem/util_windows.go

@@ -23,6 +23,8 @@ import (
 	"fmt"
 	"net"
 	"os"
+	"path/filepath"
+	"strings"
 	"time"
 
 	"k8s.io/apimachinery/pkg/util/wait"
@@ -85,3 +87,13 @@ func IsUnixDomainSocket(filePath string) (bool, error) {
 	}
 	return true, nil
 }
+
+// IsAbs returns whether the given path is absolute or not.
+// On Windows, filepath.IsAbs will not return True for paths prefixed with a slash, even
+// though they can be used as absolute paths (https://docs.microsoft.com/en-us/dotnet/standard/io/file-path-formats).
+//
+// WARN: It isn't safe to use this for API values which will propagate across systems (e.g. REST API values
+// that get validated on Unix, persisted, then consumed by Windows, etc).
+func IsAbs(path string) bool {
+	return filepath.IsAbs(path) || strings.HasPrefix(path, `\`) || strings.HasPrefix(path, `/`)
+}

vendor/k8s.io/kubernetes/pkg/util/filesystem/watcher.go

@@ -17,6 +17,10 @@ limitations under the License.
 package filesystem
 
 import (
+	"context"
+	"fmt"
+	"time"
+
 	"github.com/fsnotify/fsnotify"
 )
 
@@ -87,3 +91,126 @@ func (w *fsnotifyWatcher) Run() {
 		}
 	}()
 }
+
+type watchAddRemover interface {
+	Add(path string) error
+	Remove(path string) error
+}
+type noopWatcher struct{}
+
+func (noopWatcher) Add(path string) error    { return nil }
+func (noopWatcher) Remove(path string) error { return nil }
+
+// WatchUntil watches the specified path for changes and blocks until ctx is canceled.
+// eventHandler() must be non-nil, and pollInterval must be greater than 0.
+// eventHandler() is invoked whenever a change event is observed or pollInterval elapses.
+// errorHandler() is invoked (if non-nil) whenever an error occurs initializing or watching the specified path.
+//
+// If path is a directory, only the directory and immediate children are watched.
+//
+// If path does not exist or cannot be watched, an error is passed to errorHandler() and eventHandler() is called at pollInterval.
+//
+// Multiple observed events may collapse to a single invocation of eventHandler().
+//
+// eventHandler() is invoked immediately after successful initialization of the filesystem watch,
+// in case the path changed concurrent with calling WatchUntil().
+func WatchUntil(ctx context.Context, pollInterval time.Duration, path string, eventHandler func(), errorHandler func(err error)) {
+	if pollInterval <= 0 {
+		panic(fmt.Errorf("pollInterval must be > 0"))
+	}
+	if eventHandler == nil {
+		panic(fmt.Errorf("eventHandler must be non-nil"))
+	}
+	if errorHandler == nil {
+		errorHandler = func(err error) {}
+	}
+
+	// Initialize watcher, fall back to no-op
+	var (
+		eventsCh chan fsnotify.Event
+		errorCh  chan error
+		watcher  watchAddRemover
+	)
+	if w, err := fsnotify.NewWatcher(); err != nil {
+		errorHandler(fmt.Errorf("error creating file watcher, falling back to poll at interval %s: %w", pollInterval, err))
+		watcher = noopWatcher{}
+	} else {
+		watcher = w
+		eventsCh = w.Events
+		errorCh = w.Errors
+		defer func() {
+			_ = w.Close()
+		}()
+	}
+
+	// Initialize background poll
+	t := time.NewTicker(pollInterval)
+	defer t.Stop()
+
+	attemptPeriodicRewatch := false
+
+	// Start watching the path
+	if err := watcher.Add(path); err != nil {
+		errorHandler(err)
+		attemptPeriodicRewatch = true
+	} else {
+		// Invoke handle() at least once after successfully registering the listener,
+		// in case the file changed concurrent with calling WatchUntil.
+		eventHandler()
+	}
+
+	for {
+		select {
+		case <-ctx.Done():
+			return
+
+		case <-t.C:
+			// Prioritize exiting if context is canceled
+			if ctx.Err() != nil {
+				return
+			}
+
+			// Try to re-establish the watcher if we previously got a watch error
+			if attemptPeriodicRewatch {
+				_ = watcher.Remove(path)
+				if err := watcher.Add(path); err != nil {
+					errorHandler(err)
+				} else {
+					attemptPeriodicRewatch = false
+				}
+			}
+
+			// Handle
+			eventHandler()
+
+		case e := <-eventsCh:
+			// Prioritize exiting if context is canceled
+			if ctx.Err() != nil {
+				return
+			}
+
+			// Try to re-establish the watcher for events which dropped the existing watch
+			if e.Name == path && (e.Has(fsnotify.Remove) || e.Has(fsnotify.Rename)) {
+				_ = watcher.Remove(path)
+				if err := watcher.Add(path); err != nil {
+					errorHandler(err)
+					attemptPeriodicRewatch = true
+				}
+			}
+
+			// Handle
+			eventHandler()
+
+		case err := <-errorCh:
+			// Prioritize exiting if context is canceled
+			if ctx.Err() != nil {
+				return
+			}
+
+			// If the error occurs in response to calling watcher.Add, re-adding here could hot-loop.
+			// The periodic poll will attempt to re-establish the watch.
+			errorHandler(err)
+			attemptPeriodicRewatch = true
+		}
+	}
+}