diff --git a/changes/20250814161616.feature b/changes/20250814161616.feature new file mode 100644 index 0000000000..a74afd5a3e --- /dev/null +++ b/changes/20250814161616.feature @@ -0,0 +1 @@ +[headers] Add method to get the value of a specific header \ No newline at end of file diff --git a/utils/http/headers/headers.go b/utils/http/headers/headers.go index 5fce73b0c5..d0e57ee46d 100644 --- a/utils/http/headers/headers.go +++ b/utils/http/headers/headers.go @@ -145,6 +145,14 @@ func (hs Headers) Append(h *Header) { hs[h.Key] = *h } +func (hs Headers) Get(key string) string { + h, found := hs[key] + if !found { + return "" + } + return h.Value +} + func (hs Headers) Has(h *Header) bool { if h == nil { return false diff --git a/utils/http/headers/interfaces.go b/utils/http/headers/interfaces.go index 5b810cfde9..6b0a87bdfc 100644 --- a/utils/http/headers/interfaces.go +++ b/utils/http/headers/interfaces.go @@ -9,6 +9,7 @@ import "net/http" type IHTTPHeaders interface { AppendHeader(key, value string) Append(h *Header) + Get(key string) string Has(h *Header) bool HasHeader(key string) bool Empty() bool diff --git a/utils/mocks/mock_filesystem.go b/utils/mocks/mock_filesystem.go index 1185d4c0c8..ba8ab298f7 100644 --- a/utils/mocks/mock_filesystem.go +++ b/utils/mocks/mock_filesystem.go @@ -12,14 +12,14 @@ package mocks import ( context "context" io "io" - fs "io/fs" + os "os" user "os/user" filepath "path/filepath" reflect "reflect" time "time" filesystem "github.com/ARM-software/golang-utils/utils/filesystem" - v3 "github.com/bmatcuk/doublestar/v3" + doublestar "github.com/bmatcuk/doublestar/v3" gomock "go.uber.org/mock/gomock" ) @@ -294,10 +294,10 @@ func (mr *MockFileMockRecorder) ReadAt(p, off any) *gomock.Call { } // Readdir mocks base method. -func (m *MockFile) Readdir(count int) ([]fs.FileInfo, error) { +func (m *MockFile) Readdir(count int) ([]os.FileInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Readdir", count) - ret0, _ := ret[0].([]fs.FileInfo) + ret0, _ := ret[0].([]os.FileInfo) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -339,10 +339,10 @@ func (mr *MockFileMockRecorder) Seek(offset, whence any) *gomock.Call { } // Stat mocks base method. -func (m *MockFile) Stat() (fs.FileInfo, error) { +func (m *MockFile) Stat() (os.FileInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Stat") - ret0, _ := ret[0].(fs.FileInfo) + ret0, _ := ret[0].(os.FileInfo) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -981,7 +981,7 @@ func (mr *MockFSMockRecorder) ChangeOwnershipRecursively(ctx, path, owner any) * } // Chmod mocks base method. -func (m *MockFS) Chmod(name string, mode fs.FileMode) error { +func (m *MockFS) Chmod(name string, mode os.FileMode) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Chmod", name, mode) ret0, _ := ret[0].(error) @@ -995,7 +995,7 @@ func (mr *MockFSMockRecorder) Chmod(name, mode any) *gomock.Call { } // ChmodRecursively mocks base method. -func (m *MockFS) ChmodRecursively(ctx context.Context, path string, mode fs.FileMode) error { +func (m *MockFS) ChmodRecursively(ctx context.Context, path string, mode os.FileMode) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ChmodRecursively", ctx, path, mode) ret0, _ := ret[0].(error) @@ -1562,32 +1562,32 @@ func (mr *MockFSMockRecorder) IsLink(path any) *gomock.Call { } // IsZip mocks base method. -func (m *MockFS) IsZip(filepath string) bool { +func (m *MockFS) IsZip(arg0 string) bool { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsZip", filepath) + ret := m.ctrl.Call(m, "IsZip", arg0) ret0, _ := ret[0].(bool) return ret0 } // IsZip indicates an expected call of IsZip. -func (mr *MockFSMockRecorder) IsZip(filepath any) *gomock.Call { +func (mr *MockFSMockRecorder) IsZip(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsZip", reflect.TypeOf((*MockFS)(nil).IsZip), filepath) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsZip", reflect.TypeOf((*MockFS)(nil).IsZip), arg0) } // IsZipWithContext mocks base method. -func (m *MockFS) IsZipWithContext(ctx context.Context, filepath string) (bool, error) { +func (m *MockFS) IsZipWithContext(ctx context.Context, arg1 string) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsZipWithContext", ctx, filepath) + ret := m.ctrl.Call(m, "IsZipWithContext", ctx, arg1) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } // IsZipWithContext indicates an expected call of IsZipWithContext. -func (mr *MockFSMockRecorder) IsZipWithContext(ctx, filepath any) *gomock.Call { +func (mr *MockFSMockRecorder) IsZipWithContext(ctx, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsZipWithContext", reflect.TypeOf((*MockFS)(nil).IsZipWithContext), ctx, filepath) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsZipWithContext", reflect.TypeOf((*MockFS)(nil).IsZipWithContext), ctx, arg1) } // Link mocks base method. @@ -1652,10 +1652,10 @@ func (mr *MockFSMockRecorder) ListDirTreeWithContextAndExclusionPatterns(ctx, di } // Lls mocks base method. -func (m *MockFS) Lls(dir string) ([]fs.FileInfo, error) { +func (m *MockFS) Lls(dir string) ([]os.FileInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Lls", dir) - ret0, _ := ret[0].([]fs.FileInfo) + ret0, _ := ret[0].([]os.FileInfo) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1667,10 +1667,10 @@ func (mr *MockFSMockRecorder) Lls(dir any) *gomock.Call { } // LlsFromOpenedDirectory mocks base method. -func (m *MockFS) LlsFromOpenedDirectory(dir filesystem.File) ([]fs.FileInfo, error) { +func (m *MockFS) LlsFromOpenedDirectory(dir filesystem.File) ([]os.FileInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "LlsFromOpenedDirectory", dir) - ret0, _ := ret[0].([]fs.FileInfo) + ret0, _ := ret[0].([]os.FileInfo) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1802,10 +1802,10 @@ func (mr *MockFSMockRecorder) LsWithExclusionPatterns(dir any, exclusionPatterns } // Lstat mocks base method. -func (m *MockFS) Lstat(name string) (fs.FileInfo, error) { +func (m *MockFS) Lstat(name string) (os.FileInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Lstat", name) - ret0, _ := ret[0].(fs.FileInfo) + ret0, _ := ret[0].(os.FileInfo) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1831,7 +1831,7 @@ func (mr *MockFSMockRecorder) MkDir(dir any) *gomock.Call { } // MkDirAll mocks base method. -func (m *MockFS) MkDirAll(dir string, perm fs.FileMode) error { +func (m *MockFS) MkDirAll(dir string, perm os.FileMode) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MkDirAll", dir, perm) ret0, _ := ret[0].(error) @@ -1887,10 +1887,10 @@ func (mr *MockFSMockRecorder) NewRemoteLockFile(id, dirToLock any) *gomock.Call } // Open mocks base method. -func (m *MockFS) Open(name string) (v3.File, error) { +func (m *MockFS) Open(name string) (doublestar.File, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Open", name) - ret0, _ := ret[0].(v3.File) + ret0, _ := ret[0].(doublestar.File) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -1902,7 +1902,7 @@ func (mr *MockFSMockRecorder) Open(name any) *gomock.Call { } // OpenFile mocks base method. -func (m *MockFS) OpenFile(name string, flag int, perm fs.FileMode) (filesystem.File, error) { +func (m *MockFS) OpenFile(name string, flag int, perm os.FileMode) (filesystem.File, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OpenFile", name, flag, perm) ret0, _ := ret[0].(filesystem.File) @@ -2082,10 +2082,10 @@ func (mr *MockFSMockRecorder) Rm(dir any) *gomock.Call { } // Stat mocks base method. -func (m *MockFS) Stat(name string) (fs.FileInfo, error) { +func (m *MockFS) Stat(name string) (os.FileInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Stat", name) - ret0, _ := ret[0].(fs.FileInfo) + ret0, _ := ret[0].(os.FileInfo) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -2386,7 +2386,7 @@ func (mr *MockFSMockRecorder) WalkWithContextAndExclusionPatterns(ctx, root, fn } // WriteFile mocks base method. -func (m *MockFS) WriteFile(filename string, data []byte, perm fs.FileMode) error { +func (m *MockFS) WriteFile(filename string, data []byte, perm os.FileMode) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WriteFile", filename, data, perm) ret0, _ := ret[0].(error) @@ -2400,7 +2400,7 @@ func (mr *MockFSMockRecorder) WriteFile(filename, data, perm any) *gomock.Call { } // WriteFileWithContext mocks base method. -func (m *MockFS) WriteFileWithContext(ctx context.Context, filename string, data []byte, perm fs.FileMode) error { +func (m *MockFS) WriteFileWithContext(ctx context.Context, filename string, data []byte, perm os.FileMode) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WriteFileWithContext", ctx, filename, data, perm) ret0, _ := ret[0].(error) @@ -2414,7 +2414,7 @@ func (mr *MockFSMockRecorder) WriteFileWithContext(ctx, filename, data, perm any } // WriteToFile mocks base method. -func (m *MockFS) WriteToFile(ctx context.Context, filename string, reader io.Reader, perm fs.FileMode) (int64, error) { +func (m *MockFS) WriteToFile(ctx context.Context, filename string, reader io.Reader, perm os.FileMode) (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WriteToFile", ctx, filename, reader, perm) ret0, _ := ret[0].(int64) @@ -2542,7 +2542,7 @@ func (mr *MockICloseableFSMockRecorder) ChangeOwnershipRecursively(ctx, path, ow } // Chmod mocks base method. -func (m *MockICloseableFS) Chmod(name string, mode fs.FileMode) error { +func (m *MockICloseableFS) Chmod(name string, mode os.FileMode) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Chmod", name, mode) ret0, _ := ret[0].(error) @@ -2556,7 +2556,7 @@ func (mr *MockICloseableFSMockRecorder) Chmod(name, mode any) *gomock.Call { } // ChmodRecursively mocks base method. -func (m *MockICloseableFS) ChmodRecursively(ctx context.Context, path string, mode fs.FileMode) error { +func (m *MockICloseableFS) ChmodRecursively(ctx context.Context, path string, mode os.FileMode) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "ChmodRecursively", ctx, path, mode) ret0, _ := ret[0].(error) @@ -3137,32 +3137,32 @@ func (mr *MockICloseableFSMockRecorder) IsLink(path any) *gomock.Call { } // IsZip mocks base method. -func (m *MockICloseableFS) IsZip(filepath string) bool { +func (m *MockICloseableFS) IsZip(arg0 string) bool { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsZip", filepath) + ret := m.ctrl.Call(m, "IsZip", arg0) ret0, _ := ret[0].(bool) return ret0 } // IsZip indicates an expected call of IsZip. -func (mr *MockICloseableFSMockRecorder) IsZip(filepath any) *gomock.Call { +func (mr *MockICloseableFSMockRecorder) IsZip(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsZip", reflect.TypeOf((*MockICloseableFS)(nil).IsZip), filepath) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsZip", reflect.TypeOf((*MockICloseableFS)(nil).IsZip), arg0) } // IsZipWithContext mocks base method. -func (m *MockICloseableFS) IsZipWithContext(ctx context.Context, filepath string) (bool, error) { +func (m *MockICloseableFS) IsZipWithContext(ctx context.Context, arg1 string) (bool, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "IsZipWithContext", ctx, filepath) + ret := m.ctrl.Call(m, "IsZipWithContext", ctx, arg1) ret0, _ := ret[0].(bool) ret1, _ := ret[1].(error) return ret0, ret1 } // IsZipWithContext indicates an expected call of IsZipWithContext. -func (mr *MockICloseableFSMockRecorder) IsZipWithContext(ctx, filepath any) *gomock.Call { +func (mr *MockICloseableFSMockRecorder) IsZipWithContext(ctx, arg1 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsZipWithContext", reflect.TypeOf((*MockICloseableFS)(nil).IsZipWithContext), ctx, filepath) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsZipWithContext", reflect.TypeOf((*MockICloseableFS)(nil).IsZipWithContext), ctx, arg1) } // Link mocks base method. @@ -3227,10 +3227,10 @@ func (mr *MockICloseableFSMockRecorder) ListDirTreeWithContextAndExclusionPatter } // Lls mocks base method. -func (m *MockICloseableFS) Lls(dir string) ([]fs.FileInfo, error) { +func (m *MockICloseableFS) Lls(dir string) ([]os.FileInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Lls", dir) - ret0, _ := ret[0].([]fs.FileInfo) + ret0, _ := ret[0].([]os.FileInfo) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -3242,10 +3242,10 @@ func (mr *MockICloseableFSMockRecorder) Lls(dir any) *gomock.Call { } // LlsFromOpenedDirectory mocks base method. -func (m *MockICloseableFS) LlsFromOpenedDirectory(dir filesystem.File) ([]fs.FileInfo, error) { +func (m *MockICloseableFS) LlsFromOpenedDirectory(dir filesystem.File) ([]os.FileInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "LlsFromOpenedDirectory", dir) - ret0, _ := ret[0].([]fs.FileInfo) + ret0, _ := ret[0].([]os.FileInfo) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -3377,10 +3377,10 @@ func (mr *MockICloseableFSMockRecorder) LsWithExclusionPatterns(dir any, exclusi } // Lstat mocks base method. -func (m *MockICloseableFS) Lstat(name string) (fs.FileInfo, error) { +func (m *MockICloseableFS) Lstat(name string) (os.FileInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Lstat", name) - ret0, _ := ret[0].(fs.FileInfo) + ret0, _ := ret[0].(os.FileInfo) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -3406,7 +3406,7 @@ func (mr *MockICloseableFSMockRecorder) MkDir(dir any) *gomock.Call { } // MkDirAll mocks base method. -func (m *MockICloseableFS) MkDirAll(dir string, perm fs.FileMode) error { +func (m *MockICloseableFS) MkDirAll(dir string, perm os.FileMode) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "MkDirAll", dir, perm) ret0, _ := ret[0].(error) @@ -3462,10 +3462,10 @@ func (mr *MockICloseableFSMockRecorder) NewRemoteLockFile(id, dirToLock any) *go } // Open mocks base method. -func (m *MockICloseableFS) Open(name string) (v3.File, error) { +func (m *MockICloseableFS) Open(name string) (doublestar.File, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Open", name) - ret0, _ := ret[0].(v3.File) + ret0, _ := ret[0].(doublestar.File) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -3477,7 +3477,7 @@ func (mr *MockICloseableFSMockRecorder) Open(name any) *gomock.Call { } // OpenFile mocks base method. -func (m *MockICloseableFS) OpenFile(name string, flag int, perm fs.FileMode) (filesystem.File, error) { +func (m *MockICloseableFS) OpenFile(name string, flag int, perm os.FileMode) (filesystem.File, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "OpenFile", name, flag, perm) ret0, _ := ret[0].(filesystem.File) @@ -3657,10 +3657,10 @@ func (mr *MockICloseableFSMockRecorder) Rm(dir any) *gomock.Call { } // Stat mocks base method. -func (m *MockICloseableFS) Stat(name string) (fs.FileInfo, error) { +func (m *MockICloseableFS) Stat(name string) (os.FileInfo, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "Stat", name) - ret0, _ := ret[0].(fs.FileInfo) + ret0, _ := ret[0].(os.FileInfo) ret1, _ := ret[1].(error) return ret0, ret1 } @@ -3961,7 +3961,7 @@ func (mr *MockICloseableFSMockRecorder) WalkWithContextAndExclusionPatterns(ctx, } // WriteFile mocks base method. -func (m *MockICloseableFS) WriteFile(filename string, data []byte, perm fs.FileMode) error { +func (m *MockICloseableFS) WriteFile(filename string, data []byte, perm os.FileMode) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WriteFile", filename, data, perm) ret0, _ := ret[0].(error) @@ -3975,7 +3975,7 @@ func (mr *MockICloseableFSMockRecorder) WriteFile(filename, data, perm any) *gom } // WriteFileWithContext mocks base method. -func (m *MockICloseableFS) WriteFileWithContext(ctx context.Context, filename string, data []byte, perm fs.FileMode) error { +func (m *MockICloseableFS) WriteFileWithContext(ctx context.Context, filename string, data []byte, perm os.FileMode) error { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WriteFileWithContext", ctx, filename, data, perm) ret0, _ := ret[0].(error) @@ -3989,7 +3989,7 @@ func (mr *MockICloseableFSMockRecorder) WriteFileWithContext(ctx, filename, data } // WriteToFile mocks base method. -func (m *MockICloseableFS) WriteToFile(ctx context.Context, filename string, reader io.Reader, perm fs.FileMode) (int64, error) { +func (m *MockICloseableFS) WriteToFile(ctx context.Context, filename string, reader io.Reader, perm os.FileMode) (int64, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "WriteToFile", ctx, filename, reader, perm) ret0, _ := ret[0].(int64) @@ -4127,10 +4127,10 @@ func (m *MockIStater) EXPECT() *MockIStaterMockRecorder { } // LstatIfPossible mocks base method. -func (m *MockIStater) LstatIfPossible(arg0 string) (fs.FileInfo, bool, error) { +func (m *MockIStater) LstatIfPossible(arg0 string) (os.FileInfo, bool, error) { m.ctrl.T.Helper() ret := m.ctrl.Call(m, "LstatIfPossible", arg0) - ret0, _ := ret[0].(fs.FileInfo) + ret0, _ := ret[0].(os.FileInfo) ret1, _ := ret[1].(bool) ret2, _ := ret[2].(error) return ret0, ret1, ret2 diff --git a/utils/mocks/mock_headers.go b/utils/mocks/mock_headers.go index 576da89bf7..04bbcf4d90 100644 --- a/utils/mocks/mock_headers.go +++ b/utils/mocks/mock_headers.go @@ -91,6 +91,20 @@ func (mr *MockIHTTPHeadersMockRecorder) Empty() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Empty", reflect.TypeOf((*MockIHTTPHeaders)(nil).Empty)) } +// Get mocks base method. +func (m *MockIHTTPHeaders) Get(key string) string { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Get", key) + ret0, _ := ret[0].(string) + return ret0 +} + +// Get indicates an expected call of Get. +func (mr *MockIHTTPHeadersMockRecorder) Get(key any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIHTTPHeaders)(nil).Get), key) +} + // Has mocks base method. func (m *MockIHTTPHeaders) Has(h *headers.Header) bool { m.ctrl.T.Helper() diff --git a/utils/mocks/mock_http.go b/utils/mocks/mock_http.go index a47042fbc8..37e37c6c35 100644 --- a/utils/mocks/mock_http.go +++ b/utils/mocks/mock_http.go @@ -57,18 +57,18 @@ func (mr *MockIClientMockRecorder) Close() *gomock.Call { } // Delete mocks base method. -func (m *MockIClient) Delete(url string) (*http.Response, error) { +func (m *MockIClient) Delete(arg0 string) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete", url) + ret := m.ctrl.Call(m, "Delete", arg0) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // Delete indicates an expected call of Delete. -func (mr *MockIClientMockRecorder) Delete(url any) *gomock.Call { +func (mr *MockIClientMockRecorder) Delete(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockIClient)(nil).Delete), url) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockIClient)(nil).Delete), arg0) } // Do mocks base method. @@ -87,93 +87,93 @@ func (mr *MockIClientMockRecorder) Do(req any) *gomock.Call { } // Get mocks base method. -func (m *MockIClient) Get(url string) (*http.Response, error) { +func (m *MockIClient) Get(arg0 string) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", url) + ret := m.ctrl.Call(m, "Get", arg0) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // Get indicates an expected call of Get. -func (mr *MockIClientMockRecorder) Get(url any) *gomock.Call { +func (mr *MockIClientMockRecorder) Get(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIClient)(nil).Get), url) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIClient)(nil).Get), arg0) } // Head mocks base method. -func (m *MockIClient) Head(url string) (*http.Response, error) { +func (m *MockIClient) Head(arg0 string) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Head", url) + ret := m.ctrl.Call(m, "Head", arg0) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // Head indicates an expected call of Head. -func (mr *MockIClientMockRecorder) Head(url any) *gomock.Call { +func (mr *MockIClientMockRecorder) Head(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockIClient)(nil).Head), url) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockIClient)(nil).Head), arg0) } // Options mocks base method. -func (m *MockIClient) Options(url string) (*http.Response, error) { +func (m *MockIClient) Options(arg0 string) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Options", url) + ret := m.ctrl.Call(m, "Options", arg0) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // Options indicates an expected call of Options. -func (mr *MockIClientMockRecorder) Options(url any) *gomock.Call { +func (mr *MockIClientMockRecorder) Options(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Options", reflect.TypeOf((*MockIClient)(nil).Options), url) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Options", reflect.TypeOf((*MockIClient)(nil).Options), arg0) } // Post mocks base method. -func (m *MockIClient) Post(url, contentType string, body any) (*http.Response, error) { +func (m *MockIClient) Post(arg0, contentType string, body any) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Post", url, contentType, body) + ret := m.ctrl.Call(m, "Post", arg0, contentType, body) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // Post indicates an expected call of Post. -func (mr *MockIClientMockRecorder) Post(url, contentType, body any) *gomock.Call { +func (mr *MockIClientMockRecorder) Post(arg0, contentType, body any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockIClient)(nil).Post), url, contentType, body) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockIClient)(nil).Post), arg0, contentType, body) } // PostForm mocks base method. -func (m *MockIClient) PostForm(url string, data url.Values) (*http.Response, error) { +func (m *MockIClient) PostForm(arg0 string, data url.Values) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PostForm", url, data) + ret := m.ctrl.Call(m, "PostForm", arg0, data) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // PostForm indicates an expected call of PostForm. -func (mr *MockIClientMockRecorder) PostForm(url, data any) *gomock.Call { +func (mr *MockIClientMockRecorder) PostForm(arg0, data any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostForm", reflect.TypeOf((*MockIClient)(nil).PostForm), url, data) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostForm", reflect.TypeOf((*MockIClient)(nil).PostForm), arg0, data) } // Put mocks base method. -func (m *MockIClient) Put(url string, body any) (*http.Response, error) { +func (m *MockIClient) Put(arg0 string, body any) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Put", url, body) + ret := m.ctrl.Call(m, "Put", arg0, body) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // Put indicates an expected call of Put. -func (mr *MockIClientMockRecorder) Put(url, body any) *gomock.Call { +func (mr *MockIClientMockRecorder) Put(arg0, body any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockIClient)(nil).Put), url, body) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockIClient)(nil).Put), arg0, body) } // StandardClient mocks base method. @@ -291,18 +291,18 @@ func (mr *MockIClientWithHeadersMockRecorder) Close() *gomock.Call { } // Delete mocks base method. -func (m *MockIClientWithHeaders) Delete(url string) (*http.Response, error) { +func (m *MockIClientWithHeaders) Delete(arg0 string) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Delete", url) + ret := m.ctrl.Call(m, "Delete", arg0) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // Delete indicates an expected call of Delete. -func (mr *MockIClientWithHeadersMockRecorder) Delete(url any) *gomock.Call { +func (mr *MockIClientWithHeadersMockRecorder) Delete(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockIClientWithHeaders)(nil).Delete), url) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Delete", reflect.TypeOf((*MockIClientWithHeaders)(nil).Delete), arg0) } // Do mocks base method. @@ -321,93 +321,93 @@ func (mr *MockIClientWithHeadersMockRecorder) Do(req any) *gomock.Call { } // Get mocks base method. -func (m *MockIClientWithHeaders) Get(url string) (*http.Response, error) { +func (m *MockIClientWithHeaders) Get(arg0 string) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Get", url) + ret := m.ctrl.Call(m, "Get", arg0) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // Get indicates an expected call of Get. -func (mr *MockIClientWithHeadersMockRecorder) Get(url any) *gomock.Call { +func (mr *MockIClientWithHeadersMockRecorder) Get(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIClientWithHeaders)(nil).Get), url) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Get", reflect.TypeOf((*MockIClientWithHeaders)(nil).Get), arg0) } // Head mocks base method. -func (m *MockIClientWithHeaders) Head(url string) (*http.Response, error) { +func (m *MockIClientWithHeaders) Head(arg0 string) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Head", url) + ret := m.ctrl.Call(m, "Head", arg0) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // Head indicates an expected call of Head. -func (mr *MockIClientWithHeadersMockRecorder) Head(url any) *gomock.Call { +func (mr *MockIClientWithHeadersMockRecorder) Head(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockIClientWithHeaders)(nil).Head), url) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Head", reflect.TypeOf((*MockIClientWithHeaders)(nil).Head), arg0) } // Options mocks base method. -func (m *MockIClientWithHeaders) Options(url string) (*http.Response, error) { +func (m *MockIClientWithHeaders) Options(arg0 string) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Options", url) + ret := m.ctrl.Call(m, "Options", arg0) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // Options indicates an expected call of Options. -func (mr *MockIClientWithHeadersMockRecorder) Options(url any) *gomock.Call { +func (mr *MockIClientWithHeadersMockRecorder) Options(arg0 any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Options", reflect.TypeOf((*MockIClientWithHeaders)(nil).Options), url) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Options", reflect.TypeOf((*MockIClientWithHeaders)(nil).Options), arg0) } // Post mocks base method. -func (m *MockIClientWithHeaders) Post(url, contentType string, body any) (*http.Response, error) { +func (m *MockIClientWithHeaders) Post(arg0, contentType string, body any) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Post", url, contentType, body) + ret := m.ctrl.Call(m, "Post", arg0, contentType, body) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // Post indicates an expected call of Post. -func (mr *MockIClientWithHeadersMockRecorder) Post(url, contentType, body any) *gomock.Call { +func (mr *MockIClientWithHeadersMockRecorder) Post(arg0, contentType, body any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockIClientWithHeaders)(nil).Post), url, contentType, body) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Post", reflect.TypeOf((*MockIClientWithHeaders)(nil).Post), arg0, contentType, body) } // PostForm mocks base method. -func (m *MockIClientWithHeaders) PostForm(url string, data url.Values) (*http.Response, error) { +func (m *MockIClientWithHeaders) PostForm(arg0 string, data url.Values) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "PostForm", url, data) + ret := m.ctrl.Call(m, "PostForm", arg0, data) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // PostForm indicates an expected call of PostForm. -func (mr *MockIClientWithHeadersMockRecorder) PostForm(url, data any) *gomock.Call { +func (mr *MockIClientWithHeadersMockRecorder) PostForm(arg0, data any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostForm", reflect.TypeOf((*MockIClientWithHeaders)(nil).PostForm), url, data) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PostForm", reflect.TypeOf((*MockIClientWithHeaders)(nil).PostForm), arg0, data) } // Put mocks base method. -func (m *MockIClientWithHeaders) Put(url string, body any) (*http.Response, error) { +func (m *MockIClientWithHeaders) Put(arg0 string, body any) (*http.Response, error) { m.ctrl.T.Helper() - ret := m.ctrl.Call(m, "Put", url, body) + ret := m.ctrl.Call(m, "Put", arg0, body) ret0, _ := ret[0].(*http.Response) ret1, _ := ret[1].(error) return ret0, ret1 } // Put indicates an expected call of Put. -func (mr *MockIClientWithHeadersMockRecorder) Put(url, body any) *gomock.Call { +func (mr *MockIClientWithHeadersMockRecorder) Put(arg0, body any) *gomock.Call { mr.mock.ctrl.T.Helper() - return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockIClientWithHeaders)(nil).Put), url, body) + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Put", reflect.TypeOf((*MockIClientWithHeaders)(nil).Put), arg0, body) } // RemoveHeader mocks base method. diff --git a/utils/mocks/mock_proc.go b/utils/mocks/mock_proc.go index 53f5f32025..0ad62727ac 100644 --- a/utils/mocks/mock_proc.go +++ b/utils/mocks/mock_proc.go @@ -113,6 +113,34 @@ func (mr *MockIProcessMockRecorder) Executable() *gomock.Call { return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Executable", reflect.TypeOf((*MockIProcess)(nil).Executable)) } +// Interrupt mocks base method. +func (m *MockIProcess) Interrupt(arg0 context.Context) error { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "Interrupt", arg0) + ret0, _ := ret[0].(error) + return ret0 +} + +// Interrupt indicates an expected call of Interrupt. +func (mr *MockIProcessMockRecorder) Interrupt(arg0 any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "Interrupt", reflect.TypeOf((*MockIProcess)(nil).Interrupt), arg0) +} + +// IsAZombie mocks base method. +func (m *MockIProcess) IsAZombie() bool { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "IsAZombie") + ret0, _ := ret[0].(bool) + return ret0 +} + +// IsAZombie indicates an expected call of IsAZombie. +func (mr *MockIProcessMockRecorder) IsAZombie() *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "IsAZombie", reflect.TypeOf((*MockIProcess)(nil).IsAZombie)) +} + // IsRunning mocks base method. func (m *MockIProcess) IsRunning() bool { m.ctrl.T.Helper() diff --git a/utils/proc/interrupttype_enumer.go b/utils/proc/interrupttype_enumer.go new file mode 100644 index 0000000000..77b38e5900 --- /dev/null +++ b/utils/proc/interrupttype_enumer.go @@ -0,0 +1,144 @@ +// Code generated by "enumer -type=InterruptType -text -json -yaml"; DO NOT EDIT. + +package proc + +import ( + "encoding/json" + "fmt" + "strings" +) + +const ( + _InterruptTypeName_0 = "SigInt" + _InterruptTypeLowerName_0 = "sigint" + _InterruptTypeName_1 = "SigKill" + _InterruptTypeLowerName_1 = "sigkill" + _InterruptTypeName_2 = "SigTerm" + _InterruptTypeLowerName_2 = "sigterm" +) + +var ( + _InterruptTypeIndex_0 = [...]uint8{0, 6} + _InterruptTypeIndex_1 = [...]uint8{0, 7} + _InterruptTypeIndex_2 = [...]uint8{0, 7} +) + +func (i InterruptType) String() string { + switch { + case i == 2: + return _InterruptTypeName_0 + case i == 9: + return _InterruptTypeName_1 + case i == 15: + return _InterruptTypeName_2 + default: + return fmt.Sprintf("InterruptType(%d)", i) + } +} + +// An "invalid array index" compiler error signifies that the constant values have changed. +// Re-run the stringer command to generate them again. +func _InterruptTypeNoOp() { + var x [1]struct{} + _ = x[SigInt-(2)] + _ = x[SigKill-(9)] + _ = x[SigTerm-(15)] +} + +var _InterruptTypeValues = []InterruptType{SigInt, SigKill, SigTerm} + +var _InterruptTypeNameToValueMap = map[string]InterruptType{ + _InterruptTypeName_0[0:6]: SigInt, + _InterruptTypeLowerName_0[0:6]: SigInt, + _InterruptTypeName_1[0:7]: SigKill, + _InterruptTypeLowerName_1[0:7]: SigKill, + _InterruptTypeName_2[0:7]: SigTerm, + _InterruptTypeLowerName_2[0:7]: SigTerm, +} + +var _InterruptTypeNames = []string{ + _InterruptTypeName_0[0:6], + _InterruptTypeName_1[0:7], + _InterruptTypeName_2[0:7], +} + +// InterruptTypeString retrieves an enum value from the enum constants string name. +// Throws an error if the param is not part of the enum. +func InterruptTypeString(s string) (InterruptType, error) { + if val, ok := _InterruptTypeNameToValueMap[s]; ok { + return val, nil + } + + if val, ok := _InterruptTypeNameToValueMap[strings.ToLower(s)]; ok { + return val, nil + } + return 0, fmt.Errorf("%s does not belong to InterruptType values", s) +} + +// InterruptTypeValues returns all values of the enum +func InterruptTypeValues() []InterruptType { + return _InterruptTypeValues +} + +// InterruptTypeStrings returns a slice of all String values of the enum +func InterruptTypeStrings() []string { + strs := make([]string, len(_InterruptTypeNames)) + copy(strs, _InterruptTypeNames) + return strs +} + +// IsAInterruptType returns "true" if the value is listed in the enum definition. "false" otherwise +func (i InterruptType) IsAInterruptType() bool { + for _, v := range _InterruptTypeValues { + if i == v { + return true + } + } + return false +} + +// MarshalJSON implements the json.Marshaler interface for InterruptType +func (i InterruptType) MarshalJSON() ([]byte, error) { + return json.Marshal(i.String()) +} + +// UnmarshalJSON implements the json.Unmarshaler interface for InterruptType +func (i *InterruptType) UnmarshalJSON(data []byte) error { + var s string + if err := json.Unmarshal(data, &s); err != nil { + return fmt.Errorf("InterruptType should be a string, got %s", data) + } + + var err error + *i, err = InterruptTypeString(s) + return err +} + +// MarshalText implements the encoding.TextMarshaler interface for InterruptType +func (i InterruptType) MarshalText() ([]byte, error) { + return []byte(i.String()), nil +} + +// UnmarshalText implements the encoding.TextUnmarshaler interface for InterruptType +func (i *InterruptType) UnmarshalText(text []byte) error { + var err error + *i, err = InterruptTypeString(string(text)) + return err +} + +// MarshalYAML implements a YAML Marshaler for InterruptType +func (i InterruptType) MarshalYAML() (interface{}, error) { + return i.String(), nil +} + +// UnmarshalYAML implements a YAML Unmarshaler for InterruptType +func (i *InterruptType) UnmarshalYAML(unmarshal func(interface{}) error) error { + var s string + if err := unmarshal(&s); err != nil { + return err + } + + var err error + *i, err = InterruptTypeString(s) + return err +}