This is an automated email from the ASF dual-hosted git repository. Pearl1594 pushed a commit to branch 4.22.1-maintenance in repository https://gitbox.apache.org/repos/asf/cloudstack-go.git
commit b044a2d5d4c4dc80eb6f167e70b4ef9acbce5ed7 Author: Pearl Dsilva <[email protected]> AuthorDate: Tue May 19 11:18:08 2026 -0400 Add support for prepare and cancel maintenance --- cloudstack/HostService.go | 224 +++++++++++++++++++++++++++++++++++++++++ cloudstack/HostService_mock.go | 58 +++++++++++ generate/layout.go | 2 + test/HostService_test.go | 24 +++++ 4 files changed, 308 insertions(+) diff --git a/cloudstack/HostService.go b/cloudstack/HostService.go index dea15fe..7dba230 100644 --- a/cloudstack/HostService.go +++ b/cloudstack/HostService.go @@ -100,6 +100,10 @@ type HostServiceIface interface { NewDeclareHostAsDegradedParams(id string) *DeclareHostAsDegradedParams UpdateSecondaryStorageSelector(p *UpdateSecondaryStorageSelectorParams) (*UpdateSecondaryStorageSelectorResponse, error) NewUpdateSecondaryStorageSelectorParams(heuristicrule string, id string) *UpdateSecondaryStorageSelectorParams + PrepareForMaintenance(p *PrepareForMaintenanceParams) (*PrepareForMaintenanceResponse, error) + NewPrepareForMaintenanceParams(managementserverid UUID) *PrepareForMaintenanceParams + CancelMaintenance(p *CancelMaintenanceParams) (*CancelMaintenanceResponse, error) + NewCancelMaintenanceParams(managementserverid UUID) *CancelMaintenanceParams } type AddBaremetalHostParams struct { @@ -6645,3 +6649,223 @@ type UpdateSecondaryStorageSelectorResponse struct { Type string `json:"type"` Zoneid string `json:"zoneid"` } + +type PrepareForMaintenanceParams struct { + p map[string]interface{} +} + +func (p *PrepareForMaintenanceParams) toURLValues() url.Values { + u := url.Values{} + if p.p == nil { + return u + } + if v, found := p.p["algorithm"]; found { + u.Set("algorithm", v.(string)) + } + if v, found := p.p["forced"]; found { + vv := strconv.FormatBool(v.(bool)) + u.Set("forced", vv) + } + if v, found := p.p["managementserverid"]; found { + u.Set("managementserverid", v.(string)) + } + return u +} + +func (p *PrepareForMaintenanceParams) SetAlgorithm(v string) { + if p.p == nil { + p.p = make(map[string]interface{}) + } + p.p["algorithm"] = v +} + +func (p *PrepareForMaintenanceParams) ResetAlgorithm() { + if p.p != nil && p.p["algorithm"] != nil { + delete(p.p, "algorithm") + } +} + +func (p *PrepareForMaintenanceParams) GetAlgorithm() (string, bool) { + if p.p == nil { + p.p = make(map[string]interface{}) + } + value, ok := p.p["algorithm"].(string) + return value, ok +} + +func (p *PrepareForMaintenanceParams) SetForced(v bool) { + if p.p == nil { + p.p = make(map[string]interface{}) + } + p.p["forced"] = v +} + +func (p *PrepareForMaintenanceParams) ResetForced() { + if p.p != nil && p.p["forced"] != nil { + delete(p.p, "forced") + } +} + +func (p *PrepareForMaintenanceParams) GetForced() (bool, bool) { + if p.p == nil { + p.p = make(map[string]interface{}) + } + value, ok := p.p["forced"].(bool) + return value, ok +} + +func (p *PrepareForMaintenanceParams) SetManagementserverid(v UUID) { + if p.p == nil { + p.p = make(map[string]interface{}) + } + p.p["managementserverid"] = v +} + +func (p *PrepareForMaintenanceParams) ResetManagementserverid() { + if p.p != nil && p.p["managementserverid"] != nil { + delete(p.p, "managementserverid") + } +} + +func (p *PrepareForMaintenanceParams) GetManagementserverid() (UUID, bool) { + if p.p == nil { + p.p = make(map[string]interface{}) + } + value, ok := p.p["managementserverid"].(UUID) + return value, ok +} + +// You should always use this function to get a new PrepareForMaintenanceParams instance, +// as then you are sure you have configured all required params +func (s *HostService) NewPrepareForMaintenanceParams(managementserverid UUID) *PrepareForMaintenanceParams { + p := &PrepareForMaintenanceParams{} + p.p = make(map[string]interface{}) + p.p["managementserverid"] = managementserverid + return p +} + +// Prepares management server for maintenance by preventing new jobs from being accepted after completion of active jobs and migrating the agents +func (s *HostService) PrepareForMaintenance(p *PrepareForMaintenanceParams) (*PrepareForMaintenanceResponse, error) { + resp, err := s.cs.newPostRequest("prepareForMaintenance", p.toURLValues()) + if err != nil { + return nil, err + } + + var r PrepareForMaintenanceResponse + if err := json.Unmarshal(resp, &r); err != nil { + return nil, err + } + + return &r, nil +} + +type PrepareForMaintenanceResponse struct { + Agents []string `json:"agents"` + Agentscount int64 `json:"agentscount"` + JobID string `json:"jobid"` + Jobstatus int `json:"jobstatus"` + Maintenanceinitiated bool `json:"maintenanceinitiated"` + Managementserverid UUID `json:"managementserverid"` + Pendingjobscount int64 `json:"pendingjobscount"` + Readyforshutdown bool `json:"readyforshutdown"` + Shutdowntriggered bool `json:"shutdowntriggered"` + State string `json:"state"` +} + +type CancelMaintenanceParams struct { + p map[string]interface{} +} + +func (p *CancelMaintenanceParams) toURLValues() url.Values { + u := url.Values{} + if p.p == nil { + return u + } + if v, found := p.p["managementserverid"]; found { + u.Set("managementserverid", v.(string)) + } + if v, found := p.p["rebalance"]; found { + vv := strconv.FormatBool(v.(bool)) + u.Set("rebalance", vv) + } + return u +} + +func (p *CancelMaintenanceParams) SetManagementserverid(v UUID) { + if p.p == nil { + p.p = make(map[string]interface{}) + } + p.p["managementserverid"] = v +} + +func (p *CancelMaintenanceParams) ResetManagementserverid() { + if p.p != nil && p.p["managementserverid"] != nil { + delete(p.p, "managementserverid") + } +} + +func (p *CancelMaintenanceParams) GetManagementserverid() (UUID, bool) { + if p.p == nil { + p.p = make(map[string]interface{}) + } + value, ok := p.p["managementserverid"].(UUID) + return value, ok +} + +func (p *CancelMaintenanceParams) SetRebalance(v bool) { + if p.p == nil { + p.p = make(map[string]interface{}) + } + p.p["rebalance"] = v +} + +func (p *CancelMaintenanceParams) ResetRebalance() { + if p.p != nil && p.p["rebalance"] != nil { + delete(p.p, "rebalance") + } +} + +func (p *CancelMaintenanceParams) GetRebalance() (bool, bool) { + if p.p == nil { + p.p = make(map[string]interface{}) + } + value, ok := p.p["rebalance"].(bool) + return value, ok +} + +// You should always use this function to get a new CancelMaintenanceParams instance, +// as then you are sure you have configured all required params +func (s *HostService) NewCancelMaintenanceParams(managementserverid UUID) *CancelMaintenanceParams { + p := &CancelMaintenanceParams{} + p.p = make(map[string]interface{}) + p.p["managementserverid"] = managementserverid + return p +} + +// Cancels maintenance of the management server +func (s *HostService) CancelMaintenance(p *CancelMaintenanceParams) (*CancelMaintenanceResponse, error) { + resp, err := s.cs.newPostRequest("cancelMaintenance", p.toURLValues()) + if err != nil { + return nil, err + } + + var r CancelMaintenanceResponse + if err := json.Unmarshal(resp, &r); err != nil { + return nil, err + } + + return &r, nil +} + +type CancelMaintenanceResponse struct { + Agents []string `json:"agents"` + Agentscount int64 `json:"agentscount"` + JobID string `json:"jobid"` + Jobstatus int `json:"jobstatus"` + Maintenanceinitiated bool `json:"maintenanceinitiated"` + Managementserverid UUID `json:"managementserverid"` + Pendingjobscount int64 `json:"pendingjobscount"` + Readyforshutdown bool `json:"readyforshutdown"` + Shutdowntriggered bool `json:"shutdowntriggered"` + State string `json:"state"` +} diff --git a/cloudstack/HostService_mock.go b/cloudstack/HostService_mock.go index 3d7a743..0d786bf 100644 --- a/cloudstack/HostService_mock.go +++ b/cloudstack/HostService_mock.go @@ -148,6 +148,21 @@ func (mr *MockHostServiceIfaceMockRecorder) CancelHostMaintenance(p any) *gomock return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelHostMaintenance", reflect.TypeOf((*MockHostServiceIface)(nil).CancelHostMaintenance), p) } +// CancelMaintenance mocks base method. +func (m *MockHostServiceIface) CancelMaintenance(p *CancelMaintenanceParams) (*CancelMaintenanceResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "CancelMaintenance", p) + ret0, _ := ret[0].(*CancelMaintenanceResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// CancelMaintenance indicates an expected call of CancelMaintenance. +func (mr *MockHostServiceIfaceMockRecorder) CancelMaintenance(p any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "CancelMaintenance", reflect.TypeOf((*MockHostServiceIface)(nil).CancelMaintenance), p) +} + // ConfigureHAForHost mocks base method. func (m *MockHostServiceIface) ConfigureHAForHost(p *ConfigureHAForHostParams) (*HAForHostResponse, error) { m.ctrl.T.Helper() @@ -670,6 +685,20 @@ func (mr *MockHostServiceIfaceMockRecorder) NewCancelHostMaintenanceParams(id an return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCancelHostMaintenanceParams", reflect.TypeOf((*MockHostServiceIface)(nil).NewCancelHostMaintenanceParams), id) } +// NewCancelMaintenanceParams mocks base method. +func (m *MockHostServiceIface) NewCancelMaintenanceParams(managementserverid UUID) *CancelMaintenanceParams { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NewCancelMaintenanceParams", managementserverid) + ret0, _ := ret[0].(*CancelMaintenanceParams) + return ret0 +} + +// NewCancelMaintenanceParams indicates an expected call of NewCancelMaintenanceParams. +func (mr *MockHostServiceIfaceMockRecorder) NewCancelMaintenanceParams(managementserverid any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewCancelMaintenanceParams", reflect.TypeOf((*MockHostServiceIface)(nil).NewCancelMaintenanceParams), managementserverid) +} + // NewConfigureHAForHostParams mocks base method. func (m *MockHostServiceIface) NewConfigureHAForHostParams(hostid, provider string) *ConfigureHAForHostParams { m.ctrl.T.Helper() @@ -922,6 +951,20 @@ func (mr *MockHostServiceIfaceMockRecorder) NewMigrateSecondaryStorageDataParams return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewMigrateSecondaryStorageDataParams", reflect.TypeOf((*MockHostServiceIface)(nil).NewMigrateSecondaryStorageDataParams), destpools, srcpool) } +// NewPrepareForMaintenanceParams mocks base method. +func (m *MockHostServiceIface) NewPrepareForMaintenanceParams(managementserverid UUID) *PrepareForMaintenanceParams { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "NewPrepareForMaintenanceParams", managementserverid) + ret0, _ := ret[0].(*PrepareForMaintenanceParams) + return ret0 +} + +// NewPrepareForMaintenanceParams indicates an expected call of NewPrepareForMaintenanceParams. +func (mr *MockHostServiceIfaceMockRecorder) NewPrepareForMaintenanceParams(managementserverid any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewPrepareForMaintenanceParams", reflect.TypeOf((*MockHostServiceIface)(nil).NewPrepareForMaintenanceParams), managementserverid) +} + // NewPrepareHostForMaintenanceParams mocks base method. func (m *MockHostServiceIface) NewPrepareHostForMaintenanceParams(id string) *PrepareHostForMaintenanceParams { m.ctrl.T.Helper() @@ -1034,6 +1077,21 @@ func (mr *MockHostServiceIfaceMockRecorder) NewUpdateSecondaryStorageSelectorPar return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "NewUpdateSecondaryStorageSelectorParams", reflect.TypeOf((*MockHostServiceIface)(nil).NewUpdateSecondaryStorageSelectorParams), heuristicrule, id) } +// PrepareForMaintenance mocks base method. +func (m *MockHostServiceIface) PrepareForMaintenance(p *PrepareForMaintenanceParams) (*PrepareForMaintenanceResponse, error) { + m.ctrl.T.Helper() + ret := m.ctrl.Call(m, "PrepareForMaintenance", p) + ret0, _ := ret[0].(*PrepareForMaintenanceResponse) + ret1, _ := ret[1].(error) + return ret0, ret1 +} + +// PrepareForMaintenance indicates an expected call of PrepareForMaintenance. +func (mr *MockHostServiceIfaceMockRecorder) PrepareForMaintenance(p any) *gomock.Call { + mr.mock.ctrl.T.Helper() + return mr.mock.ctrl.RecordCallWithMethodType(mr.mock, "PrepareForMaintenance", reflect.TypeOf((*MockHostServiceIface)(nil).PrepareForMaintenance), p) +} + // PrepareHostForMaintenance mocks base method. func (m *MockHostServiceIface) PrepareHostForMaintenance(p *PrepareHostForMaintenanceParams) (*PrepareHostForMaintenanceResponse, error) { m.ctrl.T.Helper() diff --git a/generate/layout.go b/generate/layout.go index 0a20b96..fdbeec1 100644 --- a/generate/layout.go +++ b/generate/layout.go @@ -262,6 +262,8 @@ var layout = apiInfo{ "listHostHAResources", "declareHostAsDegraded", "updateSecondaryStorageSelector", + "prepareForMaintenance", + "cancelMaintenance", }, "VolumeService": { "attachVolume", diff --git a/test/HostService_test.go b/test/HostService_test.go index 45ce74c..5020300 100644 --- a/test/HostService_test.go +++ b/test/HostService_test.go @@ -455,4 +455,28 @@ func TestHostService(t *testing.T) { } t.Run("UpdateSecondaryStorageSelector", testupdateSecondaryStorageSelector) + testprepareForMaintenance := func(t *testing.T) { + if _, ok := response["prepareForMaintenance"]; !ok { + t.Skipf("Skipping as no json response is provided in testdata") + } + p := client.Host.NewPrepareForMaintenanceParams("managementserverid") + _, err := client.Host.PrepareForMaintenance(p) + if err != nil { + t.Errorf(err.Error()) + } + } + t.Run("PrepareForMaintenance", testprepareForMaintenance) + + testcancelMaintenance := func(t *testing.T) { + if _, ok := response["cancelMaintenance"]; !ok { + t.Skipf("Skipping as no json response is provided in testdata") + } + p := client.Host.NewCancelMaintenanceParams("managementserverid") + _, err := client.Host.CancelMaintenance(p) + if err != nil { + t.Errorf(err.Error()) + } + } + t.Run("CancelMaintenance", testcancelMaintenance) + }
