resources

type BaseResource ¶

type BaseResource struct {
	OrganizationID string `property:"OrganizationID"`
	ProjectID      string `property:"ProjectID"`
	Region         string `property:"Region"`
}

BaseResource embeds the project + region context every STACKIT resource shares. Use struct embedding with `property:",inline"` so the fields participate in libnuke's filter/property system.

type ComputeKeypair ¶

type ComputeKeypair struct {
	*BaseResource `property:",inline"`

	Name        string
	Fingerprint string
	CreatedAt   *time.Time
	Labels      map[string]string
	// contains filtered or unexported fields
}

ComputeKeypair is a STACKIT IaaS SSH keypair.

API: github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api

Endpoints used:

• GET /v2/keypairs
• DELETE /v2/keypairs/{keypairName}

Keypairs are neither regional nor project-scoped: they belong to the authenticated identity (user or service account). Listers run once per (project, region); the Lister only returns keypairs during the first configured project's first region scan, so each keypair shows up exactly once per run.

func (r *ComputeKeypair) Properties() types.Properties

func (r *ComputeKeypair) Remove(ctx context.Context) error

func (r *ComputeKeypair) String() string

type ComputeKeypairLister ¶

type ComputeKeypairLister struct{}

func (l *ComputeKeypairLister) List(ctx context.Context, o any) ([]resource.Resource, error)

type ComputeServer ¶

type ComputeServer struct {
	*BaseResource `property:",inline"`

	ID               string
	Name             string
	AvailabilityZone string
	CreatedAt        *time.Time
	Labels           map[string]string
	// contains filtered or unexported fields
}

ComputeServer is a STACKIT IaaS server (a.k.a. virtual machine).

API: github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api

Endpoints used:

• GET /v2/projects/{projectId}/regions/{region}/servers
• DELETE /v2/projects/{projectId}/regions/{region}/servers/{serverId}

func (r *ComputeServer) Properties() types.Properties

func (r *ComputeServer) Remove(ctx context.Context) error

func (r *ComputeServer) String() string

type ComputeServerLister ¶

type ComputeServerLister struct{}

func (l *ComputeServerLister) List(ctx context.Context, o any) ([]resource.Resource, error)

type ComputeSnapshot ¶

type ComputeSnapshot struct {
	*BaseResource `property:",inline"`

	ID        string
	Name      string
	VolumeID  string
	SizeGB    int64
	Status    string
	CreatedAt *time.Time
	Labels    map[string]string
	// contains filtered or unexported fields
}

ComputeSnapshot is a STACKIT IaaS volume snapshot.

API: github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api

Endpoints used:

• GET /v2/projects/{projectId}/regions/{region}/snapshots
• DELETE /v2/projects/{projectId}/regions/{region}/snapshots/{snapshotId}

Deletion is asynchronous: the snapshot stays listed with status DELETING until it is gone, which is exactly the wait behavior libnuke expects. Remove skips the DELETE call for snapshots already in that state, and the Lister drops snapshots with status DELETED so a finished delete can never keep libnuke waiting.

func (r *ComputeSnapshot) Properties() types.Properties

func (r *ComputeSnapshot) Remove(ctx context.Context) error

func (r *ComputeSnapshot) String() string

type ComputeSnapshotLister ¶

type ComputeSnapshotLister struct{}

func (l *ComputeSnapshotLister) List(ctx context.Context, o any) ([]resource.Resource, error)

type ComputeVolume ¶

type ComputeVolume struct {
	*BaseResource `property:",inline"`

	ID               string
	Name             string
	AvailabilityZone string
	SizeGB           int64
	Bootable         bool
	Status           string
	ServerID         string
	CreatedAt        *time.Time
	Labels           map[string]string
	// contains filtered or unexported fields
}

ComputeVolume is a STACKIT IaaS block volume.

API: github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api

Endpoints used:

• GET /v2/projects/{projectId}/regions/{region}/volumes
• DELETE /v2/projects/{projectId}/regions/{region}/volumes/{volumeId}

func (r *ComputeVolume) Properties() types.Properties

func (r *ComputeVolume) Remove(ctx context.Context) error

func (r *ComputeVolume) String() string

type ComputeVolumeLister ¶

type ComputeVolumeLister struct{}

func (l *ComputeVolumeLister) List(ctx context.Context, o any) ([]resource.Resource, error)

type DNSZone ¶

