Writable snapshot support

api/v1/api_v1_quotas.go

@@ -123,10 +123,11 @@ func CreateIsiQuota(
 	ctx context.Context,
 	client api.Client,
 	path string, container bool, size, softLimit, advisoryLimit, softGracePrd int64,
+	includeSnapshots bool,
 ) (string, error) {
 	// PAPI call: POST https://1.2.3.4:8080/platform/1/quota/quotas
 	//             { "enforced" : true,
-	//               "include_snapshots" : false,
+	//               "include_snapshots" : true,
 	//               "path" : "/ifs/volumes/volume_name",
 	//               "container" : true,
 	//               "thresholds_include_overhead" : false,
@@ -136,7 +137,7 @@ func CreateIsiQuota(
 	//                                "soft" : null
 	//                              }
 	//             }
-	// body={'path': '/ifs/data/quotatest', 'thresholds': {'soft_grace': 86400L, 'soft': 1048576L}, 'include_snapshots': False, 'force': False, 'type': 'directory'}
+	// body={'path': '/ifs/data/quotatest', 'thresholds': {'soft_grace': 86400L, 'soft': 1048576L}, 'include_snapshots': True, 'force': False, 'type': 'directory'}
 	// softGrace := 86400U
 	thresholds := isiThresholdsReq{Advisory: advisoryLimit, Hard: size, Soft: softLimit, SoftGrace: softGracePrd}
 	if advisoryLimit == 0 {
@@ -150,7 +151,7 @@ func CreateIsiQuota(
 	}
 	data := &IsiQuotaReq{
 		Enforced:                  true,
-		IncludeSnapshots:          false,
+		IncludeSnapshots:          includeSnapshots,
 		Path:                      path,
 		Container:                 container,
 		ThresholdsIncludeOverhead: false,
@@ -170,7 +171,7 @@ func SetIsiQuotaHardThreshold(
 	client api.Client,
 	path string, size, softLimit, advisoryLimit, softGracePrd int64,
 ) (string, error) {
-	return CreateIsiQuota(ctx, client, path, false, size, softLimit, advisoryLimit, softGracePrd)
+	return CreateIsiQuota(ctx, client, path, false, size, softLimit, advisoryLimit, softGracePrd, true)
 }
 
 // UpdateIsiQuotaHardThreshold modifies the hard threshold of a quota for a directory

api/v14/api_v14.go

@@ -17,5 +17,6 @@ limitations under the License.
 package v14
 
 const (
-	clusterAcsPath = "platform/14/cluster/acs"
+	clusterAcsPath       = "platform/14/cluster/acs"
+	writableSnapshotPath = "platform/14/snapshot/writable"
 )

api/v14/api_v14_snapshots.go

@@ -0,0 +1,122 @@
+/*
+Copyright (c) 2025 Dell Inc, or its subsidiaries.
+
+Licensed under the Apache License, Version 2.0 (the "License");
+you may not use this file except in compliance with the License.
+You may obtain a copy of the License at
+
+	http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software
+distributed under the License is distributed on an "AS IS" BASIS,
+WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+See the License for the specific language governing permissions and
+limitations under the License.
+*/
+
+package v14
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/dell/goisilon/api"
+)
+
+// GetIsiWritableSnapshots retrieves a list of writable snapshots.
+//
+// ctx: the context.
+// client: the API client.
+// Returns a list of writable snapshots and an error in case of failure.
+func GetIsiWritableSnapshots(
+	ctx context.Context,
+	client api.Client,
+) ([]*IsiWritableSnapshot, error) {
+	var resp *IsiWritableSnapshotQueryResponse
+	err := client.Get(ctx, writableSnapshotPath, "", nil, nil, &resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get writable snapshots from array: %v", err)
+	}
+
+	result := make([]*IsiWritableSnapshot, 0, resp.Total)
+	result = append(result, resp.Writable...)
+
+	for {
+		if resp.Resume == "" {
+			break
+		}
+
+		query := api.OrderedValues{
+			{[]byte("resume"), []byte(resp.Resume)},
+		}
+
+		resp = nil
+		err = client.Get(ctx, writableSnapshotPath, "", query, nil, &resp)
+		if err != nil {
+			return nil, fmt.Errorf("failed to get writable snapshots (query mode) from array: %v", err)
+		}
+
+		result = append(result, resp.Writable...)
+	}
+
+	return result, err
+}
+
+// GetIsiWritableSnapshot retrieves a writable snapshot.
+//
+// ctx: the context.
+// client: the API client.
+// snapshotPath: the path of the snapshot.
+//
+// Returns the snapshot on success and error in case of failure.
+func GetIsiWritableSnapshot(
+	ctx context.Context,
+	client api.Client,
+	snapshotPath string,
+) (*IsiWritableSnapshot, error) {
+	var resp *IsiWritableSnapshotQueryResponse
+	err := client.Get(ctx, writableSnapshotPath+snapshotPath, "", nil, nil, &resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to get writable snapshot: %v", err)
+	}
+
+	return resp.Writable[0], nil
+}
+
+// CreateWritableSnapshot creates a writable snapshot.
+//
+// ctx: the context.
+// client: the API client.
+// sourceSnapshot: the source snapshot name or ID.
+// destination: the destination path, must not be nested under the source snapshot.
+//
+// Returns the response and error.
+func CreateWritableSnapshot(
+	ctx context.Context,
+	client api.Client,
+	sourceSnapshot string,
+	destination string,
+) (resp *IsiWritableSnapshot, err error) {
+	// PAPI calls: PUT https://1.2.3.4:8080//platform/14/snapshot/writable
+	//             Body: {"src_snap": sourceSnapshot, "dst_path": destination}
+
+	body := map[string]string{
+		"src_snap": sourceSnapshot,
+		"dst_path": destination,
+	}
+
+	err = client.Post(ctx, writableSnapshotPath, "", nil, nil, body, &resp)
+	if err != nil {
+		return nil, fmt.Errorf("failed to create writable snapshot: %v", err)
+	}
+
+	return resp, err
+}
+
+func RemoveWritableSnapshot(
+	ctx context.Context,
+	client api.Client,
+	snapshotPath string,
+) error {
+	return client.Delete(ctx, writableSnapshotPath+snapshotPath, "", nil, nil, nil)
+}

api/v14/api_v14_types.go

@@ -31,3 +31,40 @@ type IsiClusterAcs struct {
 	// list of unresponsive nodes serial number.
 	UnresponsiveSn []string `json:"unresponsive_sn,omitempty"`
 }
+
+const (
+	WritableSnapshotStateActive   = "active"
+	WritableSnapshotStateDeleting = "deleting"
+)
+
+// An IsiWritableSnapshot is a writable snapshot.
+type IsiWritableSnapshot struct {
+	// The Unix Epoch time the writable snapshot was created.
+	Created int64 `json:"created"`
+	// The /ifs path of user supplied source snapshot. This will be null for writable snapshots pending delete.
+	SrcPath string `json:"src_path"`
+	// The user supplied /ifs path of writable snapshot.
+	DstPath string `json:"dst_path"`
+	// The system ID given to the writable snapshot.
+	ID int64 `json:"id"`
+	// The system ID of the user supplied source snapshot.
+	SrcID int64 `json:"src_id"`
+	// The user supplied source snapshot name or ID. This will be null for writable snapshots pending delete.
+	SrcSnap string `json:"src_snap"`
+	// The sum in bytes of logical size of files in this writable snapshot.
+	LogSize int64 `json:"log_size"`
+	// The amount of storage in bytes used to store this writable snapshot.
+	PhysicalSize int64 `json:"phys_size"`
+	// Writable Snapshot state. [WritableSnapshotStateActive, WritableSnapshotStateDeleting]
+	State string `json:"state"`
+}
+
+// IsiWritableSnapshotQueryResponse is the response to a writable snapshot query.
+type IsiWritableSnapshotQueryResponse struct {
+	// Total number of items available.
+	Total int64 `json:"total,omitempty"`
+	// Used to continue a query. This is null for the last page.
+	Resume string `json:"resume,omitempty"`
+	// List of writable snapshots.
+	Writable []*IsiWritableSnapshot `json:"writable"`
+}

quota.go

@@ -86,19 +86,19 @@ func (c *Client) GetQuotaWithPath(ctx context.Context, path string) (Quota, erro
 // CreateQuota creates a new hard directory quota with the specified size
 // and container option
 func (c *Client) CreateQuota(
-	ctx context.Context, name string, container bool, size, softLimit, advisoryLimit, softGracePrd int64,
+	ctx context.Context, name string, container bool, size, softLimit, advisoryLimit, softGracePrd int64, includeSnapshots bool,
 ) (string, error) {
 	return api.CreateIsiQuota(
-		ctx, c.API, c.API.VolumePath(name), container, size, softLimit, advisoryLimit, softGracePrd)
+		ctx, c.API, c.API.VolumePath(name), container, size, softLimit, advisoryLimit, softGracePrd, includeSnapshots)
 }
 
 // CreateQuotaWithPath creates a new hard directory quota with the specified size
 // and container option
 func (c *Client) CreateQuotaWithPath(
-	ctx context.Context, path string, container bool, size, softLimit, advisoryLimit, softGracePrd int64,
+	ctx context.Context, path string, container bool, size, softLimit, advisoryLimit, softGracePrd int64, includeSnapshots bool,
 ) (string, error) {
 	return api.CreateIsiQuota(
-		ctx, c.API, path, container, size, softLimit, advisoryLimit, softGracePrd)
+		ctx, c.API, path, container, size, softLimit, advisoryLimit, softGracePrd, includeSnapshots)
 }
 
 // SetQuotaSize sets the max size (hard threshold) of a quota for a volume

snapshots.go

@@ -25,6 +25,7 @@ import (
 	"strings"
 
 	api "github.com/dell/goisilon/api/v1"
+	apiv14 "github.com/dell/goisilon/api/v14"
 )
 
 const (
@@ -38,6 +39,12 @@ type SnapshotList []*api.IsiSnapshot
 // Snapshot represents an Isilon snapshot.
 type Snapshot *api.IsiSnapshot
 
+// WritableSnapshot represents an Isilon writable snapshot.
+type WritableSnapshot *apiv14.IsiWritableSnapshot
+
+// WritableSnapshotList represents a list of Isilon writable snapshots.
+type WritableSnapshotList []*apiv14.IsiWritableSnapshot
+
 // GetSnapshots returns a list of snapshots from the cluster.
 func (c *Client) GetSnapshots(ctx context.Context) (SnapshotList, error) {
 	snapshots, err := api.GetIsiSnapshots(ctx, c.API)
@@ -259,3 +266,63 @@ func (c *Client) GetSnapshotIsiPath(
 	}
 	return path.Join(zone.Path, snapShot, snapshot.Name, path.Base(snapshot.Path)), nil
 }
+
+// CreateWritableSnapshot creates a writable snapshot.
+//
+// ctx: the context.
+// sourceSnapshot: the source snapshot name or ID.
+// destination: the destination path, must not be nested under the source snapshot.
+//
+// Returns the snapshot on success and error in case of failure.
+func (c *Client) CreateWritableSnapshot(
+	ctx context.Context,
+	sourceSnapshot string,
+	destination string,
+) (WritableSnapshot, error) {
+	return apiv14.CreateWritableSnapshot(ctx, c.API, sourceSnapshot, destination)
+}
+
+// RemoveWritableSnapshot removes a writable snapshot.
+//
+// ctx: the context.
+// snapshotPath: the path of the snapshot.
+//
+// Returns an error on failure.
+func (c *Client) RemoveWritableSnapshot(
+	ctx context.Context,
+	snapshotPath string,
+) error {
+	if !strings.HasPrefix(snapshotPath, "/ifs/") {
+		return fmt.Errorf("invalid snapshot path, must start with /ifs/: %s", snapshotPath)
+	}
+
+	return apiv14.RemoveWritableSnapshot(ctx, c.API, snapshotPath)
+}
+
+// GetWritableSnapshot retrieves a writable snapshot.
+//
+// ctx: the context.
+// snapshotPath: the path of the snapshot.
+//
+// Returns the snapshot on success and error in case of failure.
+func (c *Client) GetWritableSnapshot(
+	ctx context.Context,
+	snapshotPath string,
+) (WritableSnapshot, error) {
+	if !strings.HasPrefix(snapshotPath, "/ifs/") {
+		return nil, fmt.Errorf("invalid snapshot path, must start with /ifs/: %s", snapshotPath)
+	}
+
+	return apiv14.GetIsiWritableSnapshot(ctx, c.API, snapshotPath)
+}
+
+// GetWritableSnapshots retrieves a list of all writable snapshots.
+//
+// ctx: the context.
+//
+// Returns the list of writable snapshots and an error in case of failure.
+func (c *Client) GetWritableSnapshots(
+	ctx context.Context,
+) (WritableSnapshotList, error) {
+	return apiv14.GetIsiWritableSnapshots(ctx, c.API)
+}