// Returns the completion status, in percent, for the given node and repo. func (m *Model) Completion(node protocol.NodeID, repo string) float64 { var tot int64 m.repoFiles[repo].WithGlobal(func(f protocol.FileInfo) bool { if !protocol.IsDeleted(f.Flags) { var size int64 if protocol.IsDirectory(f.Flags) { size = zeroEntrySize } else { size = f.Size() } tot += size } return true }) var need int64 m.repoFiles[repo].WithNeed(node, func(f protocol.FileInfo) bool { if !protocol.IsDeleted(f.Flags) { var size int64 if protocol.IsDirectory(f.Flags) { size = zeroEntrySize } else { size = f.Size() } need += size } return true }) return 100 * (1 - float64(need)/float64(tot)) }
func hashFile(dir string, blockSize int, outbox, inbox chan protocol.FileInfo) { for f := range inbox { if protocol.IsDirectory(f.Flags) || protocol.IsDeleted(f.Flags) { outbox <- f continue } fd, err := os.Open(filepath.Join(dir, f.Name)) if err != nil { if debug { l.Debugln("open:", err) } continue } blocks, err := Blocks(fd, blockSize) fd.Close() if err != nil { if debug { l.Debugln("hash error:", f.Name, err) } continue } f.Blocks = blocks outbox <- f } }
// Returns the completion status, in percent, for the given node and repo. func (m *Model) Completion(node protocol.NodeID, repo string) float64 { var tot int64 m.rmut.RLock() rf, ok := m.repoFiles[repo] m.rmut.RUnlock() if !ok { return 0 // Repo doesn't exist, so we hardly have any of it } rf.WithGlobal(func(f protocol.FileInfo) bool { if !protocol.IsDeleted(f.Flags) { var size int64 if protocol.IsDirectory(f.Flags) { size = zeroEntrySize } else { size = f.Size() } tot += size } return true }) if tot == 0 { return 100 // Repo is empty, so we have all of it } var need int64 rf.WithNeed(node, func(f protocol.FileInfo) bool { if !protocol.IsDeleted(f.Flags) { var size int64 if protocol.IsDirectory(f.Flags) { size = zeroEntrySize } else { size = f.Size() } need += size } return true }) return 100 * (1 - float64(need)/float64(tot)) }
func sizeOfFile(f protocol.FileInfo) (files, deleted int, bytes int64) { if !protocol.IsDeleted(f.Flags) { files++ if !protocol.IsDirectory(f.Flags) { bytes += f.Size() } else { bytes += zeroEntrySize } } else { deleted++ bytes += zeroEntrySize } return }
// handleBlock fulfills the block request by copying, ignoring or fetching // from the network. Returns true if the block was fully handled // synchronously, i.e. if the slot can be reused. func (p *puller) handleBlock(b bqBlock) bool { f := b.file // For directories, making sure they exist is enough. // Deleted directories we mark as handled and delete later. if protocol.IsDirectory(f.Flags) { if !protocol.IsDeleted(f.Flags) { path := filepath.Join(p.repoCfg.Directory, f.Name) _, err := os.Stat(path) if err != nil && os.IsNotExist(err) { if debug { l.Debugf("create dir: %v", f) } err = os.MkdirAll(path, os.FileMode(f.Flags&0777)) if err != nil { p.errors++ l.Infof("mkdir: error: %q: %v", path, err) } } } else if debug { l.Debugf("ignore delete dir: %v", f) } p.model.updateLocal(p.repoCfg.ID, f) return true } if len(b.copy) > 0 && len(b.copy) == len(b.file.Blocks) && b.last { // We are supposed to copy the entire file, and then fetch nothing. // We don't actually need to make the copy. if debug { l.Debugln("taking shortcut:", f) } fp := filepath.Join(p.repoCfg.Directory, f.Name) t := time.Unix(f.Modified, 0) err := os.Chtimes(fp, t, t) if err != nil { l.Infof("chtimes: error: %q / %q: %v", p.repoCfg.ID, f.Name, err) } if !p.repoCfg.IgnorePerms && protocol.HasPermissionBits(f.Flags) { err = os.Chmod(fp, os.FileMode(f.Flags&0777)) if err != nil { l.Infof("chmod: error: %q / %q: %v", p.repoCfg.ID, f.Name, err) } } events.Default.Log(events.ItemStarted, map[string]string{ "repo": p.repoCfg.ID, "item": f.Name, }) p.model.updateLocal(p.repoCfg.ID, f) return true } of, ok := p.openFiles[f.Name] of.done = b.last if !ok { if debug { l.Debugf("pull: %q: opening file %q", p.repoCfg.ID, f.Name) } events.Default.Log(events.ItemStarted, map[string]string{ "repo": p.repoCfg.ID, "item": f.Name, }) of.availability = p.model.repoFiles[p.repoCfg.ID].Availability(f.Name) of.filepath = filepath.Join(p.repoCfg.Directory, f.Name) of.temp = filepath.Join(p.repoCfg.Directory, defTempNamer.TempName(f.Name)) dirName := filepath.Dir(of.filepath) info, err := os.Stat(dirName) if err != nil { err = os.MkdirAll(dirName, 0777) if debug && err != nil { l.Debugf("mkdir: error: %q / %q: %v", p.repoCfg.ID, f.Name, err) } } else { // We need to make sure the directory is writeable so we can create files in it if dirName != p.repoCfg.Directory { err = os.Chmod(dirName, 0777) if debug && err != nil { l.Debugf("make writeable: error: %q / %q: %v", p.repoCfg.ID, f.Name, err) } } // Change it back after creating the file, to minimize the time window with incorrect permissions defer os.Chmod(dirName, info.Mode()) } of.file, of.err = os.Create(of.temp) if of.err != nil { p.errors++ l.Infof("create: error: %q / %q: %v", p.repoCfg.ID, f.Name, of.err) if !b.last { p.openFiles[f.Name] = of } return true } osutil.HideFile(of.temp) } if of.err != nil { // We have already failed this file. if debug { l.Debugf("pull: error: %q / %q has already failed: %v", p.repoCfg.ID, f.Name, of.err) } if b.last { delete(p.openFiles, f.Name) } return true } p.openFiles[f.Name] = of switch { case len(b.copy) > 0: p.handleCopyBlock(b) return true case b.block.Size > 0: return p.handleRequestBlock(b) default: p.handleEmptyBlock(b) return true } }
func (w *Walker) walkAndHashFiles(fchan chan protocol.FileInfo, ign map[string][]string) filepath.WalkFunc { return func(p string, info os.FileInfo, err error) error { if err != nil { if debug { l.Debugln("error:", p, info, err) } return nil } rn, err := filepath.Rel(w.Dir, p) if err != nil { if debug { l.Debugln("rel error:", p, err) } return nil } if rn == "." { return nil } if w.TempNamer != nil && w.TempNamer.IsTemporary(rn) { // A temporary file if debug { l.Debugln("temporary:", rn) } return nil } if sn := filepath.Base(rn); sn == w.IgnoreFile || sn == ".stversions" || w.ignoreFile(ign, rn) { // An ignored file if debug { l.Debugln("ignored:", rn) } if info.IsDir() { return filepath.SkipDir } return nil } if (runtime.GOOS == "linux" || runtime.GOOS == "windows") && !norm.NFC.IsNormalString(rn) { l.Warnf("File %q contains non-NFC UTF-8 sequences and cannot be synced. Consider renaming.", rn) return nil } if info.Mode().IsDir() { if w.CurrentFiler != nil { cf := w.CurrentFiler.CurrentFile(rn) permUnchanged := w.IgnorePerms || !protocol.HasPermissionBits(cf.Flags) || PermsEqual(cf.Flags, uint32(info.Mode())) if !protocol.IsDeleted(cf.Flags) && protocol.IsDirectory(cf.Flags) && permUnchanged { return nil } } var flags uint32 = protocol.FlagDirectory if w.IgnorePerms { flags |= protocol.FlagNoPermBits | 0777 } else { flags |= uint32(info.Mode() & os.ModePerm) } f := protocol.FileInfo{ Name: rn, Version: lamport.Default.Tick(0), Flags: flags, Modified: info.ModTime().Unix(), } if debug { l.Debugln("dir:", f) } fchan <- f return nil } if info.Mode().IsRegular() { if w.CurrentFiler != nil { cf := w.CurrentFiler.CurrentFile(rn) permUnchanged := w.IgnorePerms || !protocol.HasPermissionBits(cf.Flags) || PermsEqual(cf.Flags, uint32(info.Mode())) if !protocol.IsDeleted(cf.Flags) && cf.Modified == info.ModTime().Unix() && permUnchanged { return nil } if debug { l.Debugln("rescan:", cf, info.ModTime().Unix(), info.Mode()&os.ModePerm) } } var flags = uint32(info.Mode() & os.ModePerm) if w.IgnorePerms { flags = protocol.FlagNoPermBits | 0666 } fchan <- protocol.FileInfo{ Name: rn, Version: lamport.Default.Tick(0), Flags: flags, Modified: info.ModTime().Unix(), } } return nil } }