Tigris Storage SDK for Go

go get github.com/tigrisdata/storage-go

package main

import (
    "context"
    "fmt"
    "log"

    storage "github.com/tigrisdata/storage-go"
)

func main() {
    ctx := context.Background()

    // Create a new Tigris client
    client, err := storage.New(ctx)
    if err != nil {
        log.Fatal(err)
    }

    // Use the client like you would use AWS S3 client
    // plus Tigris-specific features (see below)
    fmt.Println("Connected to Tigris!")
}

client, err := storage.New(ctx,
    storage.WithFlyEndpoint(),           // Use fly.io optimized endpoint
    storage.WithGlobalEndpoint(),        // Use globally available endpoint (default)
    storage.WithRegion("auto"),          // Specify a region
    storage.WithAccessKeypair(key, secret), // Set access credentials
)

output, err := client.CreateSnapshotEnabledBucket(ctx, &s3.CreateBucketInput{
    Bucket: aws.String("my-bucket"),
})

output, err := client.CreateBucketSnapshot(ctx, "Initial backup", &s3.CreateBucketInput{
    Bucket: aws.String("my-bucket"),
})
// output.SnapshotVersion holds the version returned by Tigris.

// Creates a new bucket "my-bucket-fork" as a fork of "my-bucket"
output, err := client.CreateBucketFork(ctx, "my-bucket", "my-bucket-fork")

snapshots, err := client.ListBucketSnapshots(ctx, "my-bucket")

info, err := client.HeadBucketForkOrSnapshot(ctx, &s3.HeadBucketInput{
    Bucket: aws.String("my-bucket"),
})
// info.SnapshotsEnabled     - true if snapshots are enabled
// info.SourceBucket         - The bucket this was forked from
// info.SourceBucketSnapshot - The snapshot this was forked from
// info.IsForkParent         - true if there are forks of this bucket

// Default 7-day retention window
_, err := client.CreateBucketWithSoftDelete(ctx, &storage.CreateBucketWithSoftDeleteInput{
    CreateBucketInput: &s3.CreateBucketInput{
        Bucket: aws.String("my-bucket"),
    },
})

// Custom 30-day retention window
_, err = client.CreateBucketWithSoftDelete(ctx, &storage.CreateBucketWithSoftDeleteInput{
    CreateBucketInput: &s3.CreateBucketInput{
        Bucket: aws.String("my-other-bucket"),
    },
    RetentionDays: 30,
})

_, err := client.SetBucketSoftDelete(ctx, &storage.SetBucketSoftDeleteInput{
    Bucket:        "my-bucket",
    Enabled:       true,
    RetentionDays: 30, // omit for the default 7-day window
})

listed, err := client.ListSoftDeletedObjects(ctx, &storage.ListSoftDeletedObjectsInput{
    Bucket: "my-bucket",
    Prefix: "logs/", // optional
})
// listed.Objects[i].Key          - object key
// listed.Objects[i].VersionID    - version to restore or permanently delete
// listed.Objects[i].Size         - original size in bytes
// listed.Objects[i].LastModified - time the object was soft-deleted
// listed.IsTruncated             - true if more pages are available

// Restore the most recent soft-deleted version
_, err = client.RestoreSoftDeletedObject(ctx, &storage.RestoreSoftDeletedObjectInput{
    Bucket: "my-bucket",
    Key:    "my-key",
})

// Restore one specific version
_, err = client.RestoreSoftDeletedObject(ctx, &storage.RestoreSoftDeletedObjectInput{
    Bucket:    "my-bucket",
    Key:       "my-key",
    VersionID: listed.Objects[0].VersionID,
})

listed, err := client.ListSoftDeletedBuckets(ctx, nil)
// listed.Buckets[i].Name          - bucket to restore
// listed.Buckets[i].RetentionDays - the configured window in days

_, err = client.RestoreBucket(ctx, &storage.RestoreBucketInput{
    Bucket: "my-bucket",
})

_, err := client.ForceDeleteBucket(ctx, &s3.DeleteBucketInput{
    Bucket: aws.String("my-bucket"),
})

_, err := client.PermanentlyDeleteObject(ctx, "my-bucket", "my-key", "1775929768707198086")

_, err := client.RestoreBucket(ctx, &storage.RestoreBucketInput{Bucket: "my-bucket"})

var apiErr smithy.APIError
if errors.As(err, &apiErr) && apiErr.ErrorCode() == "NoSuchBucket" {
    // the bucket is gone
}

var apiErr *storage.APIError
if errors.As(err, &apiErr) {
    log.Printf("HTTP %d %s: %s (request %s)",
        apiErr.StatusCode, apiErr.Code, apiErr.Message, apiErr.RequestID)
}

_, err := client.RenameObject(ctx, &s3.CopyObjectInput{
    Bucket:     aws.String("my-bucket"),
    CopySource: aws.String("my-bucket/old-name.txt"),
    Key:        aws.String("new-name.txt"),
})