From e13df683c3444dafb96875fe7c32993e3c219742 Mon Sep 17 00:00:00 2001 From: Jan Obernberger Date: Mon, 15 Jun 2026 16:18:30 +0200 Subject: [PATCH 1/6] chore(logme): copy waiter --- services/logme/v2api/wait/wait.go | 135 ++++++++++++++++++++++++++++++ 1 file changed, 135 insertions(+) create mode 100644 services/logme/v2api/wait/wait.go diff --git a/services/logme/v2api/wait/wait.go b/services/logme/v2api/wait/wait.go new file mode 100644 index 000000000..490a442be --- /dev/null +++ b/services/logme/v2api/wait/wait.go @@ -0,0 +1,135 @@ +package wait + +import ( + "context" + "errors" + "fmt" + "net/http" + "strings" + "time" + + "github.com/stackitcloud/stackit-sdk-go/core/oapierror" + "github.com/stackitcloud/stackit-sdk-go/core/wait" + logme "github.com/stackitcloud/stackit-sdk-go/services/logme/v2api" +) + +// CreateInstanceWaitHandler will wait for instance creation +func CreateInstanceWaitHandler(ctx context.Context, client logme.DefaultAPI, projectId, region, instanceId string) *wait.AsyncActionHandler[logme.Instance] { + waitConfig := wait.WaiterHelper[logme.Instance, logme.InstanceStatus]{ + FetchInstance: client.GetInstance(ctx, projectId, region, instanceId).Execute, + GetState: func(response *logme.Instance) (logme.InstanceStatus, error) { + if response == nil { + return "", errors.New("empty response") + } + if response.Status == nil { + return "", errors.New("status is missing in response") + } + return *response.Status, nil + }, + ActiveState: []logme.InstanceStatus{logme.INSTANCESTATUS_ACTIVE}, + ErrorState: []logme.InstanceStatus{logme.INSTANCESTATUS_FAILED}, + } + + handler := wait.New(waitConfig.Wait()) + handler.SetTimeout(45 * time.Minute) + return handler +} + +// PartialUpdateInstanceWaitHandler will wait for instance update +func PartialUpdateInstanceWaitHandler(ctx context.Context, client logme.DefaultAPI, projectId, region, instanceId string) *wait.AsyncActionHandler[logme.Instance] { + waitConfig := wait.WaiterHelper[logme.Instance, logme.InstanceStatus]{ + FetchInstance: client.GetInstance(ctx, projectId, region, instanceId).Execute, + GetState: func(response *logme.Instance) (logme.InstanceStatus, error) { + if response == nil { + return "", errors.New("empty response") + } + if response.Status == nil { + return "", errors.New("status is missing in response") + } + return *response.Status, nil + }, + ActiveState: []logme.InstanceStatus{logme.INSTANCESTATUS_ACTIVE}, + ErrorState: []logme.InstanceStatus{logme.INSTANCESTATUS_FAILED}, + } + + handler := wait.New(waitConfig.Wait()) + handler.SetTimeout(45 * time.Minute) + return handler +} + +// DeleteInstanceWaitHandler will wait for instance deletion +func DeleteInstanceWaitHandler(ctx context.Context, a logme.DefaultAPI, projectId, region, instanceId string) *wait.AsyncActionHandler[struct{}] { + handler := wait.New(func() (waitFinished bool, response *struct{}, err error) { + s, err := a.GetInstance(ctx, projectId, region, instanceId).Execute() + if err == nil { + if s.Status == nil { + return false, nil, fmt.Errorf("delete failed for instance with id %s. The response is not valid: The status is missing", instanceId) + } + if *s.Status != logme.INSTANCESTATUS_DELETING { + return false, nil, nil + } + if *s.Status == logme.INSTANCESTATUS_ACTIVE { + if strings.Contains(s.LastOperation.Description, "DeleteFailed") || strings.Contains(s.LastOperation.Description, "failed") { + return true, nil, fmt.Errorf("instance was deleted successfully but has errors: %s", s.LastOperation.Description) + } + return true, nil, nil + } + return false, nil, nil + } + var oapiErr *oapierror.GenericOpenAPIError + ok := errors.As(err, &oapiErr) //nolint:errorlint //complaining that error.As should be used to catch wrapped errors, but this error should not be wrapped + if !ok { + return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError") + } + if oapiErr.StatusCode != http.StatusGone { + return false, nil, err + } + return true, nil, nil + }) + handler.SetTimeout(15 * time.Minute) + return handler +} + +// CreateCredentialsWaitHandler will wait for credentials creation +func CreateCredentialsWaitHandler(ctx context.Context, a logme.DefaultAPI, projectId, region, instanceId, credentialsId string) *wait.AsyncActionHandler[logme.CredentialsResponse] { + handler := wait.New(func() (waitFinished bool, response *logme.CredentialsResponse, err error) { + s, err := a.GetCredentials(ctx, projectId, region, instanceId, credentialsId).Execute() + if err != nil { + oapiErr, ok := err.(*oapierror.GenericOpenAPIError) + if !ok { + return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError") + } + // If the request returns 404, the credentials have not been created yet + if oapiErr.StatusCode == http.StatusNotFound { + return false, nil, nil + } + return false, nil, err + } + if s.Id == credentialsId { + return true, s, nil + } + return false, nil, nil + }) + handler.SetTimeout(1 * time.Minute) + return handler +} + +// DeleteCredentialsWaitHandler will wait for credentials deletion +func DeleteCredentialsWaitHandler(ctx context.Context, a logme.DefaultAPI, projectId, region, instanceId, credentialsId string) *wait.AsyncActionHandler[struct{}] { + handler := wait.New(func() (waitFinished bool, response *struct{}, err error) { + _, err = a.GetCredentials(ctx, projectId, region, instanceId, credentialsId).Execute() + if err == nil { + return false, nil, nil + } + oapiErr, ok := err.(*oapierror.GenericOpenAPIError) //nolint:errorlint //complaining that error.As should be used to catch wrapped errors, but this error should not be wrapped + if !ok { + return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError") + } + if oapiErr.StatusCode != http.StatusNotFound && oapiErr.StatusCode != http.StatusGone { + return false, nil, err + } + return true, nil, nil + }) + handler.SetTimeout(1 * time.Minute) + return handler +} From 6cf1b207d8aec8165aadefefb108eff17d2eb524 Mon Sep 17 00:00:00 2001 From: Jan Obernberger Date: Mon, 15 Jun 2026 16:25:30 +0200 Subject: [PATCH 2/6] chore(logme): try fix linter --- services/logme/v2api/wait/wait.go | 5 ++--- 1 file changed, 2 insertions(+), 3 deletions(-) diff --git a/services/logme/v2api/wait/wait.go b/services/logme/v2api/wait/wait.go index 490a442be..d412d8f7c 100644 --- a/services/logme/v2api/wait/wait.go +++ b/services/logme/v2api/wait/wait.go @@ -76,8 +76,7 @@ func DeleteInstanceWaitHandler(ctx context.Context, a logme.DefaultAPI, projectI } return false, nil, nil } - var oapiErr *oapierror.GenericOpenAPIError - ok := errors.As(err, &oapiErr) //nolint:errorlint //complaining that error.As should be used to catch wrapped errors, but this error should not be wrapped + oapiErr, ok := err.(*oapierror.GenericOpenAPIError) //nolint:errorlint //complaining that error.As should be used to catch wrapped errors, but this error should not be wrapped if !ok { return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError") } @@ -95,7 +94,7 @@ func CreateCredentialsWaitHandler(ctx context.Context, a logme.DefaultAPI, proje handler := wait.New(func() (waitFinished bool, response *logme.CredentialsResponse, err error) { s, err := a.GetCredentials(ctx, projectId, region, instanceId, credentialsId).Execute() if err != nil { - oapiErr, ok := err.(*oapierror.GenericOpenAPIError) + oapiErr, ok := err.(*oapierror.GenericOpenAPIError) //nolint:errorlint //complaining that error.As should be used to catch wrapped errors, but this error should not be wrapped if !ok { return false, nil, fmt.Errorf("could not convert error to oapierror.GenericOpenAPIError") } From 4e21afc4580f78a7b1985cbb9627d21cb4ca7ec6 Mon Sep 17 00:00:00 2001 From: Jan Obernberger Date: Mon, 15 Jun 2026 17:04:34 +0200 Subject: [PATCH 3/6] chore(logme): created test --- services/logme/v2api/wait/wait_test.go | 417 +++++++++++++++++++++++++ 1 file changed, 417 insertions(+) create mode 100644 services/logme/v2api/wait/wait_test.go diff --git a/services/logme/v2api/wait/wait_test.go b/services/logme/v2api/wait/wait_test.go new file mode 100644 index 000000000..008d735b1 --- /dev/null +++ b/services/logme/v2api/wait/wait_test.go @@ -0,0 +1,417 @@ +package wait + +import ( + "context" + "testing" + "testing/synctest" + + "github.com/google/go-cmp/cmp" + + "github.com/stackitcloud/stackit-sdk-go/core/oapierror" + "github.com/stackitcloud/stackit-sdk-go/core/utils" + logme "github.com/stackitcloud/stackit-sdk-go/services/logme/v2api" +) + +const deleteOperation = "delete" +const testRegion = "region" + +type mockSettings struct { + instanceGetFails bool + instanceDeletionSucceedsWithErrors bool + instanceResourceId string + instanceResourceOperation *string + instanceResourceState logme.InstanceStatus + instanceResourceDescription string + + credentialGetFails bool + credentialResourceId string + credentialOperationSucceeds bool + credentialDeletionSucceeds bool +} + +func newAPIMock(settings *mockSettings) logme.DefaultAPI { + return &logme.DefaultAPIServiceMock{ + GetInstanceExecuteMock: utils.Ptr(func(_ logme.ApiGetInstanceRequest) (*logme.Instance, error) { + if settings.instanceGetFails { + return nil, &oapierror.GenericOpenAPIError{ + StatusCode: 500, + } + } + if settings.instanceResourceOperation != nil && *settings.instanceResourceOperation == deleteOperation && settings.instanceResourceState == logme.INSTANCESTATUS_ACTIVE { + if settings.instanceDeletionSucceedsWithErrors { + return &logme.Instance{ + InstanceId: &settings.instanceResourceId, + Status: &settings.instanceResourceState, + LastOperation: logme.InstanceLastOperation{ + Description: settings.instanceResourceDescription, + }, + }, nil + } + return nil, &oapierror.GenericOpenAPIError{ + StatusCode: 410, + } + } + + return &logme.Instance{ + InstanceId: &settings.instanceResourceId, + Status: &settings.instanceResourceState, + }, nil + }), + GetCredentialsExecuteMock: utils.Ptr(func(_ logme.ApiGetCredentialsRequest) (*logme.CredentialsResponse, error) { + if settings.credentialGetFails { + return nil, &oapierror.GenericOpenAPIError{ + StatusCode: 500, + } + } + + if !settings.credentialOperationSucceeds || settings.credentialDeletionSucceeds { + return nil, &oapierror.GenericOpenAPIError{ + StatusCode: 404, + } + } + + return &logme.CredentialsResponse{ + Id: settings.credentialResourceId, + }, nil + }), + } +} + +func TestCreateInstanceWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + resourceState logme.InstanceStatus + wantErr bool + wantResp bool + }{ + { + desc: "create_succeeded", + getFails: false, + resourceState: logme.INSTANCESTATUS_ACTIVE, + wantErr: false, + wantResp: true, + }, + { + desc: "create_failed", + getFails: false, + resourceState: logme.INSTANCESTATUS_FAILED, + wantErr: true, + wantResp: true, + }, + { + desc: "wrong state in response", + getFails: false, + resourceState: "wrong state", + wantErr: true, + wantResp: false, + }, + { + desc: "get_fails", + getFails: true, + wantErr: true, + wantResp: false, + }, + { + desc: "timeout", + getFails: false, + resourceState: "ANOTHER STATE", + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + instanceId := "foo-bar" + + apiClient := newAPIMock(&mockSettings{ + instanceGetFails: tt.getFails, + instanceResourceId: instanceId, + instanceResourceState: tt.resourceState, + }) + + var wantRes *logme.Instance + if tt.wantResp { + wantRes = &logme.Instance{ + InstanceId: &instanceId, + Status: &tt.resourceState, + } + } + + handler := CreateInstanceWaitHandler(context.Background(), apiClient, "pid", testRegion, instanceId) + + gotRes, err := handler.WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + diff := cmp.Diff(gotRes, wantRes) + if diff != "" { + t.Fatalf("handler gotRes = %+v\n want %+v\n diff = %s", gotRes, wantRes, diff) + } + }) + }) + } +} + +func TestUpdateInstanceWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + resourceState logme.InstanceStatus + wantErr bool + wantResp bool + }{ + { + desc: "update_succeeded", + getFails: false, + resourceState: logme.INSTANCESTATUS_ACTIVE, + wantErr: false, + wantResp: true, + }, + { + desc: "update_failed", + getFails: false, + resourceState: logme.INSTANCESTATUS_FAILED, + wantErr: true, + wantResp: true, + }, + { + desc: "wrong state in response", + getFails: false, + resourceState: "wrong state", + wantErr: true, + wantResp: false, + }, + { + desc: "get_fails", + getFails: true, + wantErr: true, + wantResp: false, + }, + { + desc: "timeout", + getFails: false, + resourceState: "ANOTHER STATE", + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + instanceId := "foo-bar" + + apiClient := newAPIMock(&mockSettings{ + instanceGetFails: tt.getFails, + instanceResourceId: instanceId, + instanceResourceState: tt.resourceState, + }) + + var wantRes *logme.Instance + if tt.wantResp { + wantRes = &logme.Instance{ + InstanceId: &instanceId, + Status: &tt.resourceState, + } + } + + handler := PartialUpdateInstanceWaitHandler(context.Background(), apiClient, "", testRegion, instanceId) + + gotRes, err := handler.WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + if !cmp.Equal(gotRes, wantRes) { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + }) + }) + } +} + +func TestDeleteInstanceWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + deleteSucceeedsWithErrors bool + resourceState logme.InstanceStatus + resourceDescription string + wantErr bool + wantResp bool + }{ + { + desc: "delete_succeeded", + getFails: false, + deleteSucceeedsWithErrors: false, + resourceState: logme.INSTANCESTATUS_ACTIVE, + wantErr: false, + wantResp: true, + }, + { + desc: "delete_failed", + getFails: false, + deleteSucceeedsWithErrors: false, + resourceState: logme.INSTANCESTATUS_FAILED, + wantErr: true, + wantResp: true, + }, + { + desc: "delete_succeeds_with_errors", + getFails: false, + resourceState: logme.INSTANCESTATUS_ACTIVE, + deleteSucceeedsWithErrors: true, + resourceDescription: "Deleting resource: cf failed with error: DeleteFailed", + wantErr: true, + wantResp: false, + }, + { + desc: "get_fails", + deleteSucceeedsWithErrors: false, + getFails: true, + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + instanceId := "foo-bar" + + apiClient := newAPIMock(&mockSettings{ + instanceGetFails: tt.getFails, + instanceDeletionSucceedsWithErrors: tt.deleteSucceeedsWithErrors, + instanceResourceId: instanceId, + instanceResourceOperation: utils.Ptr(deleteOperation), + instanceResourceDescription: tt.resourceDescription, + instanceResourceState: tt.resourceState, + }) + + handler := DeleteInstanceWaitHandler(context.Background(), apiClient, "", "", instanceId) + + gotRes, err := handler.WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + if err == nil && gotRes != nil { + t.Fatalf("handler gotRes = %v, want %v", gotRes, nil) + } + }) + }) + } +} + +func TestCreateCredentialsWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + operationSucceeds bool + wantErr bool + wantResp bool + }{ + { + desc: "create_succeeded", + getFails: false, + operationSucceeds: true, + wantErr: false, + wantResp: true, + }, + { + desc: "create_failed", + getFails: false, + operationSucceeds: false, + wantErr: true, + wantResp: false, + }, + { + desc: "get_fails", + getFails: true, + wantErr: true, + wantResp: false, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + credentialsId := "foo-bar" + + apiClient := newAPIMock(&mockSettings{ + credentialGetFails: tt.getFails, + credentialResourceId: credentialsId, + credentialOperationSucceeds: tt.operationSucceeds, + }) + + var wantRes *logme.CredentialsResponse + if tt.wantResp { + wantRes = &logme.CredentialsResponse{ + Id: credentialsId, + } + } + + handler := CreateCredentialsWaitHandler(context.Background(), apiClient, "", "", "", credentialsId) + + gotRes, err := handler.WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + if !cmp.Equal(gotRes, wantRes) { + t.Fatalf("handler gotRes = %v, want %v", gotRes, wantRes) + } + }) + }) + } +} + +func TestDeleteCredentialsWaitHandler(t *testing.T) { + tests := []struct { + desc string + getFails bool + deletionSucceeds bool + wantErr bool + }{ + { + desc: "delete_succeeded", + getFails: false, + deletionSucceeds: true, + wantErr: false, + }, + { + desc: "delete_failed", + getFails: false, + deletionSucceeds: false, + wantErr: true, + }, + { + desc: "get_fails", + getFails: true, + deletionSucceeds: false, + wantErr: true, + }, + } + for _, tt := range tests { + t.Run(tt.desc, func(t *testing.T) { + synctest.Test(t, func(t *testing.T) { + credentialsId := "foo-bar" + + apiClient := newAPIMock(&mockSettings{ + credentialGetFails: tt.getFails, + credentialResourceId: credentialsId, + credentialOperationSucceeds: true, + credentialDeletionSucceeds: tt.deletionSucceeds, + }) + + handler := DeleteCredentialsWaitHandler(context.Background(), apiClient, "", "", "", credentialsId) + + _, err := handler.WaitWithContext(context.Background()) + + if (err != nil) != tt.wantErr { + t.Fatalf("handler error = %v, wantErr %v", err, tt.wantErr) + } + }) + }) + } +} From a30544a14a8e5992d63ca43872c8c4d238c0f0c9 Mon Sep 17 00:00:00 2001 From: Jan Obernberger Date: Mon, 15 Jun 2026 17:12:05 +0200 Subject: [PATCH 4/6] chore(logme): write changelog --- CHANGELOG.md | 3 +++ services/logme/CHANGELOG.md | 4 ++++ services/logme/VERSION | 2 +- 3 files changed, 8 insertions(+), 1 deletion(-) diff --git a/CHANGELOG.md b/CHANGELOG.md index b9d8a2c1d..c159f67ba 100644 --- a/CHANGELOG.md +++ b/CHANGELOG.md @@ -260,6 +260,9 @@ - `v1api`: - **Feature:** Added optional `CreateCredentialsPayload` to `ApiCreateCredentialsRequest`. - **Deprecation:** `FluentdTls`, `FluentdTlsCiphers`, `FluentdTlsMaxVersion`, `FluentdTlsMinVersion`, `FluentdTlsVersion`, `OpensearchTlsCiphers`, `OpensearchTlsProtocols` from `InstanceParameters` model are deprecated and will be removed 2026-12-12. + - [v1.0.1](services/logme/CHANGELOG.md#v101) + - `v2api`: + - **Bugfix**: Add missing waiter - `logs`: - [v0.7.3](services/logs/CHANGELOG.md#v073) - **Dependencies:** Bump STACKIT SDK core module from `v0.24.0` to `v0.24.1` diff --git a/services/logme/CHANGELOG.md b/services/logme/CHANGELOG.md index 80fa87d86..88170f6e0 100644 --- a/services/logme/CHANGELOG.md +++ b/services/logme/CHANGELOG.md @@ -1,3 +1,7 @@ +## v1.0.1 +- `v2api`: + - **Bugfix**: Add missing waiter + ## v1.0.0 - `v2api`: - New package which can be used for communication with the logme v2 API diff --git a/services/logme/VERSION b/services/logme/VERSION index 60453e690..6a2b0ac42 100644 --- a/services/logme/VERSION +++ b/services/logme/VERSION @@ -1 +1 @@ -v1.0.0 \ No newline at end of file +v1.0.1 \ No newline at end of file From 58b82763355332e8264fa2ba44155795ac73b764 Mon Sep 17 00:00:00 2001 From: Jan Obernberger Date: Mon, 15 Jun 2026 18:02:49 +0200 Subject: [PATCH 5/6] chore(logme): remove if statement that introduces unreachable code path --- services/logme/v2api/wait/wait.go | 3 --- 1 file changed, 3 deletions(-) diff --git a/services/logme/v2api/wait/wait.go b/services/logme/v2api/wait/wait.go index d412d8f7c..968204222 100644 --- a/services/logme/v2api/wait/wait.go +++ b/services/logme/v2api/wait/wait.go @@ -65,9 +65,6 @@ func DeleteInstanceWaitHandler(ctx context.Context, a logme.DefaultAPI, projectI if s.Status == nil { return false, nil, fmt.Errorf("delete failed for instance with id %s. The response is not valid: The status is missing", instanceId) } - if *s.Status != logme.INSTANCESTATUS_DELETING { - return false, nil, nil - } if *s.Status == logme.INSTANCESTATUS_ACTIVE { if strings.Contains(s.LastOperation.Description, "DeleteFailed") || strings.Contains(s.LastOperation.Description, "failed") { return true, nil, fmt.Errorf("instance was deleted successfully but has errors: %s", s.LastOperation.Description) From 0268308a64093b3adfbefd9895a59c438b3809e7 Mon Sep 17 00:00:00 2001 From: Jan Obernberger Date: Mon, 15 Jun 2026 18:08:07 +0200 Subject: [PATCH 6/6] chore(logme): add deprecated status till end of period --- services/logme/v2api/wait/wait.go | 21 +++++++++++++++++++++ 1 file changed, 21 insertions(+) diff --git a/services/logme/v2api/wait/wait.go b/services/logme/v2api/wait/wait.go index 968204222..a3254e52f 100644 --- a/services/logme/v2api/wait/wait.go +++ b/services/logme/v2api/wait/wait.go @@ -13,6 +13,27 @@ import ( logme "github.com/stackitcloud/stackit-sdk-go/services/logme/v2api" ) +const ( + // Deprecated: symbol is not used anymore, use the packages enum instead, will be removed 2026-12, use `go fix` for automatic fixing + //go:fix inline + INSTANCESTATUS_ACTIVE = logme.INSTANCESTATUS_ACTIVE + // Deprecated: symbol is not used anymore, use the packages enum instead, will be removed 2026-12, use `go fix` for automatic fixing + //go:fix inline + INSTANCESTATUS_FAILED = logme.INSTANCESTATUS_FAILED + // Deprecated: symbol is not used anymore, use the packages enum instead, will be removed 2026-12, use `go fix` for automatic fixing + //go:fix inline + INSTANCESTATUS_STOPPED = logme.INSTANCESTATUS_STOPPED + // Deprecated: symbol is not used anymore, use the packages enum instead, will be removed 2026-12, use `go fix` for automatic fixing + //go:fix inline + INSTANCESTATUS_CREATING = logme.INSTANCESTATUS_CREATING + // Deprecated: symbol is not used anymore, use the packages enum instead, will be removed 2026-12, use `go fix` for automatic fixing + //go:fix inline + INSTANCESTATUS_DELETING = logme.INSTANCESTATUS_DELETING + // Deprecated: symbol is not used anymore, use the packages enum instead, will be removed 2026-12, use `go fix` for automatic fixing + //go:fix inline + INSTANCESTATUS_UPDATING = logme.INSTANCESTATUS_UPDATING +) + // CreateInstanceWaitHandler will wait for instance creation func CreateInstanceWaitHandler(ctx context.Context, client logme.DefaultAPI, projectId, region, instanceId string) *wait.AsyncActionHandler[logme.Instance] { waitConfig := wait.WaiterHelper[logme.Instance, logme.InstanceStatus]{