// Load returns the data stored in the backend for h at the given offset and // saves it in p. Load has the same semantics as io.ReaderAt, with one // exception: when off is lower than zero, it is treated as an offset relative // to the end of the file. func (b *Local) Load(h restic.Handle, p []byte, off int64) (n int, err error) { debug.Log("Load %v, length %v at %v", h, len(p), off) if err := h.Valid(); err != nil { return 0, err } f, err := fs.Open(filename(b.p, h.Type, h.Name)) if err != nil { return 0, errors.Wrap(err, "Open") } defer func() { e := f.Close() if err == nil { err = errors.Wrap(e, "Close") } }() switch { case off > 0: _, err = f.Seek(off, 0) case off < 0: _, err = f.Seek(off, 2) } if err != nil { return 0, errors.Wrap(err, "Seek") } return io.ReadFull(f, p) }
// savePacker stores p in the backend. func (r *Repository) savePacker(p *pack.Packer) error { debug.Log("save packer with %d blobs\n", p.Count()) n, err := p.Finalize() if err != nil { return err } tmpfile := p.Writer().(*os.File) f, err := fs.Open(tmpfile.Name()) if err != nil { return errors.Wrap(err, "Open") } data := make([]byte, n) m, err := io.ReadFull(f, data) if err != nil { return errors.Wrap(err, "ReadFul") } if uint(m) != n { return errors.Errorf("read wrong number of bytes from %v: want %v, got %v", tmpfile.Name(), n, m) } if err = f.Close(); err != nil { return errors.Wrap(err, "Close") } id := restic.Hash(data) h := restic.Handle{Type: restic.DataFile, Name: id.String()} err = r.be.Save(h, data) if err != nil { debug.Log("Save(%v) error: %v", h, err) return err } debug.Log("saved as %v", h) err = fs.Remove(tmpfile.Name()) if err != nil { return errors.Wrap(err, "Remove") } // update blobs in the index for _, b := range p.Blobs() { debug.Log(" updating blob %v to pack %v", b.ID.Str(), id.Str()) r.idx.Current().Store(restic.PackedBlob{ Blob: restic.Blob{ Type: b.Type, ID: b.ID, Offset: b.Offset, Length: uint(b.Length), }, PackID: id, }) } return nil }
// NewHtpasswdFromFile reads the users and passwords from a htpasswd // file and returns them. If an error is encountered, it is returned, together // with a nil-Pointer for the HtpasswdFile. func NewHtpasswdFromFile(path string) (*HtpasswdFile, error) { r, err := fs.Open(path) if err != nil { return nil, err } defer r.Close() return NewHtpasswd(r) }
// readDirNames reads the directory named by dirname and returns // a sorted list of directory entries. // taken from filepath/path.go func readDirNames(dirname string) ([]string, error) { f, err := fs.Open(dirname) if err != nil { return nil, errors.Wrap(err, "Open") } names, err := f.Readdirnames(-1) f.Close() if err != nil { return nil, errors.Wrap(err, "Readdirnames") } sort.Strings(names) return names, nil }
// GetBlob returns a http.HandlerFunc that retrieves a blob // from the repository. func GetBlob(c *Context) http.HandlerFunc { return func(w http.ResponseWriter, r *http.Request) { vars := strings.Split(r.RequestURI, "/") dir := vars[1] name := vars[2] path := filepath.Join(c.path, dir, name) file, err := fs.Open(path) if err != nil { http.Error(w, "404 not found", 404) return } defer file.Close() http.ServeContent(w, r, "", time.Unix(0, 0), file) } }
func readdir(d string) (fileInfos []os.FileInfo, err error) { f, e := fs.Open(d) if e != nil { return nil, errors.Wrap(e, "Open") } defer func() { e := f.Close() if err == nil { err = errors.Wrap(e, "Close") } }() return f.Readdir(-1) }
func (node Node) restoreSymlinkTimestamps(path string, utimes [2]syscall.Timespec) error { dir, err := fs.Open(filepath.Dir(path)) defer dir.Close() if err != nil { return errors.Wrap(err, "Open") } times := []unix.Timespec{ {Sec: utimes[0].Sec, Nsec: utimes[0].Nsec}, {Sec: utimes[1].Sec, Nsec: utimes[1].Nsec}, } err = unix.UtimesNanoAt(int(dir.Fd()), filepath.Base(path), times, unix.AT_SYMLINK_NOFOLLOW) if err != nil { return errors.Wrap(err, "UtimesNanoAt") } return nil }
// SaveFile stores the content of the file on the backend as a Blob by calling // Save for each chunk. func (arch *Archiver) SaveFile(p *restic.Progress, node *restic.Node) (*restic.Node, error) { file, err := fs.Open(node.Path) defer file.Close() if err != nil { return node, errors.Wrap(err, "Open") } debug.RunHook("archiver.SaveFile", node.Path) node, err = arch.reloadFileIfChanged(node, file) if err != nil { return node, err } chnker := chunker.New(file, arch.repo.Config().ChunkerPolynomial) resultChannels := [](<-chan saveResult){} for { chunk, err := chnker.Next(getBuf()) if errors.Cause(err) == io.EOF { break } if err != nil { return node, errors.Wrap(err, "chunker.Next") } resCh := make(chan saveResult, 1) go arch.saveChunk(chunk, p, <-arch.blobToken, file, resCh) resultChannels = append(resultChannels, resCh) } results, err := waitForResults(resultChannels) if err != nil { return node, err } err = updateNodeContent(node, results) return node, err }
// SaveFile stores the content of the file on the backend as a Blob by calling // Save for each chunk. func (arch *Archiver) SaveFile(p *Progress, node *Node) error { file, err := fs.Open(node.path) defer file.Close() if err != nil { return err } node, err = arch.reloadFileIfChanged(node, file) if err != nil { return err } chnker := chunker.New(file, arch.repo.Config.ChunkerPolynomial) resultChannels := [](<-chan saveResult){} for { chunk, err := chnker.Next(getBuf()) if err == io.EOF { break } if err != nil { return errors.Annotate(err, "SaveFile() chunker.Next()") } resCh := make(chan saveResult, 1) go arch.saveChunk(chunk, p, <-arch.blobToken, file, resCh) resultChannels = append(resultChannels, resCh) } results, err := waitForResults(resultChannels) if err != nil { return err } err = updateNodeContent(node, results) return err }
func runBackup(opts BackupOptions, gopts GlobalOptions, args []string) error { target, err := readLinesFromFile(opts.FilesFrom) if err != nil { return err } // merge files from files-from into normal args so we can reuse the normal // args checks and have the ability to use both files-from and args at the // same time args = append(args, target...) if len(args) == 0 { return errors.Fatalf("wrong number of parameters") } for _, d := range args { if a, err := filepath.Abs(d); err == nil { d = a } target = append(target, d) } target, err = filterExisting(target) if err != nil { return err } // allowed devices var allowedDevs map[uint64]struct{} if opts.ExcludeOtherFS { allowedDevs, err = gatherDevices(target) if err != nil { return err } debug.Log("allowed devices: %v\n", allowedDevs) } repo, err := OpenRepository(gopts) if err != nil { return err } lock, err := lockRepo(repo) defer unlockRepo(lock) if err != nil { return err } err = repo.LoadIndex() if err != nil { return err } var parentSnapshotID *restic.ID // Force using a parent if !opts.Force && opts.Parent != "" { id, err := restic.FindSnapshot(repo, opts.Parent) if err != nil { return errors.Fatalf("invalid id %q: %v", opts.Parent, err) } parentSnapshotID = &id } // Find last snapshot to set it as parent, if not already set if !opts.Force && parentSnapshotID == nil { id, err := restic.FindLatestSnapshot(repo, target, "") if err == nil { parentSnapshotID = &id } else if err != restic.ErrNoSnapshotFound { return err } } if parentSnapshotID != nil { Verbosef("using parent snapshot %v\n", parentSnapshotID.Str()) } Verbosef("scan %v\n", target) // add patterns from file if opts.ExcludeFile != "" { file, err := fs.Open(opts.ExcludeFile) if err != nil { Warnf("error reading exclude patterns: %v", err) return nil } scanner := bufio.NewScanner(file) for scanner.Scan() { line := scanner.Text() if !strings.HasPrefix(line, "#") { line = os.ExpandEnv(line) opts.Excludes = append(opts.Excludes, line) } } } selectFilter := func(item string, fi os.FileInfo) bool { matched, err := filter.List(opts.Excludes, item) if err != nil { Warnf("error for exclude pattern: %v", err) } if matched { debug.Log("path %q excluded by a filter", item) return false } if !opts.ExcludeOtherFS || fi == nil { return true } id, err := fs.DeviceID(fi) if err != nil { // This should never happen because gatherDevices() would have // errored out earlier. If it still does that's a reason to panic. panic(err) } _, found := allowedDevs[id] if !found { debug.Log("path %q on disallowed device %d", item, id) return false } return true } stat, err := archiver.Scan(target, selectFilter, newScanProgress(gopts)) if err != nil { return err } arch := archiver.New(repo) arch.Excludes = opts.Excludes arch.SelectFilter = selectFilter arch.Error = func(dir string, fi os.FileInfo, err error) error { // TODO: make ignoring errors configurable Warnf("%s\rerror for %s: %v\n", ClearLine(), dir, err) return nil } _, id, err := arch.Snapshot(newArchiveProgress(gopts, stat), target, opts.Tags, parentSnapshotID) if err != nil { return err } Verbosef("snapshot %s saved\n", id.Str()) return nil }