func TestNotFound(t *testing.T) {
conn, _ := rados.NewConn()
conn.ReadDefaultConfigFile()
conn.Connect()
poolname := GetUUID()
err := conn.MakePool(poolname)
assert.NoError(t, err)
ioctx, err := conn.OpenIOContext(poolname)
assert.NoError(t, err)
name := GetUUID()
img := rbd.GetImage(ioctx, name)
err = img.Open()
assert.Equal(t, err, rbd.RbdErrorNotFound)
img.Remove()
assert.Equal(t, err, rbd.RbdErrorNotFound)
ioctx.Destroy()
conn.DeletePool(poolname)
conn.Shutdown()
}
// FIXME: getting panics when trying to run below go-ceph code, at ListLockers():
//
// see https://github.com/yp-engineering/rbd-docker-plugin/issues/3
//
func (d *cephRBDVolumeDriver) goceph_rbdImageIsLocked(pool, name string) (bool, error) {
if pool == "" || name == "" {
return true, errors.New("rbdImageIsLocked: pool and name required")
}
// make the image struct
rbdImage := rbd.GetImage(d.ioctx, name)
// open it (read-only)
err := rbdImage.Open(true)
if err != nil {
log.Printf("ERROR: opening rbd image(%s): %s", name, err)
return true, err
}
defer rbdImage.Close()
// check for locks -- for our purposes, with even one lock we consider image locked
//lockers := []rbd.Locker{}
//lockers := make([]rbd.Locker, 10)
tag, lockers, err := rbdImage.ListLockers()
if err != nil {
log.Printf("ERROR: retrieving Lockers list for Image(%s): %s", name, err)
return true, err
}
if len(lockers) > 0 {
log.Printf("WARN: RBD Image is locked: tag=%s, lockers=%q", tag, lockers)
return true, nil
}
return false, nil
}
func (d *cephRBDVolumeDriver) goceph_renameRBDImage(pool, name, newname string) error {
// build image struct
rbdImage := rbd.GetImage(d.ioctx, name)
// rename the block device image
return rbdImage.Rename(newname)
}
// lockImage locks image and returns locker cookie name
func (d *cephRBDVolumeDriver) lockImage(pool, imagename string) (string, error) {
log.Printf("INFO: lockImage(%s/%s)", pool, imagename)
ctx, err := d.openContext(pool)
if err != nil {
return "", err
}
defer d.shutdownContext(ctx)
// build image struct
rbdImage := rbd.GetImage(ctx, imagename)
// open it (read-only)
err = rbdImage.Open(true)
if err != nil {
log.Printf("ERROR: opening rbd image(%s): %s", imagename, err)
return "", err
}
defer rbdImage.Close()
// lock it using hostname
locker := d.localLockerCookie()
err = rbdImage.LockExclusive(locker)
if err != nil {
return locker, err
}
return locker, nil
}
func (d *cephRBDVolumeDriver) goceph_unlockImage(pool, imagename, locker string) error {
// build image struct
rbdImage := rbd.GetImage(d.ioctx, imagename)
// open it (read-only)
//err := rbdImage.Open(true)
err := rbdImage.Open()
if err != nil {
log.Printf("ERROR: opening rbd image(%s): %s", imagename, err)
return err
}
defer rbdImage.Close()
return rbdImage.Unlock(locker)
}
func TestGetImageNames(t *testing.T) {
conn, _ := rados.NewConn()
conn.ReadDefaultConfigFile()
conn.Connect()
poolname := GetUUID()
err := conn.MakePool(poolname)
assert.NoError(t, err)
ioctx, err := conn.OpenIOContext(poolname)
assert.NoError(t, err)
createdList := []string{}
for i := 0; i < 10; i++ {
name := GetUUID()
_, err := rbd.Create(ioctx, name, 1<<22, 22)
assert.NoError(t, err)
createdList = append(createdList, name)
}
imageNames, err := rbd.GetImageNames(ioctx)
assert.NoError(t, err)
sort.Strings(createdList)
sort.Strings(imageNames)
assert.Equal(t, createdList, imageNames)
for _, name := range createdList {
img := rbd.GetImage(ioctx, name)
err := img.Remove()
assert.NoError(t, err)
}
ioctx.Destroy()
conn.DeletePool(poolname)
conn.Shutdown()
}
func (d *cephRBDVolumeDriver) goceph_rbdImageExists(pool, findName string) (bool, error) {
log.Printf("INFO: checking if rbdImageExists(%s/%s)", pool, findName)
if findName == "" {
return false, fmt.Errorf("Empty Ceph RBD Image name")
}
ctx, err := d.goceph_openContext(pool)
if err != nil {
return false, err
}
defer d.goceph_shutdownContext(ctx)
img := rbd.GetImage(ctx, findName)
err = img.Open(true)
defer img.Close()
if err != nil {
if err == rbd.RbdErrorNotFound {
log.Printf("INFO: Ceph RBD Image ('%s') not found: %s", findName, err)
return false, nil
}
return false, err
}
return true, nil
}
// unlockImage releases the exclusive lock on an image
func (d *cephRBDVolumeDriver) unlockImage(pool, imagename, locker string) error {
if locker == "" {
return errors.New(fmt.Sprintf("Unable to unlock image(%s/%s) for empty locker", pool, imagename))
}
log.Printf("INFO: unlockImage(%s/%s, %s)", pool, imagename, locker)
ctx, err := d.openContext(pool)
if err != nil {
return err
}
defer d.shutdownContext(ctx)
// build image struct
rbdImage := rbd.GetImage(ctx, imagename)
// open it (read-only)
err = rbdImage.Open(true)
if err != nil {
log.Printf("ERROR: opening rbd image(%s): %s", imagename, err)
return err
}
defer rbdImage.Close()
return rbdImage.Unlock(locker)
}
func TestParentInfo(t *testing.T) {
conn, _ := rados.NewConn()
conn.ReadDefaultConfigFile()
conn.Connect()
poolname := GetUUID()
err := conn.MakePool(poolname)
assert.NoError(t, err)
ioctx, err := conn.OpenIOContext(poolname)
assert.NoError(t, err)
name := "parent"
img, err := rbd.Create(ioctx, name, 1<<22, 22, 1)
assert.NoError(t, err)
err = img.Open()
assert.NoError(t, err)
snapshot, err := img.CreateSnapshot("mysnap")
assert.NoError(t, err)
err = snapshot.Protect()
assert.NoError(t, err)
// create an image context with the parent+snapshot
snapImg := rbd.GetImage(ioctx, "parent")
err = snapImg.Open("mysnap")
assert.NoError(t, err)
// ensure no children prior to clone
pools, images, err := snapImg.ListChildren()
assert.NoError(t, err)
assert.Equal(t, len(pools), 0, "pools equal")
assert.Equal(t, len(images), 0, "children length equal")
imgNew, err := img.Clone("mysnap", ioctx, "child", 1, 22)
assert.NoError(t, err)
err = imgNew.Open()
assert.NoError(t, err)
parentPool := make([]byte, 128)
parentName := make([]byte, 128)
parentSnapname := make([]byte, 128)
err = imgNew.GetParentInfo(parentPool, parentName, parentSnapname)
assert.NoError(t, err)
n := bytes.Index(parentName, []byte{0})
pName := string(parentName[:n])
n = bytes.Index(parentSnapname, []byte{0})
pSnapname := string(parentSnapname[:n])
assert.Equal(t, pName, "parent", "they should be equal")
assert.Equal(t, pSnapname, "mysnap", "they should be equal")
pools, images, err = snapImg.ListChildren()
assert.NoError(t, err)
assert.Equal(t, len(pools), 1, "pools equal")
assert.Equal(t, len(images), 1, "children length equal")
err = imgNew.Close()
assert.NoError(t, err)
err = imgNew.Remove()
assert.NoError(t, err)
err = snapshot.Unprotect()
assert.NoError(t, err)
err = snapshot.Remove()
assert.NoError(t, err)
err = img.Close()
assert.NoError(t, err)
err = snapImg.Close()
assert.NoError(t, err)
err = img.Remove()
assert.NoError(t, err)
ioctx.Destroy()
conn.DeletePool(poolname)
conn.Shutdown()
}