type DNSZone struct {
	*BaseResource `property:",inline"`

	ID      string
	Name    string
	DNSName string
	State   string
	// contains filtered or unexported fields
}

DNSZone is a STACKIT DNS zone.

API: github.com/stackitcloud/stackit-sdk-go/services/dns/v1api

Endpoints used:

• GET /v1/projects/{projectId}/zones
• DELETE /v1/projects/{projectId}/zones/{zoneId}

DNS is a global service: zones are not bound to a region, but listers run once per (project, region). The Lister therefore only returns zones for the first configured region, so each zone shows up exactly once per run.

Deleting a zone is a soft delete: the zone stays listed with state DELETE_SUCCEEDED during the retention window. The Lister skips those, so libnuke sees the zone as gone once the delete has landed.

func (r *DNSZone) Properties() types.Properties

func (r *DNSZone) Remove(ctx context.Context) error

func (r *DNSZone) String() string

type DNSZoneLister ¶

type DNSZoneLister struct{}

func (l *DNSZoneLister) List(ctx context.Context, o any) ([]resource.Resource, error)

type FloatingIP ¶

type FloatingIP struct {
	*BaseResource `property:",inline"`

	ID               string
	IP               string
	NetworkInterface string
	Labels           map[string]string
	// contains filtered or unexported fields
}

FloatingIP is a STACKIT IaaS public IP.

API: github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api

Endpoints used:

• GET /v2/projects/{projectId}/regions/{region}/public-ips
• DELETE /v2/projects/{projectId}/regions/{region}/public-ips/{publicIpId}

func (r *FloatingIP) Properties() types.Properties

func (r *FloatingIP) Remove(ctx context.Context) error

func (r *FloatingIP) String() string

type FloatingIPLister ¶

type FloatingIPLister struct{}

func (l *FloatingIPLister) List(ctx context.Context, o any) ([]resource.Resource, error)

type GitInstance ¶ added in v0.0.7

type GitInstance struct {
	*BaseResource `property:",inline"`

	ID      string
	Name    string
	URL     string
	Flavor  string
	Version string
	State   string
	// contains filtered or unexported fields
}

GitInstance is a STACKIT Git instance.

API: github.com/stackitcloud/stackit-sdk-go/services/git/v1betaapi

Endpoints used:

• GET /v1beta/projects/{projectId}/instances
• DELETE /v1beta/projects/{projectId}/instances/{instanceId}

STACKIT Git is a global service: instances are not bound to a region (the API host's region variable defaults to "global" and no endpoint takes a region), but listers run once per (project, region). The Lister therefore only returns instances for the first configured region, so each instance shows up exactly once per run.

Deletion is asynchronous: the instance stays listed in state "Deleting" until it is gone, which is exactly the wait behavior libnuke expects.

func (r *GitInstance) Properties() types.Properties

func (r *GitInstance) Remove(ctx context.Context) error

func (r *GitInstance) String() string

type GitInstanceLister ¶ added in v0.0.7

type GitInstanceLister struct{}

func (l *GitInstanceLister) List(ctx context.Context, o any) ([]resource.Resource, error)

type LoadBalancer ¶

type LoadBalancer struct {
	*BaseResource `property:",inline"`
	Name          string
}

func (r *LoadBalancer) Properties() types.Properties

func (r *LoadBalancer) Remove(_ context.Context) error

func (r *LoadBalancer) String() string

type LoadBalancerLister ¶

type LoadBalancerLister struct{}

func (l *LoadBalancerLister) List(_ context.Context, _ any) ([]resource.Resource, error)

type MariaDBInstance ¶ added in v0.0.8

type MariaDBInstance struct {
	*BaseResource `property:",inline"`

	ID      string
	Name    string
	Plan    string
	Version string
	Status  string
	// contains filtered or unexported fields
}

MariaDBInstance is a STACKIT MariaDB instance.

API: github.com/stackitcloud/stackit-sdk-go/services/mariadb/v2api

Endpoints used:

• GET /v2/projects/{projectId}/regions/{regionId}/instances
• DELETE /v2/projects/{projectId}/regions/{regionId}/instances/{instanceId}

Deletion is asynchronous: the instance stays listed with status "deleting" until it is gone, which is exactly the wait behavior libnuke expects. Remove skips the DELETE call for instances already in that state (e.g. left over from an interrupted run). The Lister drops instances whose last operation is a succeeded delete, so a finished delete can never keep libnuke waiting.

func (r *MariaDBInstance) Properties() types.Properties

func (r *MariaDBInstance) Remove(ctx context.Context) error

func (r *MariaDBInstance) String() string

type MariaDBInstanceLister ¶ added in v0.0.8

type MariaDBInstanceLister struct{}

func (l *MariaDBInstanceLister) List(ctx context.Context, o any) ([]resource.Resource, error)

type MongoDBFlexInstance ¶

type MongoDBFlexInstance struct {
	*BaseResource `property:",inline"`
	ID            string
	Name          string
}

func (r *MongoDBFlexInstance) Properties() types.Properties

func (r *MongoDBFlexInstance) Remove(_ context.Context) error

func (r *MongoDBFlexInstance) String() string

type MongoDBFlexInstanceLister ¶

type MongoDBFlexInstanceLister struct{}

func (l *MongoDBFlexInstanceLister) List(_ context.Context, _ any) ([]resource.Resource, error)

type Network ¶

type Network struct {
	*BaseResource `property:",inline"`

	ID        string
	Name      string
	Routed    bool
	Status    string
	CreatedAt *time.Time
	Labels    map[string]string
	// contains filtered or unexported fields
}

Network is a STACKIT IaaS network.

API: github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api

Endpoints used:

• GET /v2/projects/{projectId}/regions/{region}/networks
• DELETE /v2/projects/{projectId}/regions/{region}/networks/{networkId}

func (r *Network) Properties() types.Properties

func (r *Network) Remove(ctx context.Context) error

func (r *Network) String() string

type NetworkInterface ¶ added in v0.0.2

type NetworkInterface struct {
	*BaseResource `property:",inline"`

	ID        string
	Name      string
	NetworkID string
	Device    string
	IPv4      string
	MAC       string
	Status    string
	Labels    map[string]string
	// contains filtered or unexported fields
}

NetworkInterface is a STACKIT IaaS NIC. NICs live under a Network, so the API path includes both networkId and nicId.

API: github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api

Endpoints used:

• GET /v2/projects/{projectId}/regions/{region}/networks/{networkId}/nics
• DELETE /v2/projects/{projectId}/regions/{region}/networks/{networkId}/nics/{nicId}

func (r *NetworkInterface) Properties() types.Properties

func (r *NetworkInterface) Remove(ctx context.Context) error

func (r *NetworkInterface) String() string

type NetworkInterfaceLister ¶ added in v0.0.2

type NetworkInterfaceLister struct{}

func (l *NetworkInterfaceLister) List(ctx context.Context, o any) ([]resource.Resource, error)

type NetworkLister ¶

type NetworkLister struct{}

func (l *NetworkLister) List(ctx context.Context, o any) ([]resource.Resource, error)

type ObjectStorageBucket ¶

type ObjectStorageBucket struct {
	*BaseResource `property:",inline"`

	Name              string
	ObjectLockEnabled bool
	URL               string
	// contains filtered or unexported fields
}

ObjectStorageBucket is a STACKIT Object Storage bucket.

API: github.com/stackitcloud/stackit-sdk-go/services/objectstorage/v2api

Endpoints used:

• GET /v2/project/{projectId}/regions/{region}/buckets
• DELETE /v2/project/{projectId}/regions/{region}/bucket/{bucketName}
• POST /v2/project/{projectId}/regions/{region}/credentials-group
• DELETE /v2/project/{projectId}/regions/{region}/credentials-group/{groupId}
• POST /v2/project/{projectId}/regions/{region}/access-key
• DELETE /v2/project/{projectId}/regions/{region}/access-key/{keyId}
• S3 ListObjectVersions + DeleteObjects on the bucket

The API refuses to delete a bucket that still holds objects (422 bucket.not_empty), and it has no object endpoints. On that error Remove creates a temporary credentials group + access key, deletes every object version and delete marker over S3, deletes the bucket, and then removes the temporary credentials again. Objects are therefore not a separate resource type.

Projects without Object Storage enabled answer the list call with 404, which the Lister treats as "no buckets".

func (r *ObjectStorageBucket) Properties() types.Properties

func (r *ObjectStorageBucket) Remove(ctx context.Context) error

func (r *ObjectStorageBucket) String() string

type ObjectStorageBucketLister ¶

type ObjectStorageBucketLister struct{}

func (l *ObjectStorageBucketLister) List(ctx context.Context, o any) ([]resource.Resource, error)

type OpenSearchInstance ¶

type OpenSearchInstance struct {
	*BaseResource `property:",inline"`
	ID            string
	Name          string
}

func (r *OpenSearchInstance) Properties() types.Properties

func (r *OpenSearchInstance) Remove(_ context.Context) error

func (r *OpenSearchInstance) String() string

type OpenSearchInstanceLister ¶

type OpenSearchInstanceLister struct{}

func (l *OpenSearchInstanceLister) List(_ context.Context, _ any) ([]resource.Resource, error)

type PostgresFlexInstance ¶

type PostgresFlexInstance struct {
	*BaseResource `property:",inline"`

	ID     string
	Name   string
	Status string
	// contains filtered or unexported fields
}

PostgresFlexInstance is a STACKIT PostgreSQL Flex instance.

API: github.com/stackitcloud/stackit-sdk-go/services/postgresflex/v2api

Endpoints used:

• GET /v2/projects/{projectId}/regions/{region}/instances
• GET /v2/projects/{projectId}/regions/{region}/instances/{instanceId}
• DELETE /v2/projects/{projectId}/regions/{region}/instances/{instanceId}
• DELETE /v2/projects/{projectId}/regions/{region}/instances/{instanceId}/force

Deleting an instance is a soft delete: it stays listed with status "Deleted" during the retention window, so libnuke would wait on it forever (Remove is only invoked once per item per run). Remove therefore soft-deletes, polls until the instance reaches "Deleted", then force-deletes to purge it within the same run.

func (r *PostgresFlexInstance) Properties() types.Properties

func (r *PostgresFlexInstance) Remove(ctx context.Context) error

func (r *PostgresFlexInstance) String() string

type PostgresFlexInstanceLister ¶

type PostgresFlexInstanceLister struct{}

func (l *PostgresFlexInstanceLister) List(ctx context.Context, o any) ([]resource.Resource, error)

type RabbitMQInstance ¶

type RabbitMQInstance struct {
	*BaseResource `property:",inline"`
	ID            string
	Name          string
}

func (r *RabbitMQInstance) Properties() types.Properties

func (r *RabbitMQInstance) Remove(_ context.Context) error

func (r *RabbitMQInstance) String() string

type RabbitMQInstanceLister ¶

type RabbitMQInstanceLister struct{}

func (l *RabbitMQInstanceLister) List(_ context.Context, _ any) ([]resource.Resource, error)

type RedisInstance ¶

type RedisInstance struct {
	*BaseResource `property:",inline"`
	ID            string
	Name          string
}

func (r *RedisInstance) Properties() types.Properties

func (r *RedisInstance) Remove(_ context.Context) error

func (r *RedisInstance) String() string

type RedisInstanceLister ¶

type RedisInstanceLister struct{}

func (l *RedisInstanceLister) List(_ context.Context, _ any) ([]resource.Resource, error)

type SKECluster ¶

type SKECluster struct {
	*BaseResource `property:",inline"`
	Name          string
}

func (r *SKECluster) Properties() types.Properties

func (r *SKECluster) Remove(_ context.Context) error

func (r *SKECluster) String() string

type SKEClusterLister ¶

type SKEClusterLister struct{}

func (l *SKEClusterLister) List(_ context.Context, _ any) ([]resource.Resource, error)

type SecurityGroup ¶

type SecurityGroup struct {
	*BaseResource `property:",inline"`

	ID          string
	Name        string
	Description string
	Stateful    bool
	CreatedAt   *time.Time
	Labels      map[string]string
	// contains filtered or unexported fields
}

SecurityGroup is a STACKIT IaaS security group.

Note: STACKIT auto-creates a "default" SG per project. It is generally protected and will fail to delete; filter it out in config via `filters.SecurityGroup: [{property: Name, value: default}]`.

API: github.com/stackitcloud/stackit-sdk-go/services/iaas/v2api

Endpoints used:

• GET /v2/projects/{projectId}/regions/{region}/security-groups
• DELETE /v2/projects/{projectId}/regions/{region}/security-groups/{securityGroupId}

func (r *SecurityGroup) Properties() types.Properties

func (r *SecurityGroup) Remove(ctx context.Context) error

func (r *SecurityGroup) String() string

type SecurityGroupLister ¶

type SecurityGroupLister struct{}

func (l *SecurityGroupLister) List(ctx context.Context, o any) ([]resource.Resource, error)