// Lazy file loading
func (dir *Directory) loadChildren() {
	util.P_out("Loading children")
	for key := range dir.ChildVids {
		util.P_out(key)
		if dir.IsDir[key] {
			child, err := filesystem.GetDirectory(dir.ChildVids[key], dir.Source)
			if err != nil {
				util.P_err("Error loading directory from db: ", err)
			} else {
				child.parent = dir
				child.archive = dir.isArchive()
				dir.setChild(child)
			}
		} else {
			child, err := filesystem.GetFile(dir.ChildVids[key], dir.Source)
			if err != nil {
				util.P_err("Error loading file from db: ", err)
			} else {
				child.parent = dir
				child.archive = dir.isArchive()
				dir.setChild(child)
			}
		}
	}
	dir.childrenInMemory = true
}
예제 #2
0
func flushNode(flushTime time.Time, node NamedNode, changes map[string][]byte) {
	if dir, ok := node.(*Directory); ok {
		util.P_out("Visiting node: "+dir.Name+" at version %d", dir.Vid)
		for _, node := range dir.children {
			if node != nil {
				if !node.isArchive() {
					flushNode(flushTime, node, changes)
				}
			}
		}
		// TODO: make this a dir method or another function here
		if dir.dirty {
			util.P_out("Putting " + dir.Name)
			dir.LastVid = dir.Vid
			//dir.Vid = filesystem.getNextVid()
			dir.Vid = dir.ComputeVid()
			dir.Vtime = flushTime
			dir.Source = filesystem.replInfo.Pid
			if dir.parent != nil {
				dir.parent.setChild(dir)
				if err := filesystem.database.PutDirectory(dir); err != nil {
					util.P_err("Error putting directory in db: ", err)
				}
				dir.parent.dirty = true
			} else {
				if err := filesystem.database.SetRoot(dir); err != nil {
					util.P_err("Error setting root in db: ", err)
				}
				changes[HEAD] = dir.Vid
			}
			changes[hex.EncodeToString(dir.Vid)], _ = json.Marshal(dir)
		}
	}
	if file, ok := node.(*File); ok {
		util.P_out("Visiting " + file.Name)
	}
	// TODO: make this a file method or another function here
	if file, ok := node.(*File); ok && file.dirty {
		util.P_out("Putting " + file.Name)
		file.LastVid = file.Vid
		//file.Vid = filesystem.getNextVid()
		file.Vid = file.ComputeVid()
		file.Vtime = flushTime
		file.Source = filesystem.replInfo.Pid
		file.commitChunks()
		if err := filesystem.database.PutFile(file); err != nil {
			util.P_err("Error putting file in db: ", err)
		}
		if file.parent != nil {
			file.parent.setChild(file)
			file.parent.dirty = true
		}
		changes[hex.EncodeToString(file.Vid)], _ = json.Marshal(file)
	}
}
예제 #3
0
func (fsdb *LeveldbFsDatabase) PutDirectory(dir *Directory) error {
	//key := []byte(strconv.FormatUint(dir.Vid, 10))
	//dir.updateChildVids()
	if val, jsonErr := json.Marshal(dir); jsonErr == nil {
		if dbErr := fsdb.database.Put(dir.Vid, val, nil); dbErr != nil {
			util.P_err("Error writing to the db: ", dbErr)
			return dbErr
		} else {
			dir.dirty = false
			return nil
		}
	} else {
		util.P_err("Error jsonifying direcotory: ", jsonErr)
		return jsonErr
	}
}
예제 #4
0
func (file *File) commitChunks() {
	chunker := util.DefaultChunker()
	chunks := chunker.Chunks(file.data)
	file.DataBlocks = make([][]byte, len(chunks))
	for i, chunk := range chunks {
		hasher := sha1.New()
		hasher.Write(chunk)
		dataHash := hasher.Sum(nil)
		// Academic assumption: collisions aren't a thing, so we'll assume there will
		// never be any corruption, might as well save on writes in the process.
		util.P_out(string(dataHash))
		file.DataBlocks[i] = dataHash
		if !filesystem.DbContains(dataHash) {
			if dbErr := filesystem.PutChunk(dataHash, chunk); dbErr != nil {
				util.P_err("Failed to write chunk to db: ", dbErr)
			}
		}
	}
}
예제 #5
0
func (file *File) loadChunks() {
	tmp := make([][]byte, len(file.DataBlocks))
	size := 0
	for i, chunkSha := range file.DataBlocks {
		if data, err := filesystem.GetChunk(chunkSha, file.Source); err != nil {
			util.P_err("Unable to load block", err)
			tmp[i] = []byte{} // TODO: probably shouldn't fail this silently
		} else {
			tmp[i] = data
		}
		size += len(tmp[i])
	}
	file.data = make([]byte, size)
	offset := 0
	for _, chunk := range tmp {
		copy(file.data[offset:], chunk)
		offset += len(chunk)
	}
	file.loaded = true
}
예제 #6
0
func main() {
	flag.Usage = Usage

	debugPtr := flag.Bool("debug", false, "print lots of stuff")
	newfsPtr := flag.Bool("newfs", false, "start with an empty file system")
	mtimePtr := flag.Bool("mtimeArchives", false, "use modify timestamp instead of version timestamp for archives")
	name := flag.String("name", "auto", "replica name")
	configFile := flag.String("config", "config.txt", "path to config file")
	flag.Parse()
	util.SetDebug(*debugPtr)
	myfs.UseMtime = *mtimePtr

	util.P_out("main\n")

	pid := myfs.GetOurPid(*configFile, *name)
	replicas := myfs.ReadReplicaInfo(*configFile)
	thisReplica := replicas[pid]

	if thisReplica == nil {
		util.P_err("No applicable replica")
		os.Exit(1)
	}

	if *newfsPtr {
		os.RemoveAll(thisReplica.DbPath)
	}

	if _, err := os.Stat(thisReplica.MntPoint); os.IsNotExist(err) {
		os.MkdirAll(thisReplica.MntPoint, os.ModeDir)
	}

	db, err := myfs.NewLeveldbFsDatabase(thisReplica.DbPath)
	//db := &myfs.DummyFsDb{}
	//err := error(nil)
	if err != nil {
		util.P_err("Problem loading the database: ", err)
		os.Exit(-1)
	}
	filesystem := myfs.NewFs(db, thisReplica, replicas)
	go filesystem.PeriodicFlush()

	//mountpoint := flag.Arg(0)
	mountpoint := thisReplica.MntPoint

	fuse.Unmount(mountpoint) //!!
	c, err := fuse.Mount(mountpoint)
	if err != nil {
		log.Fatal(err)
	}
	defer c.Close()

	err = fs.Serve(c, filesystem)
	if err != nil {
		log.Fatal(err)
	}

	// check if the mount process has an error to report
	<-c.Ready
	if err := c.MountError; err != nil {
		log.Fatal(err)
	}
}