From 4625908a6405f7a226ce53430df33fdc67b7f9e2 Mon Sep 17 00:00:00 2001 From: HirazawaUi <695097494plus@gmail.com> Date: Sun, 6 Jul 2025 15:58:06 +0800 Subject: [PATCH] remove unused file --- .../configfiles/configfiles_test.go | 23 +- pkg/kubelet/kubeletconfig/util/files/files.go | 229 --------- .../kubeletconfig/util/files/files_test.go | 478 ------------------ .../util/files/files_unix_test.go | 25 - .../util/files/files_windows_test.go | 25 - 5 files changed, 18 insertions(+), 762 deletions(-) delete mode 100644 pkg/kubelet/kubeletconfig/util/files/files.go delete mode 100644 pkg/kubelet/kubeletconfig/util/files/files_test.go delete mode 100644 pkg/kubelet/kubeletconfig/util/files/files_unix_test.go delete mode 100644 pkg/kubelet/kubeletconfig/util/files/files_windows_test.go diff --git a/pkg/kubelet/kubeletconfig/configfiles/configfiles_test.go b/pkg/kubelet/kubeletconfig/configfiles/configfiles_test.go index fe9bba43c4a..5e3763e128d 100644 --- a/pkg/kubelet/kubeletconfig/configfiles/configfiles_test.go +++ b/pkg/kubelet/kubeletconfig/configfiles/configfiles_test.go @@ -28,7 +28,6 @@ import ( kubeletconfigv1beta1 "k8s.io/kubelet/config/v1beta1" kubeletconfig "k8s.io/kubernetes/pkg/kubelet/apis/config" kubeletscheme "k8s.io/kubernetes/pkg/kubelet/apis/config/scheme" - utilfiles "k8s.io/kubernetes/pkg/kubelet/kubeletconfig/util/files" utiltest "k8s.io/kubernetes/pkg/kubelet/kubeletconfig/util/test" utilfs "k8s.io/kubernetes/pkg/util/filesystem" ) @@ -229,11 +228,25 @@ func newString(s string) *string { return &s } -func addFile(fs utilfs.Filesystem, path string, file string) error { - if err := utilfiles.EnsureDir(fs, filepath.Dir(path)); err != nil { - return err +func addFile(fs utilfs.Filesystem, path string, fileContent string) error { + dir := filepath.Dir(path) + tmpFile, err := fs.TempFile(dir, "tmp_"+filepath.Base(path)) + if err != nil { + return fmt.Errorf("failed to create temp file: %w", err) } - return utilfiles.ReplaceFile(fs, path, []byte(file)) + tmpPath := tmpFile.Name() + + if _, err = tmpFile.Write([]byte(fileContent)); err != nil { + _ = tmpFile.Close() + _ = fs.Remove(tmpPath) + return fmt.Errorf("failed to write to temp file: %w", err) + } + if err = tmpFile.Close(); err != nil { + _ = fs.Remove(tmpPath) + return fmt.Errorf("failed to close temp file: %w", err) + } + + return fs.Rename(tmpPath, path) } func newConfig(t *testing.T) *kubeletconfig.KubeletConfiguration { diff --git a/pkg/kubelet/kubeletconfig/util/files/files.go b/pkg/kubelet/kubeletconfig/util/files/files.go deleted file mode 100644 index 5641002532a..00000000000 --- a/pkg/kubelet/kubeletconfig/util/files/files.go +++ /dev/null @@ -1,229 +0,0 @@ -/* -Copyright 2017 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 files - -import ( - "fmt" - "os" - "path/filepath" - - utilfs "k8s.io/kubernetes/pkg/util/filesystem" -) - -const ( - defaultPerm = 0755 - tmpTag = "tmp_" // additional prefix to prevent accidental collisions -) - -// FileExists returns true if a regular file exists at `path`, false if `path` does not exist, otherwise an error -func FileExists(fs utilfs.Filesystem, path string) (bool, error) { - if info, err := fs.Stat(path); err == nil { - if info.Mode().IsRegular() { - return true, nil - } - return false, fmt.Errorf("expected regular file at %q, but mode is %q", path, info.Mode().String()) - } else if os.IsNotExist(err) { - return false, nil - } else { - return false, err - } -} - -// EnsureFile ensures that a regular file exists at `path`, and if it must create the file any -// necessary parent directories will also be created and the new file will be empty. -func EnsureFile(fs utilfs.Filesystem, path string) error { - // if file exists, don't change it, but do report any unexpected errors - if ok, err := FileExists(fs, path); ok || err != nil { - return err - } // Assert: file does not exist - - // create any necessary parents - err := fs.MkdirAll(filepath.Dir(path), defaultPerm) - if err != nil { - return err - } - - // create the file - file, err := fs.Create(path) - if err != nil { - return err - } - // close the file, since we don't intend to use it yet - return file.Close() -} - -// WriteTmpFile creates a temporary file at `path`, writes `data` into it, and fsyncs the file -// Expects the parent directory to exist. -func WriteTmpFile(fs utilfs.Filesystem, path string, data []byte) (tmpPath string, retErr error) { - dir := filepath.Dir(path) - prefix := tmpTag + filepath.Base(path) - - // create the tmp file - tmpFile, err := fs.TempFile(dir, prefix) - if err != nil { - return "", err - } - defer func() { - // close the file, return the close error only if there haven't been any other errors - if err := tmpFile.Close(); retErr == nil { - retErr = err - } - // if there was an error writing, syncing, or closing, delete the temporary file and return the error - if retErr != nil { - if err := fs.Remove(tmpPath); err != nil { - retErr = fmt.Errorf("attempted to remove temporary file %q after error %v, but failed due to error: %v", tmpPath, retErr, err) - } - tmpPath = "" - } - }() - - // Name() will be an absolute path when using utilfs.DefaultFS, because os.CreateTemp passes - // an absolute path to os.Open, and we ensure similar behavior in utilfs.FakeFS for testing. - tmpPath = tmpFile.Name() - - // write data - if _, err := tmpFile.Write(data); err != nil { - return tmpPath, err - } - // sync file, to ensure it's written in case a hard reset happens - return tmpPath, tmpFile.Sync() -} - -// ReplaceFile replaces the contents of the file at `path` with `data` by writing to a tmp file in the same -// dir as `path` and renaming the tmp file over `path`. The file does not have to exist to use ReplaceFile, -// but the parent directory must exist. -// Note ReplaceFile calls fsync. -func ReplaceFile(fs utilfs.Filesystem, path string, data []byte) error { - // write data to a temporary file - tmpPath, err := WriteTmpFile(fs, path, data) - if err != nil { - return err - } - // rename over existing file - return fs.Rename(tmpPath, path) -} - -// DirExists returns true if a directory exists at `path`, false if `path` does not exist, otherwise an error -func DirExists(fs utilfs.Filesystem, path string) (bool, error) { - if info, err := fs.Stat(path); err == nil { - if info.IsDir() { - return true, nil - } - return false, fmt.Errorf("expected dir at %q, but mode is %q", path, info.Mode().String()) - } else if os.IsNotExist(err) { - return false, nil - } else { - return false, err - } -} - -// EnsureDir ensures that a directory exists at `path`, and if it must create the directory any -// necessary parent directories will also be created and the new directory will be empty. -func EnsureDir(fs utilfs.Filesystem, path string) error { - // if dir exists, don't change it, but do report any unexpected errors - if ok, err := DirExists(fs, path); ok || err != nil { - return err - } // Assert: dir does not exist - - // create the dir - return fs.MkdirAll(path, defaultPerm) -} - -// WriteTempDir creates a temporary dir at `path`, writes `files` into it, and fsyncs all the files -// The keys of `files` represent file names. These names must not: -// - be empty -// - be a path that contains more than the base name of a file (e.g. foo/bar is invalid, as is /bar) -// - match `.` or `..` exactly -// - be longer than 255 characters -// The above validation rules are based on atomic_writer.go, though in this case are more restrictive -// because we only allow a flat hierarchy. -func WriteTempDir(fs utilfs.Filesystem, path string, files map[string]string) (tmpPath string, retErr error) { - // validate the filename keys; for now we only allow a flat keyset - for name := range files { - // invalidate empty names - if name == "" { - return "", fmt.Errorf("invalid file key: must not be empty: %q", name) - } - // invalidate: foo/bar and /bar - if name != filepath.Base(name) { - return "", fmt.Errorf("invalid file key %q, only base names are allowed", name) - } - // invalidate `.` and `..` - if name == "." || name == ".." { - return "", fmt.Errorf("invalid file key, may not be '.' or '..'") - } - // invalidate length > 255 characters - if len(name) > 255 { - return "", fmt.Errorf("invalid file key %q, must be less than 255 characters", name) - } - } - - // write the temp directory in parent dir and return path to the tmp directory - dir := filepath.Dir(path) - prefix := tmpTag + filepath.Base(path) - - // create the tmp dir - var err error - tmpPath, err = fs.TempDir(dir, prefix) - if err != nil { - return "", err - } - // be sure to clean up if there was an error - defer func() { - if retErr != nil { - if err := fs.RemoveAll(tmpPath); err != nil { - retErr = fmt.Errorf("attempted to remove temporary directory %q after error %v, but failed due to error: %v", tmpPath, retErr, err) - } - } - }() - // write data - for name, data := range files { - // create the file - file, err := fs.Create(filepath.Join(tmpPath, name)) - if err != nil { - return tmpPath, err - } - // be sure to close the file when we're done - defer func() { - // close the file when we're done, don't overwrite primary retErr if close fails - if err := file.Close(); retErr == nil { - retErr = err - } - }() - // write the file - if _, err := file.Write([]byte(data)); err != nil { - return tmpPath, err - } - // sync the file, to ensure it's written in case a hard reset happens - if err := file.Sync(); err != nil { - return tmpPath, err - } - } - return tmpPath, nil -} - -// ReplaceDir replaces the contents of the dir at `path` with `files` by writing to a tmp dir in the same -// dir as `path` and renaming the tmp dir over `path`. The dir does not have to exist to use ReplaceDir. -func ReplaceDir(fs utilfs.Filesystem, path string, files map[string]string) error { - // write data to a temporary directory - tmpPath, err := WriteTempDir(fs, path, files) - if err != nil { - return err - } - // rename over target directory - return fs.Rename(tmpPath, path) -} diff --git a/pkg/kubelet/kubeletconfig/util/files/files_test.go b/pkg/kubelet/kubeletconfig/util/files/files_test.go deleted file mode 100644 index 20d91349f99..00000000000 --- a/pkg/kubelet/kubeletconfig/util/files/files_test.go +++ /dev/null @@ -1,478 +0,0 @@ -/* -Copyright 2018 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 files - -import ( - "fmt" - "os" - "path/filepath" - "testing" - - utiltest "k8s.io/kubernetes/pkg/kubelet/kubeletconfig/util/test" - utilfs "k8s.io/kubernetes/pkg/util/filesystem" -) - -const ( - prefix = "test-util-files" -) - -type file struct { - name string - // mode distinguishes file type, - // we only check for regular vs. directory in these tests, - // specify regular as 0, directory as os.ModeDir - mode os.FileMode - data string // ignored if mode == os.ModeDir -} - -func (f *file) write(fs utilfs.Filesystem, dir string) error { - path := filepath.Join(dir, f.name) - if f.mode.IsDir() { - if err := fs.MkdirAll(path, defaultPerm); err != nil { - return err - } - } else if f.mode.IsRegular() { - // create parent directories, if necessary - parents := filepath.Dir(path) - if err := fs.MkdirAll(parents, defaultPerm); err != nil { - return err - } - // create the file - handle, err := fs.Create(path) - if err != nil { - return err - } - _, err = handle.Write([]byte(f.data)) - // The file should always be closed, not just in error cases. - if cerr := handle.Close(); cerr != nil { - return fmt.Errorf("error closing file: %v", cerr) - } - if err != nil { - return err - } - } else { - return fmt.Errorf("mode not implemented for testing %s", f.mode.String()) - } - return nil -} - -func (f *file) expect(fs utilfs.Filesystem, dir string) error { - path := filepath.Join(dir, f.name) - if f.mode.IsDir() { - info, err := fs.Stat(path) - if err != nil { - return err - } - if !info.IsDir() { - return fmt.Errorf("expected directory, got mode %s", info.Mode().String()) - } - } else if f.mode.IsRegular() { - info, err := fs.Stat(path) - if err != nil { - return err - } - if !info.Mode().IsRegular() { - return fmt.Errorf("expected regular file, got mode %s", info.Mode().String()) - } - data, err := fs.ReadFile(path) - if err != nil { - return err - } - if f.data != string(data) { - return fmt.Errorf("expected file data %q, got %q", f.data, string(data)) - } - } else { - return fmt.Errorf("mode not implemented for testing %s", f.mode.String()) - } - return nil -} - -// write files, perform some function, then attempt to read files back -// if err is non-empty, expects an error from the function performed in the test -// and skips reading back the expected files -type test struct { - desc string - writes []file - expects []file - fn func(fs utilfs.Filesystem, dir string, c *test) []error - err string -} - -func (c *test) write(t *testing.T, fs utilfs.Filesystem, dir string) { - for _, f := range c.writes { - if err := f.write(fs, dir); err != nil { - t.Fatalf("error pre-writing file: %v", err) - } - } -} - -// you can optionally skip calling t.Errorf by passing a nil t, and process the -// returned errors instead -func (c *test) expect(t *testing.T, fs utilfs.Filesystem, dir string) []error { - errs := []error{} - for _, f := range c.expects { - if err := f.expect(fs, dir); err != nil { - msg := fmt.Errorf("expect %#v, got error: %v", f, err) - errs = append(errs, msg) - if t != nil { - t.Errorf("%s", msg) - } - } - } - return errs -} - -// run a test case, with an arbitrary function to execute between write and expect -// if c.fn is nil, errors from c.expect are checked against c.err, instead of errors -// from fn being checked against c.err -func (c *test) run(t *testing.T, fs utilfs.Filesystem) { - // isolate each test case in a new temporary directory - dir, err := fs.TempDir("", prefix) - if err != nil { - t.Fatalf("error creating temporary directory for test: %v", err) - } - defer os.RemoveAll(dir) - c.write(t, fs, dir) - // if fn exists, check errors from fn, then check expected files - if c.fn != nil { - errs := c.fn(fs, dir, c) - if len(errs) > 0 { - for _, err := range errs { - utiltest.ExpectError(t, err, c.err) - } - // skip checking expected files if we expected errors - // (usually means we didn't create file) - return - } - c.expect(t, fs, dir) - return - } - // just check expected files, and compare errors from c.expect to c.err - // (this lets us test the helper functions above) - errs := c.expect(nil, fs, dir) - for _, err := range errs { - utiltest.ExpectError(t, err, c.err) - } -} - -// simple test of the above helper functions -func TestHelpers(t *testing.T) { - // omitting the test.fn means test.err is compared to errors from test.expect - cases := []test{ - { - desc: "regular file", - writes: []file{{name: "foo", data: "bar"}}, - expects: []file{{name: "foo", data: "bar"}}, - }, - { - desc: "directory", - writes: []file{{name: "foo", mode: os.ModeDir}}, - expects: []file{{name: "foo", mode: os.ModeDir}}, - }, - { - desc: "deep regular file", - writes: []file{{name: "foo/bar", data: "baz"}}, - expects: []file{{name: "foo/bar", data: "baz"}}, - }, - { - desc: "deep directory", - writes: []file{{name: "foo/bar", mode: os.ModeDir}}, - expects: []file{{name: "foo/bar", mode: os.ModeDir}}, - }, - { - desc: "missing file", - expects: []file{{name: "foo", data: "bar"}}, - err: missingFileError, - }, - { - desc: "missing directory", - expects: []file{{name: "foo/bar", mode: os.ModeDir}}, - err: missingFolderError, - }, - } - for _, c := range cases { - t.Run(c.desc, func(t *testing.T) { - c.run(t, &utilfs.DefaultFs{}) - }) - } -} - -func TestFileExists(t *testing.T) { - fn := func(fs utilfs.Filesystem, dir string, c *test) []error { - ok, err := FileExists(fs, filepath.Join(dir, "foo")) - if err != nil { - return []error{err} - } - if !ok { - return []error{fmt.Errorf("does not exist (test)")} - } - return nil - } - cases := []test{ - { - fn: fn, - desc: "file exists", - writes: []file{{name: "foo"}}, - }, - { - fn: fn, - desc: "file does not exist", - err: "does not exist (test)", - }, - { - fn: fn, - desc: "object has non-file mode", - writes: []file{{name: "foo", mode: os.ModeDir}}, - err: "expected regular file", - }, - } - for _, c := range cases { - t.Run(c.desc, func(t *testing.T) { - c.run(t, &utilfs.DefaultFs{}) - }) - } -} - -func TestEnsureFile(t *testing.T) { - fn := func(fs utilfs.Filesystem, dir string, c *test) []error { - var errs []error - for _, f := range c.expects { - if err := EnsureFile(fs, filepath.Join(dir, f.name)); err != nil { - errs = append(errs, err) - } - } - return errs - } - cases := []test{ - { - fn: fn, - desc: "file exists", - writes: []file{{name: "foo"}}, - expects: []file{{name: "foo"}}, - }, - { - fn: fn, - desc: "file does not exist", - expects: []file{{name: "bar"}}, - }, - { - fn: fn, - desc: "neither parent nor file exists", - expects: []file{{name: "baz/quux"}}, - }, - } - for _, c := range cases { - t.Run(c.desc, func(t *testing.T) { - c.run(t, &utilfs.DefaultFs{}) - }) - } -} - -// Note: This transitively tests WriteTmpFile -func TestReplaceFile(t *testing.T) { - fn := func(fs utilfs.Filesystem, dir string, c *test) []error { - var errs []error - for _, f := range c.expects { - if err := ReplaceFile(fs, filepath.Join(dir, f.name), []byte(f.data)); err != nil { - errs = append(errs, err) - } - } - return errs - } - cases := []test{ - { - fn: fn, - desc: "file exists", - writes: []file{{name: "foo"}}, - expects: []file{{name: "foo", data: "bar"}}, - }, - { - fn: fn, - desc: "file does not exist", - expects: []file{{name: "foo", data: "bar"}}, - }, - { - fn: func(fs utilfs.Filesystem, dir string, c *test) []error { - if err := ReplaceFile(fs, filepath.Join(dir, "foo/bar"), []byte("")); err != nil { - return []error{err} - } - return nil - }, - desc: "neither parent nor file exists", - err: missingFolderError, - }, - } - for _, c := range cases { - t.Run(c.desc, func(t *testing.T) { - c.run(t, &utilfs.DefaultFs{}) - }) - } -} - -func TestDirExists(t *testing.T) { - fn := func(fs utilfs.Filesystem, dir string, c *test) []error { - ok, err := DirExists(fs, filepath.Join(dir, "foo")) - if err != nil { - return []error{err} - } - if !ok { - return []error{fmt.Errorf("does not exist (test)")} - } - return nil - } - cases := []test{ - { - fn: fn, - desc: "dir exists", - writes: []file{{name: "foo", mode: os.ModeDir}}, - }, - { - fn: fn, - desc: "dir does not exist", - err: "does not exist (test)", - }, - { - fn: fn, - desc: "object has non-dir mode", - writes: []file{{name: "foo"}}, - err: "expected dir", - }, - } - for _, c := range cases { - t.Run(c.desc, func(t *testing.T) { - c.run(t, &utilfs.DefaultFs{}) - }) - } -} - -func TestEnsureDir(t *testing.T) { - fn := func(fs utilfs.Filesystem, dir string, c *test) []error { - var errs []error - for _, f := range c.expects { - if err := EnsureDir(fs, filepath.Join(dir, f.name)); err != nil { - errs = append(errs, err) - } - } - return errs - } - cases := []test{ - { - fn: fn, - desc: "dir exists", - writes: []file{{name: "foo", mode: os.ModeDir}}, - expects: []file{{name: "foo", mode: os.ModeDir}}, - }, - { - fn: fn, - desc: "dir does not exist", - expects: []file{{name: "bar", mode: os.ModeDir}}, - }, - { - fn: fn, - desc: "neither parent nor dir exists", - expects: []file{{name: "baz/quux", mode: os.ModeDir}}, - }, - } - for _, c := range cases { - t.Run(c.desc, func(t *testing.T) { - c.run(t, &utilfs.DefaultFs{}) - }) - } -} - -func TestWriteTempDir(t *testing.T) { - // writing a tmp dir is covered by TestReplaceDir, but we additionally test filename validation here - c := test{ - desc: "invalid file key", - err: "invalid file key", - fn: func(fs utilfs.Filesystem, dir string, c *test) []error { - if _, err := WriteTempDir(fs, filepath.Join(dir, "tmpdir"), map[string]string{"foo/bar": ""}); err != nil { - return []error{err} - } - return nil - }, - } - c.run(t, &utilfs.DefaultFs{}) -} - -func TestReplaceDir(t *testing.T) { - fn := func(fs utilfs.Filesystem, dir string, c *test) []error { - errs := []error{} - - // compute filesets from expected files and call ReplaceDir for each - // we don't nest dirs in test cases, order of ReplaceDir call is not guaranteed - dirs := map[string]map[string]string{} - - // allocate dirs - for _, f := range c.expects { - if f.mode.IsDir() { - path := filepath.Join(dir, f.name) - if _, ok := dirs[path]; !ok { - dirs[path] = map[string]string{} - } - } else if f.mode.IsRegular() { - path := filepath.Join(dir, filepath.Dir(f.name)) - if _, ok := dirs[path]; !ok { - // require an expectation for the parent directory if there is an expectation for the file - errs = append(errs, fmt.Errorf("no prior parent directory in c.expects for file %s", f.name)) - continue - } - dirs[path][filepath.Base(f.name)] = f.data - } - } - - // short-circuit test case validation errors - if len(errs) > 0 { - return errs - } - - // call ReplaceDir for each desired dir - for path, files := range dirs { - if err := ReplaceDir(fs, path, files); err != nil { - errs = append(errs, err) - } - } - return errs - } - cases := []test{ - { - fn: fn, - desc: "fn catches invalid test case", - expects: []file{{name: "foo/bar"}}, - err: "no prior parent directory", - }, - { - fn: fn, - desc: "empty dir", - expects: []file{{name: "foo", mode: os.ModeDir}}, - }, - { - fn: fn, - desc: "dir with files", - expects: []file{ - {name: "foo", mode: os.ModeDir}, - {name: "foo/bar", data: "baz"}, - {name: "foo/baz", data: "bar"}, - }, - }, - } - for _, c := range cases { - t.Run(c.desc, func(t *testing.T) { - c.run(t, &utilfs.DefaultFs{}) - }) - } -} diff --git a/pkg/kubelet/kubeletconfig/util/files/files_unix_test.go b/pkg/kubelet/kubeletconfig/util/files/files_unix_test.go deleted file mode 100644 index 3dc2b089a52..00000000000 --- a/pkg/kubelet/kubeletconfig/util/files/files_unix_test.go +++ /dev/null @@ -1,25 +0,0 @@ -//go:build !windows -// +build !windows - -/* -Copyright 2022 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 files - -const ( - missingFileError = "no such file or directory" - missingFolderError = "no such file or directory" -) diff --git a/pkg/kubelet/kubeletconfig/util/files/files_windows_test.go b/pkg/kubelet/kubeletconfig/util/files/files_windows_test.go deleted file mode 100644 index 27fe09abc28..00000000000 --- a/pkg/kubelet/kubeletconfig/util/files/files_windows_test.go +++ /dev/null @@ -1,25 +0,0 @@ -//go:build windows -// +build windows - -/* -Copyright 2022 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 files - -const ( - missingFileError = "The system cannot find the file specified." - missingFolderError = "The system cannot find the path specified." -)