本文整理汇总了Golang中github.com/flynn/flynn/host/volume.Volume.Info方法的典型用法代码示例。如果您正苦于以下问题:Golang Volume.Info方法的具体用法?Golang Volume.Info怎么用?Golang Volume.Info使用的例子?那么恭喜您, 这里精选的方法代码示例或许可以为您提供帮助。您也可以进一步了解该方法所在类github.com/flynn/flynn/host/volume.Volume
的用法示例。
在下文中一共展示了Volume.Info方法的7个代码示例,这些例子默认根据受欢迎程度排序。您可以为喜欢或者感觉有用的代码点赞,您的评价将有助于系统推荐出更棒的Golang代码示例。
示例1: ForkVolume
func (p *Provider) ForkVolume(vol volume.Volume) (volume.Volume, error) {
zvol, err := p.owns(vol)
if err != nil {
return nil, err
}
if !vol.IsSnapshot() {
return nil, fmt.Errorf("can only fork a snapshot")
}
id := random.UUID()
info := &volume.Info{ID: id, Type: vol.Info().Type}
v2 := &zfsVolume{
info: info,
provider: zvol.provider,
basemount: p.mountPath(info),
}
cloneID := fmt.Sprintf("%s/%s", zvol.provider.dataset.Name, id)
v2.dataset, err = zvol.dataset.Clone(cloneID, map[string]string{
"mountpoint": v2.basemount,
})
if err != nil {
return nil, fmt.Errorf("could not fork volume: %s", err)
}
p.volumes[id] = v2
return v2, nil
}
示例2: DestroyVolume
func (b *Provider) DestroyVolume(vol volume.Volume) error {
zvol, err := b.owns(vol)
if err != nil {
return err
}
if vol.IsSnapshot() {
if err := syscall.Unmount(vol.Location(), 0); err != nil {
return err
}
os.Remove(vol.Location())
}
if err := zvol.dataset.Destroy(zfs.DestroyForceUmount); err != nil {
for i := 0; i < 5 && err != nil && IsDatasetBusyError(err); i++ {
// sometimes zfs will claim to be busy as if files are still open even when all container processes are dead.
// usually this goes away, so retry a few times.
time.Sleep(1 * time.Second)
err = zvol.dataset.Destroy(zfs.DestroyForceUmount)
}
if err != nil {
return err
}
}
os.Remove(zvol.basemount)
delete(b.volumes, vol.Info().ID)
return nil
}
示例3: owns
func (b *Provider) owns(vol volume.Volume) (*zfsVolume, error) {
zvol := b.volumes[vol.Info().ID]
if zvol == nil {
return nil, fmt.Errorf("volume does not belong to this provider")
}
if zvol != vol { // these pointers should be canonical
panic(fmt.Errorf("volume does not belong to this provider"))
}
return zvol, nil
}
示例4: ReceiveSnapshot
/*
ReceiveSnapshot both accepts a snapshotted filesystem as a byte stream,
and applies that state to the given `vol` (i.e., if this were git, it's like
`git fetch && git pull` at the same time; regretably, it's pretty hard to get
zfs to separate those operations). If there are local working changes in
the volume, they will be overwritten.
In addition to the given volume being mutated on disk, a reference to the
new snapshot will be returned (this can be used for cleanup, though be aware
that with zfs, removing snapshots may impact the ability to use incremental
deltas when receiving future snapshots).
Also note that ZFS is *extremely* picky about receiving snapshots; in
addition to obvious failure modes like an incremental snapshot with
insufficient data, the following complications apply:
- Sending an incremental snapshot with too much history will fail.
- Sending a full snapshot to a volume with any other snapshots will fail.
In the former case, you can renegociate; in the latter, you will have to
either *destroy snapshots* or make a new volume.
*/
func (p *Provider) ReceiveSnapshot(vol volume.Volume, input io.Reader) (volume.Volume, error) {
zvol, err := p.owns(vol)
if err != nil {
return nil, err
}
// recv does the right thing with input either fresh or incremental.
// recv with the dataset name and no snapshot suffix means the snapshot name from farside is kept;
// this is important because though we've assigned it a new UUID, the zfs dataset name match is used for incr hinting.
var buf bytes.Buffer
recvCmd := exec.Command("zfs", "recv", "-F", zvol.dataset.Name)
recvCmd.Stdin = input
recvCmd.Stderr = &buf
if err := recvCmd.Run(); err != nil {
return nil, fmt.Errorf("zfs recv rejected snapshot data: %s (%s)", err, strings.TrimSpace(buf.String()))
}
// get the dataset reference back; whatever the latest snapshot is must be what we received
snapshots, err := zvol.dataset.Snapshots()
if err != nil {
return nil, err
}
if len(snapshots) == 0 {
// should never happen, unless someone else is racing the zfs controls
return nil, fmt.Errorf("zfs recv misplaced snapshot data")
}
snapds := snapshots[len(snapshots)-1]
// reassemble as a flynn volume for return
id := random.UUID()
info := &volume.Info{ID: id, Type: vol.Info().Type}
snap := &zfsVolume{
info: info,
provider: zvol.provider,
dataset: snapds,
basemount: p.mountPath(info),
}
if err := p.mountDataset(snap); err != nil {
return nil, err
}
p.volumes[id] = snap
return snap, nil
}
示例5: persistVolume
// Called to sync changes to disk when a volume is updated
func (m *Manager) persistVolume(tx *bolt.Tx, vol volume.Volume) error {
// Save the general volume info
volumesBucket := tx.Bucket([]byte("volumes"))
id := vol.Info().ID
k := []byte(id)
_, volExists := m.volumes[id]
if !volExists {
volumesBucket.Delete(k)
} else {
b, err := json.Marshal(vol.Info())
if err != nil {
return fmt.Errorf("failed to serialize volume info: %s", err)
}
err = volumesBucket.Put(k, b)
if err != nil {
return fmt.Errorf("could not persist volume info to boltdb: %s", err)
}
}
// Save any provider-specific metadata associated with the volume.
// These are saved per-provider since the deserialization is also only defined per-provider implementation.
providerBucket, err := m.getProviderBucket(tx, m.providerIDs[vol.Provider()])
if err != nil {
return fmt.Errorf("could not persist provider volume info to boltdb: %s", err)
}
providerVolumesBucket := providerBucket.Bucket([]byte("volumes"))
if !volExists {
providerVolumesBucket.Delete(k)
} else {
b, err := vol.Provider().MarshalVolumeState(id)
if err != nil {
return fmt.Errorf("failed to serialize provider volume info: %s", err)
}
err = providerVolumesBucket.Put(k, b)
if err != nil {
return fmt.Errorf("could not persist provider volume info to boltdb: %s", err)
}
}
return nil
}
示例6: CreateSnapshot
func (p *Provider) CreateSnapshot(vol volume.Volume) (volume.Volume, error) {
zvol, err := p.owns(vol)
if err != nil {
return nil, err
}
id := random.UUID()
info := &volume.Info{ID: id, Type: vol.Info().Type}
snap := &zfsVolume{
info: info,
provider: zvol.provider,
basemount: p.mountPath(info),
}
snap.dataset, err = zvol.dataset.Snapshot(id, false)
if err != nil {
return nil, err
}
if err := p.mountDataset(snap); err != nil {
return nil, err
}
p.volumes[id] = snap
return snap, nil
}
示例7: assertInfoEqual
func assertInfoEqual(c *C, volA, volB volume.Volume) {
c.Assert(volA.Info().ID, Equals, volB.Info().ID)
c.Assert(volA.Info().Type, Equals, volB.Info().Type)
c.Assert(volA.Info().Meta, DeepEquals, volB.Info().Meta)
c.Assert(volA.Info().CreatedAt.Equal(volB.Info().CreatedAt), Equals, true)
}