Esempio n. 1
0
func (vd *volDriver) parseSnapID(r *http.Request) (api.SnapID, error) {
	vars := mux.Vars(r)
	if id, ok := vars["id"]; ok {
		return api.SnapID(id), nil
	}
	return api.BadSnapID, fmt.Errorf("could not parse snap ID")
}
Esempio n. 2
0
// Snap specified volume. IO to the underlying volume should be quiesced before
// calling this function.
// Errors ErrEnoEnt may be returned
func (v *volumeClient) Snapshot(volumeID api.VolumeID, labels api.Labels) (api.SnapID, error) {

	var response api.SnapCreateResponse
	createReq := api.SnapCreateRequest{
		ID:     volumeID,
		Labels: labels,
	}
	err := v.c.Post().Resource(snapPath).Body(&createReq).Do().Unmarshal(&response)
	if err != nil {
		return api.SnapID(""), err
	}
	if response.Error != "" {
		return api.SnapID(""), errors.New(response.Error)
	}
	return response.ID, nil
}
Esempio n. 3
0
func TestSnapEnumerate(t *testing.T) {
	snapID := api.SnapID(snapName)
	id := api.VolumeID(volName)
	vol := api.Volume{
		ID:      id,
		Locator: api.VolumeLocator{Name: volName, VolumeLabels: labels},
		State:   api.VolumeAvailable,
		Spec:    &api.VolumeSpec{},
	}
	err := store.CreateVol(&vol)
	assert.NoError(t, err, "Failed in CreateVol")
	snap := api.VolumeSnap{
		ID:         snapID,
		VolumeID:   id,
		SnapLabels: labels,
	}
	err = store.CreateSnap(&snap)
	assert.NoError(t, err, "Failed in CreateSnap")

	snaps, err := store.SnapEnumerate(api.VolumeLocator{Name: volName}, nil)
	assert.NoError(t, err, "Failed in Enumerate")
	assert.Equal(t, len(snaps), 1, "Number of snaps returned in enumerate should be 1")
	if len(snaps) == 1 {
		assert.Equal(t, snaps[0].ID, snap.ID, "Invalid snap returned in Enumerate")
	}
	snaps, err = store.SnapEnumerate(api.VolumeLocator{VolumeLabels: labels}, nil)
	assert.NoError(t, err, "Failed in Enumerate")
	assert.Equal(t, len(snaps), 1, "Number of snaps returned in enumerate should be 1")
	if len(snaps) == 1 {
		assert.Equal(t, snaps[0].ID, snap.ID, "Invalid snap returned in Enumerate")
	}

	snaps, err = store.SnapEnumerate(api.VolumeLocator{}, labels)
	assert.NoError(t, err, "Failed in Enumerate")
	assert.True(t, len(snaps) >= 1, "Number of snaps returned in enumerate should be at least 1")
	if len(snaps) == 1 {
		assert.Equal(t, snaps[0].ID, snap.ID, "Invalid snap returned in Enumerate")
	}

	snaps, err = store.SnapEnumerate(api.VolumeLocator{}, nil)
	assert.NoError(t, err, "Failed in Enumerate")
	assert.True(t, len(snaps) >= 1, "Number of snaps returned in enumerate should be at least 1")
	if len(snaps) == 1 {
		assert.Equal(t, snaps[0].ID, snap.ID, "Invalid snap returned in Enumerate")
	}

	err = store.DeleteSnap(snapID)
	assert.NoError(t, err, "Failed in Delete")
	snaps, err = store.SnapEnumerate(api.VolumeLocator{Name: volName}, nil)
	assert.NotNil(t, snaps, "Inspect returned nil snaps")
	assert.Equal(t, len(snaps), 0, "Number of snaps returned in enumerate should be 0")

	err = store.DeleteVol(id)
	assert.NoError(t, err, "Failed in Delete")
}
Esempio n. 4
0
func snapInspect(t *testing.T, ctx *Context) {
	fmt.Println("snapInspect")

	snaps, err := ctx.SnapInspect([]api.SnapID{ctx.snapID})
	assert.NoError(t, err, "Failed in Inspect")
	assert.NotNil(t, snaps, "Nil snaps")
	assert.Equal(t, len(snaps), 1, "Expect 1 snaps actual %v snaps", len(snaps))
	assert.Equal(t, snaps[0].ID, ctx.snapID, "Expect snapID %v actual %v", ctx.snapID, snaps[0].ID)

	snaps, err = ctx.SnapInspect([]api.SnapID{api.SnapID("shouldNotExist")})
	assert.Equal(t, 0, len(snaps), "Expect 0 snaps actual %v snaps", len(snaps))
}
Esempio n. 5
0
func (vd *volDriver) snapEnumerate(w http.ResponseWriter, r *http.Request) {
	var err error
	var labels api.Labels
	var ids []api.VolumeID
	var snaps []api.VolumeSnap

	method := "snapEnumerate"
	d, err := volume.Get(vd.name)
	if err != nil {
		vd.notFound(w, r)
		return
	}
	params := r.URL.Query()
	v := params[string(api.OptLabel)]
	if v != nil {
		if err = json.Unmarshal([]byte(v[0]), &labels); err != nil {
			e := fmt.Errorf("Failed to parse parse VolumeLabels: %s", err.Error())
			vd.sendError(vd.name, method, w, e.Error(), http.StatusBadRequest)
		}
	}

	v, ok := params[string(api.OptSnapID)]
	if ok && v != nil {
		sids := make([]api.SnapID, len(params))
		for i, s := range v {
			sids[i] = api.SnapID(s)
		}
		snaps, err = d.SnapInspect(sids)
		if err != nil {
			e := fmt.Errorf("Failed to inspect snaps: %s", err.Error())
			vd.sendError(vd.name, method, w, e.Error(), http.StatusBadRequest)
			return
		}
	} else {
		v, ok = params[string(api.OptVolumeID)]
		if v != nil && ok {
			ids = make([]api.VolumeID, len(params))
			for i, s := range v {
				ids[i] = api.VolumeID(s)
			}
		}

		snaps, err = d.SnapEnumerate(ids, labels)
		if err != nil {
			e := fmt.Errorf("Failed to enumerate snaps: %s", err.Error())
			vd.sendError(vd.name, method, w, e.Error(), http.StatusBadRequest)
			return
		}
	}

	json.NewEncoder(w).Encode(snaps)
}
Esempio n. 6
0
func (v *volDriver) snapDelete(c *cli.Context) {
	fn := "delete"
	if len(c.Args()) < 1 {
		missingParameter(c, fn, "snapID", "Invalid number of arguments")
		return
	}
	v.volumeOptions(c)
	snapID := c.Args()[0]
	err := v.volDriver.SnapDelete(api.SnapID(snapID))
	if err != nil {
		cmdError(c, fn, err)
		return
	}

	fmtOutput(c, &Format{UUID: []string{c.Args()[0]}})
}
Esempio n. 7
0
// Snapshot create new subvolume from volume
func (d *driver) Snapshot(volumeID api.VolumeID, labels api.Labels) (api.SnapID, error) {
	snapID := uuid.New()

	snap := &api.VolumeSnap{
		ID:         api.SnapID(snapID),
		VolumeID:   volumeID,
		SnapLabels: labels,
		Ctime:      time.Now(),
	}
	err := d.CreateSnap(snap)
	if err != nil {
		return api.BadSnapID, err
	}
	chaos.Now(koStrayCreate)
	err = d.btrfs.Create(snapID, string(volumeID))
	if err != nil {
		return api.BadSnapID, err
	}
	return snap.ID, nil
}
Esempio n. 8
0
func (v *volDriver) snapInspect(c *cli.Context) {

	v.volumeOptions(c)
	fn := "inspect"
	if len(c.Args()) < 1 {
		missingParameter(c, fn, "snapID", "Invalid number of arguments")
		return
	}
	d := make([]api.SnapID, len(c.Args()))
	for i, v := range c.Args() {
		d[i] = api.SnapID(v)
	}

	snaps, err := v.volDriver.SnapInspect(d)
	if err != nil {
		cmdError(c, fn, err)
		return
	}

	cmdOutput(c, snaps)
}
Esempio n. 9
0
func (d *Driver) Snapshot(volumeID api.VolumeID, labels api.Labels) (api.SnapID, error) {
	dryRun := false
	awsID := string(volumeID)
	request := &ec2.CreateSnapshotInput{
		VolumeID: &awsID,
		DryRun:   &dryRun,
	}
	snap, err := d.ec2.CreateSnapshot(request)
	chaos.Now(koStrayCreate)
	volSnap := &api.VolumeSnap{
		ID:         api.SnapID(*snap.SnapshotID),
		VolumeID:   volumeID,
		SnapLabels: labels,
		Ctime:      time.Now(),
	}
	chaos.Now(koStrayCreate)
	err = d.CreateSnap(volSnap)
	if err != nil {
		return api.BadSnapID, err
	}
	return volSnap.ID, nil
}
Esempio n. 10
0
func TestSnapInspect(t *testing.T) {
	snapID := api.SnapID(snapName)
	id := api.VolumeID(volName)
	snap := api.VolumeSnap{
		ID:         snapID,
		VolumeID:   id,
		SnapLabels: labels,
	}
	err := store.CreateSnap(&snap)
	assert.NoError(t, err, "Failed in CreateSnap")

	snaps, err := store.SnapInspect([]api.SnapID{snapID})
	assert.NoError(t, err, "Failed in Inspect")
	assert.Equal(t, len(snaps), 1, "Number of snaps returned in Inspect should be 1")
	if len(snaps) == 1 {
		assert.Equal(t, snaps[0].ID, snap.ID, "Invalid snap returned in Enumerate")
	}

	err = store.DeleteSnap(snapID)
	assert.NoError(t, err, "Failed in Delete")
	snaps, err = store.SnapEnumerate(api.VolumeLocator{Name: volName}, nil)
	assert.Equal(t, len(snaps), 0, "Number of snaps returned in enumerate should be 1")
}