"strings"

"github.com/NVIDIA/aistore/cmn"

Flags: []cli.Flag{verbObjPrefixFlag},

bck, objName, err := parseBckObjURI(c, uri, false)

var prefix string

if flagIsSet(c, verbObjPrefixFlag) {

prefix = parseStrFlag(c, verbObjPrefixFlag)

if strings.HasSuffix(objName, "/") {

if prefix != "" && prefix != objName {

return fmt.Errorf("prefix %q vs prefix %q ambiguity", prefix, objName)

}

prefix = objName

return _checkLockMany(c, bck, prefix, uri)

}

lockState, err := _checkLockOne(bck, objName)

if err != nil {

return err

}

fmt.Fprintf(c.App.Writer, "%s: %s\n", uri, lockState)

return nil

}

func _checkLockMany(c *cli.Context, bck cmn.Bck, prefix, uri string) error {

// List objects with the given prefix

msg := &apc.LsoMsg{

Prefix: prefix,

Props: apc.GetPropsName, // Only need object names

}

objList, err := api.ListObjects(apiBP, bck, msg, api.ListArgs{})

if len(objList.Entries) == 0 {

fmt.Fprintf(c.App.ErrWriter, "No objects found with prefix %q\n", uri)

return nil

}

for _, entry := range objList.Entries {

lockState, err := _checkLockOne(bck, entry.Name)

if err != nil {

warn := fmt.Sprintf("%s: %v", bck.Cname(entry.Name), err)

actionWarn(c, warn)

continue

}

fmt.Fprintf(c.App.Writer, "%s: %s\n", bck.Cname(entry.Name), lockState)

}

return nil

}

func _checkLockOne(bck cmn.Bck, objName string) (string, error) {

lockState, err := api.CheckObjectLock(apiBP, bck, objName)

if err != nil {

return "", V(err)

}

return "unlocked", nil

return "read-locked", nil

return "write-locked", nil

return "", fmt.Errorf("unexpected return from 'api.CheckObjectLock': %d", lockState)

Prefix-based (multi-object) selection is also supported:

$ ais advanced check-lock --help

For illustration purposes, the directory in question will contain only two objects: