github/containerd
2
0
Fork 0
Code Issues Pull Requests Packages Projects Releases 2 Wiki Activity

improve rollback for overlay.prepare

Browse Source 
improve err message
Signed-off-by: yason <yan.xuean@zte.com.cn>
This commit is contained in:
yason 2017-12-01 23:24:48 +08:00
parent 16a2177ae3
commit bb02302c9c
2 changed files with 21 additions and 25 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

26
snapshots/overlay/overlay.go
View File

@ -287,41 +287,37 @@ func (o *snapshotter) createSnapshot(ctx context.Context, kind snapshots.Kind, k
if err != nil { if err != nil {
return nil, err return nil, err
} }
isRollback := true
defer func() {
if isRollback {
if rerr := t.Rollback(); rerr != nil {
log.G(ctx).WithError(rerr).Warn("Failure rolling back transaction")
}
}
}()
s, err := storage.CreateSnapshot(ctx, kind, key, parent, opts...) s, err := storage.CreateSnapshot(ctx, kind, key, parent, opts...)
if err != nil { if err != nil {
if rerr := t.Rollback(); rerr != nil { return nil, errors.Wrap(err, "failed to create snapshot")
log.G(ctx).WithError(rerr).Warn("Failure rolling back transaction")
}
return nil, errors.Wrap(err, "failed to create active")
} }
if len(s.ParentIDs) > 0 { if len(s.ParentIDs) > 0 {
st, err := os.Stat(filepath.Join(o.upperPath(s.ParentIDs[0]))) st, err := os.Stat(o.upperPath(s.ParentIDs[0]))
if err != nil { if err != nil {
if rerr := t.Rollback(); rerr != nil {
log.G(ctx).WithError(rerr).Warn("Failure rolling back transaction")
}
return nil, errors.Wrap(err, "failed to stat parent") return nil, errors.Wrap(err, "failed to stat parent")
} }
stat := st.Sys().(*syscall.Stat_t) stat := st.Sys().(*syscall.Stat_t)
if err := os.Lchown(fs, int(stat.Uid), int(stat.Gid)); err != nil { if err := os.Lchown(fs, int(stat.Uid), int(stat.Gid)); err != nil {
if rerr := t.Rollback(); rerr != nil {
log.G(ctx).WithError(rerr).Warn("Failure rolling back transaction")
}
return nil, errors.Wrap(err, "failed to chown") return nil, errors.Wrap(err, "failed to chown")
} }
} }
path = filepath.Join(snapshotDir, s.ID) path = filepath.Join(snapshotDir, s.ID)
if err = os.Rename(td, path); err != nil { if err = os.Rename(td, path); err != nil {
if rerr := t.Rollback(); rerr != nil {
log.G(ctx).WithError(rerr).Warn("Failure rolling back transaction")
}
return nil, errors.Wrap(err, "failed to rename") return nil, errors.Wrap(err, "failed to rename")
} }
isRollback = false
td = "" td = ""
if err = t.Commit(); err != nil { if err = t.Commit(); err != nil {

12
snapshots/storage/bolt.go
View File

@ -207,11 +207,11 @@ func CreateSnapshot(ctx context.Context, kind snapshots.Kind, key, parent string
if parent != "" { if parent != "" {
spbkt = bkt.Bucket([]byte(parent)) spbkt = bkt.Bucket([]byte(parent))
if spbkt == nil { if spbkt == nil {
return errors.Wrap(errdefs.ErrNotFound, "missing parent bucket") return errors.Wrapf(errdefs.ErrNotFound, "missing parent %q bucket", parent)
} }
if readKind(spbkt) != snapshots.KindCommitted { if readKind(spbkt) != snapshots.KindCommitted {
return errors.Wrap(errdefs.ErrInvalidArgument, "parent is not committed snapshot") return errors.Wrapf(errdefs.ErrInvalidArgument, "parent %q is not committed snapshot", parent)
} }
} }
sbkt, err := bkt.CreateBucket([]byte(key)) sbkt, err := bkt.CreateBucket([]byte(key))
@ -224,7 +224,7 @@ func CreateSnapshot(ctx context.Context, kind snapshots.Kind, key, parent string
id, err := bkt.NextSequence() id, err := bkt.NextSequence()
if err != nil { if err != nil {
return errors.Wrap(err, "unable to get identifier") return errors.Wrapf(err, "unable to get identifier for snapshot %q", key)
} }
t := time.Now().UTC() t := time.Now().UTC()
@ -245,12 +245,12 @@ func CreateSnapshot(ctx context.Context, kind snapshots.Kind, key, parent string
// Store a backlink from the key to the parent. Store the snapshot name // Store a backlink from the key to the parent. Store the snapshot name
// as the value to allow following the backlink to the snapshot value. // as the value to allow following the backlink to the snapshot value.
if err := pbkt.Put(parentKey(pid, id), []byte(key)); err != nil { if err := pbkt.Put(parentKey(pid, id), []byte(key)); err != nil {
return errors.Wrap(err, "failed to write parent link") return errors.Wrapf(err, "failed to write parent link for snapshot %q", key)
} }
s.ParentIDs, err = parents(bkt, spbkt, pid) s.ParentIDs, err = parents(bkt, spbkt, pid)
if err != nil { if err != nil {
return errors.Wrap(err, "failed to get parent chain") return errors.Wrapf(err, "failed to get parent chain for snapshot %q", key)
} }
} }
@ -438,7 +438,7 @@ func createBucketIfNotExists(ctx context.Context, fn func(context.Context, *bolt
} }
pbkt, err := bkt.CreateBucketIfNotExists(bucketKeyParents) pbkt, err := bkt.CreateBucketIfNotExists(bucketKeyParents)
if err != nil { if err != nil {
return errors.Wrap(err, "failed to create snapshots bucket") return errors.Wrap(err, "failed to create parents bucket")
} }
return fn(ctx, sbkt, pbkt) return fn(ctx, sbkt, pbkt)
} }