2016-05-13 06:51:48 +03:00
|
|
|
// Copyright 2015 The etcd Authors
|
2015-01-25 06:19:16 +03:00
|
|
|
//
|
|
|
|
// Licensed under the Apache License, Version 2.0 (the "License");
|
|
|
|
// you may not use this file except in compliance with the License.
|
|
|
|
// You may obtain a copy of the License at
|
|
|
|
//
|
|
|
|
// http://www.apache.org/licenses/LICENSE-2.0
|
|
|
|
//
|
|
|
|
// Unless required by applicable law or agreed to in writing, software
|
|
|
|
// distributed under the License is distributed on an "AS IS" BASIS,
|
|
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
|
|
// See the License for the specific language governing permissions and
|
|
|
|
// limitations under the License.
|
2014-10-18 02:41:22 +04:00
|
|
|
|
2015-11-18 07:54:10 +03:00
|
|
|
// Package snap stores raft nodes' states with snapshots.
|
2014-08-19 22:13:25 +04:00
|
|
|
package snap
|
|
|
|
|
|
|
|
import (
|
|
|
|
"errors"
|
|
|
|
"fmt"
|
|
|
|
"hash/crc32"
|
|
|
|
"io/ioutil"
|
|
|
|
"os"
|
|
|
|
"path"
|
|
|
|
"sort"
|
2014-08-21 00:15:08 +04:00
|
|
|
"strings"
|
2015-02-18 01:39:05 +03:00
|
|
|
"time"
|
2014-08-19 22:13:25 +04:00
|
|
|
|
2016-06-02 17:35:24 +03:00
|
|
|
pioutil "github.com/coreos/etcd/pkg/ioutil"
|
2014-11-05 23:14:42 +03:00
|
|
|
"github.com/coreos/etcd/pkg/pbutil"
|
2014-09-17 05:18:45 +04:00
|
|
|
"github.com/coreos/etcd/raft"
|
2014-09-04 03:33:41 +04:00
|
|
|
"github.com/coreos/etcd/raft/raftpb"
|
|
|
|
"github.com/coreos/etcd/snap/snappb"
|
2015-06-02 00:05:17 +03:00
|
|
|
|
2016-03-23 03:10:28 +03:00
|
|
|
"github.com/coreos/pkg/capnslog"
|
2014-08-19 22:13:25 +04:00
|
|
|
)
|
|
|
|
|
2014-08-21 00:15:08 +04:00
|
|
|
const (
|
|
|
|
snapSuffix = ".snap"
|
|
|
|
)
|
|
|
|
|
2014-08-19 22:13:25 +04:00
|
|
|
var (
|
2015-06-03 00:58:24 +03:00
|
|
|
plog = capnslog.NewPackageLogger("github.com/coreos/etcd", "snap")
|
2015-06-02 00:05:17 +03:00
|
|
|
|
2014-12-09 07:39:12 +03:00
|
|
|
ErrNoSnapshot = errors.New("snap: no available snapshot")
|
|
|
|
ErrEmptySnapshot = errors.New("snap: empty snapshot")
|
|
|
|
ErrCRCMismatch = errors.New("snap: crc mismatch")
|
|
|
|
crcTable = crc32.MakeTable(crc32.Castagnoli)
|
2016-04-04 03:28:04 +03:00
|
|
|
|
|
|
|
// A map of valid files that can be present in the snap folder.
|
|
|
|
validFiles = map[string]bool{
|
|
|
|
"db": true,
|
|
|
|
}
|
2014-08-19 22:13:25 +04:00
|
|
|
)
|
|
|
|
|
|
|
|
type Snapshotter struct {
|
|
|
|
dir string
|
|
|
|
}
|
|
|
|
|
|
|
|
func New(dir string) *Snapshotter {
|
|
|
|
return &Snapshotter{
|
|
|
|
dir: dir,
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-10-29 20:42:21 +03:00
|
|
|
func (s *Snapshotter) SaveSnap(snapshot raftpb.Snapshot) error {
|
2014-09-17 05:18:45 +04:00
|
|
|
if raft.IsEmptySnap(snapshot) {
|
2014-10-29 20:42:21 +03:00
|
|
|
return nil
|
2014-09-17 05:18:45 +04:00
|
|
|
}
|
2014-10-29 20:42:21 +03:00
|
|
|
return s.save(&snapshot)
|
2014-09-17 05:18:45 +04:00
|
|
|
}
|
|
|
|
|
|
|
|
func (s *Snapshotter) save(snapshot *raftpb.Snapshot) error {
|
2015-02-18 01:39:05 +03:00
|
|
|
start := time.Now()
|
|
|
|
|
2014-11-20 00:17:50 +03:00
|
|
|
fname := fmt.Sprintf("%016x-%016x%s", snapshot.Metadata.Term, snapshot.Metadata.Index, snapSuffix)
|
2014-11-05 23:14:42 +03:00
|
|
|
b := pbutil.MustMarshal(snapshot)
|
2014-08-19 22:13:25 +04:00
|
|
|
crc := crc32.Update(0, crcTable, b)
|
2014-09-04 03:33:41 +04:00
|
|
|
snap := snappb.Snapshot{Crc: crc, Data: b}
|
2014-08-19 22:13:25 +04:00
|
|
|
d, err := snap.Marshal()
|
|
|
|
if err != nil {
|
|
|
|
return err
|
2015-08-20 04:58:29 +03:00
|
|
|
} else {
|
2015-10-17 22:57:18 +03:00
|
|
|
marshallingDurations.Observe(float64(time.Since(start)) / float64(time.Second))
|
2014-08-19 22:13:25 +04:00
|
|
|
}
|
2015-08-20 04:58:29 +03:00
|
|
|
|
2016-06-02 17:35:24 +03:00
|
|
|
err = pioutil.WriteAndSyncFile(path.Join(s.dir, fname), d, 0666)
|
2015-07-16 19:52:10 +03:00
|
|
|
if err == nil {
|
2015-10-17 22:57:18 +03:00
|
|
|
saveDurations.Observe(float64(time.Since(start)) / float64(time.Second))
|
2016-06-02 17:35:24 +03:00
|
|
|
} else {
|
|
|
|
err1 := os.Remove(path.Join(s.dir, fname))
|
|
|
|
if err1 != nil {
|
|
|
|
plog.Errorf("failed to remove broken snapshot file %s", path.Join(s.dir, fname))
|
|
|
|
}
|
2015-02-18 01:39:05 +03:00
|
|
|
}
|
|
|
|
return err
|
2014-08-19 22:13:25 +04:00
|
|
|
}
|
|
|
|
|
2014-09-04 03:33:41 +04:00
|
|
|
func (s *Snapshotter) Load() (*raftpb.Snapshot, error) {
|
2014-08-20 08:08:29 +04:00
|
|
|
names, err := s.snapNames()
|
2014-08-19 22:13:25 +04:00
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2014-09-04 03:33:41 +04:00
|
|
|
var snap *raftpb.Snapshot
|
2014-08-19 22:13:25 +04:00
|
|
|
for _, name := range names {
|
2014-08-21 00:42:23 +04:00
|
|
|
if snap, err = loadSnap(s.dir, name); err == nil {
|
|
|
|
break
|
2014-08-19 22:13:25 +04:00
|
|
|
}
|
2014-08-21 00:42:23 +04:00
|
|
|
}
|
2015-04-14 19:43:58 +03:00
|
|
|
if err != nil {
|
|
|
|
return nil, ErrNoSnapshot
|
|
|
|
}
|
|
|
|
return snap, nil
|
2014-08-21 00:42:23 +04:00
|
|
|
}
|
|
|
|
|
2014-09-04 03:33:41 +04:00
|
|
|
func loadSnap(dir, name string) (*raftpb.Snapshot, error) {
|
2014-08-21 00:42:23 +04:00
|
|
|
fpath := path.Join(dir, name)
|
2015-02-11 21:21:19 +03:00
|
|
|
snap, err := Read(fpath)
|
|
|
|
if err != nil {
|
|
|
|
renameBroken(fpath)
|
|
|
|
}
|
|
|
|
return snap, err
|
|
|
|
}
|
2014-08-21 00:42:23 +04:00
|
|
|
|
2015-02-11 21:21:19 +03:00
|
|
|
// Read reads the snapshot named by snapname and returns the snapshot.
|
|
|
|
func Read(snapname string) (*raftpb.Snapshot, error) {
|
|
|
|
b, err := ioutil.ReadFile(snapname)
|
2014-08-19 22:13:25 +04:00
|
|
|
if err != nil {
|
2015-06-03 00:58:24 +03:00
|
|
|
plog.Errorf("cannot read file %v: %v", snapname, err)
|
2014-08-21 00:42:23 +04:00
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
|
2015-06-30 02:05:55 +03:00
|
|
|
if len(b) == 0 {
|
|
|
|
plog.Errorf("unexpected empty snapshot")
|
|
|
|
return nil, ErrEmptySnapshot
|
|
|
|
}
|
|
|
|
|
2014-09-04 03:33:41 +04:00
|
|
|
var serializedSnap snappb.Snapshot
|
2014-08-21 00:42:23 +04:00
|
|
|
if err = serializedSnap.Unmarshal(b); err != nil {
|
2015-06-03 00:58:24 +03:00
|
|
|
plog.Errorf("corrupted snapshot file %v: %v", snapname, err)
|
2014-08-21 00:42:23 +04:00
|
|
|
return nil, err
|
|
|
|
}
|
2014-12-09 07:39:12 +03:00
|
|
|
|
|
|
|
if len(serializedSnap.Data) == 0 || serializedSnap.Crc == 0 {
|
2015-06-03 00:58:24 +03:00
|
|
|
plog.Errorf("unexpected empty snapshot")
|
2014-12-09 07:39:12 +03:00
|
|
|
return nil, ErrEmptySnapshot
|
|
|
|
}
|
|
|
|
|
2014-08-21 00:42:23 +04:00
|
|
|
crc := crc32.Update(0, crcTable, serializedSnap.Data)
|
|
|
|
if crc != serializedSnap.Crc {
|
2015-06-03 00:58:24 +03:00
|
|
|
plog.Errorf("corrupted snapshot file %v: crc mismatch", snapname)
|
2014-12-09 07:39:12 +03:00
|
|
|
return nil, ErrCRCMismatch
|
2014-08-21 00:42:23 +04:00
|
|
|
}
|
|
|
|
|
2014-09-04 03:33:41 +04:00
|
|
|
var snap raftpb.Snapshot
|
|
|
|
if err = snap.Unmarshal(serializedSnap.Data); err != nil {
|
2015-06-03 00:58:24 +03:00
|
|
|
plog.Errorf("corrupted snapshot file %v: %v", snapname, err)
|
2014-08-19 22:13:25 +04:00
|
|
|
return nil, err
|
|
|
|
}
|
2014-08-20 02:41:52 +04:00
|
|
|
return &snap, nil
|
2014-08-19 22:13:25 +04:00
|
|
|
}
|
2014-08-20 08:08:29 +04:00
|
|
|
|
|
|
|
// snapNames returns the filename of the snapshots in logical time order (from newest to oldest).
|
2014-12-05 01:12:55 +03:00
|
|
|
// If there is no available snapshots, an ErrNoSnapshot will be returned.
|
2014-08-20 08:08:29 +04:00
|
|
|
func (s *Snapshotter) snapNames() ([]string, error) {
|
|
|
|
dir, err := os.Open(s.dir)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
|
|
|
defer dir.Close()
|
|
|
|
names, err := dir.Readdirnames(-1)
|
|
|
|
if err != nil {
|
|
|
|
return nil, err
|
|
|
|
}
|
2014-08-21 00:15:08 +04:00
|
|
|
snaps := checkSuffix(names)
|
|
|
|
if len(snaps) == 0 {
|
2014-08-20 08:08:29 +04:00
|
|
|
return nil, ErrNoSnapshot
|
|
|
|
}
|
2014-08-21 00:15:08 +04:00
|
|
|
sort.Sort(sort.Reverse(sort.StringSlice(snaps)))
|
|
|
|
return snaps, nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func checkSuffix(names []string) []string {
|
|
|
|
snaps := []string{}
|
|
|
|
for i := range names {
|
|
|
|
if strings.HasSuffix(names[i], snapSuffix) {
|
|
|
|
snaps = append(snaps, names[i])
|
|
|
|
} else {
|
2016-04-04 03:28:04 +03:00
|
|
|
// If we find a file which is not a snapshot then check if it's
|
|
|
|
// a vaild file. If not throw out a warning.
|
|
|
|
if _, ok := validFiles[names[i]]; !ok {
|
|
|
|
plog.Warningf("skipped unexpected non snapshot file %v", names[i])
|
|
|
|
}
|
2014-08-21 00:15:08 +04:00
|
|
|
}
|
|
|
|
}
|
|
|
|
return snaps
|
|
|
|
}
|
|
|
|
|
|
|
|
func renameBroken(path string) {
|
|
|
|
brokenPath := path + ".broken"
|
|
|
|
if err := os.Rename(path, brokenPath); err != nil {
|
2015-06-03 00:58:24 +03:00
|
|
|
plog.Warningf("cannot rename broken snapshot file %v to %v: %v", path, brokenPath, err)
|
2014-08-21 00:15:08 +04:00
|
|
|
}
|
2014-08-20 08:08:29 +04:00
|
|
|
}
|