2014-04-10 00:44:58 +08:00
|
|
|
package filer
|
|
|
|
|
|
|
|
import (
|
|
|
|
"bufio"
|
2014-09-25 00:47:09 +08:00
|
|
|
"github.com/aszxqw/weed-fs/go/util"
|
2014-04-10 00:44:58 +08:00
|
|
|
"fmt"
|
|
|
|
"io"
|
|
|
|
"os"
|
|
|
|
"path/filepath"
|
|
|
|
"strconv"
|
|
|
|
"strings"
|
2014-09-05 10:26:31 +08:00
|
|
|
"sync"
|
2014-04-10 00:44:58 +08:00
|
|
|
)
|
|
|
|
|
2014-09-05 10:26:31 +08:00
|
|
|
var writeLock sync.Mutex //serialize changes to dir.log
|
|
|
|
|
2014-04-10 00:44:58 +08:00
|
|
|
type DirectoryEntryInMap struct {
|
|
|
|
Name string
|
|
|
|
Parent *DirectoryEntryInMap
|
|
|
|
SubDirectories map[string]*DirectoryEntryInMap
|
|
|
|
Id DirectoryId
|
|
|
|
}
|
|
|
|
|
|
|
|
type DirectoryManagerInMap struct {
|
|
|
|
Root *DirectoryEntryInMap
|
|
|
|
max DirectoryId
|
|
|
|
logFile *os.File
|
|
|
|
isLoading bool
|
|
|
|
}
|
|
|
|
|
2014-09-05 10:34:43 +08:00
|
|
|
func (dm *DirectoryManagerInMap) NewDirectoryEntryInMap(parent *DirectoryEntryInMap, name string) (d *DirectoryEntryInMap, err error) {
|
2014-09-05 10:26:31 +08:00
|
|
|
writeLock.Lock()
|
|
|
|
defer writeLock.Unlock()
|
2014-04-18 13:32:21 +08:00
|
|
|
d = &DirectoryEntryInMap{Name: name, Parent: parent, SubDirectories: make(map[string]*DirectoryEntryInMap)}
|
2014-04-10 00:44:58 +08:00
|
|
|
parts := make([]string, 0)
|
|
|
|
for p := d; p != nil && p.Name != ""; p = p.Parent {
|
|
|
|
parts = append(parts, p.Name)
|
|
|
|
}
|
|
|
|
n := len(parts)
|
|
|
|
if n <= 0 {
|
2014-09-05 10:34:43 +08:00
|
|
|
return nil, fmt.Errorf("Failed to create folder %s/%s", parent.Name, name)
|
2014-04-10 00:44:58 +08:00
|
|
|
}
|
|
|
|
for i := 0; i < n/2; i++ {
|
|
|
|
parts[i], parts[n-1-i] = parts[n-1-i], parts[i]
|
|
|
|
}
|
2014-09-05 10:26:31 +08:00
|
|
|
dm.max++
|
|
|
|
d.Id = dm.max
|
2014-04-10 00:44:58 +08:00
|
|
|
dm.log("add", "/"+strings.Join(parts, "/"), strconv.Itoa(int(d.Id)))
|
2014-09-05 10:34:43 +08:00
|
|
|
return d, nil
|
2014-04-10 00:44:58 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
func (dm *DirectoryManagerInMap) log(words ...string) {
|
|
|
|
if !dm.isLoading {
|
|
|
|
dm.logFile.WriteString(strings.Join(words, "\t") + "\n")
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func NewDirectoryManagerInMap(dirLogFile string) (dm *DirectoryManagerInMap, err error) {
|
|
|
|
dm = &DirectoryManagerInMap{}
|
2014-04-18 13:32:21 +08:00
|
|
|
//dm.Root do not use NewDirectoryEntryInMap, since dm.max will be changed
|
|
|
|
dm.Root = &DirectoryEntryInMap{SubDirectories: make(map[string]*DirectoryEntryInMap)}
|
2014-04-10 00:44:58 +08:00
|
|
|
if dm.logFile, err = os.OpenFile(dirLogFile, os.O_RDWR|os.O_CREATE, 0644); err != nil {
|
|
|
|
return nil, fmt.Errorf("cannot write directory log file %s.idx: %s", dirLogFile, err.Error())
|
|
|
|
}
|
|
|
|
return dm, dm.load()
|
|
|
|
}
|
|
|
|
|
|
|
|
func (dm *DirectoryManagerInMap) processEachLine(line string) error {
|
|
|
|
if strings.HasPrefix(line, "#") {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
if line == "" {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
parts := strings.Split(line, "\t")
|
|
|
|
if len(parts) == 0 {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
switch parts[0] {
|
|
|
|
case "add":
|
|
|
|
v, pe := strconv.Atoi(parts[2])
|
|
|
|
if pe != nil {
|
|
|
|
return pe
|
|
|
|
}
|
|
|
|
if e := dm.loadDirectory(parts[1], DirectoryId(v)); e != nil {
|
|
|
|
return e
|
|
|
|
}
|
|
|
|
case "mov":
|
2014-07-21 14:12:49 +08:00
|
|
|
newName := ""
|
|
|
|
if len(parts) >= 4 {
|
|
|
|
newName = parts[3]
|
|
|
|
}
|
|
|
|
if e := dm.MoveUnderDirectory(parts[1], parts[2], newName); e != nil {
|
2014-04-10 00:44:58 +08:00
|
|
|
return e
|
|
|
|
}
|
|
|
|
case "del":
|
|
|
|
if e := dm.DeleteDirectory(parts[1]); e != nil {
|
|
|
|
return e
|
|
|
|
}
|
|
|
|
default:
|
|
|
|
fmt.Printf("line %s has %s!\n", line, parts[0])
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
func (dm *DirectoryManagerInMap) load() error {
|
|
|
|
dm.max = 0
|
|
|
|
lines := bufio.NewReader(dm.logFile)
|
|
|
|
dm.isLoading = true
|
|
|
|
defer func() { dm.isLoading = false }()
|
|
|
|
for {
|
|
|
|
line, err := util.Readln(lines)
|
|
|
|
if err != nil && err != io.EOF {
|
|
|
|
return err
|
|
|
|
}
|
|
|
|
if pe := dm.processEachLine(string(line)); pe != nil {
|
|
|
|
return pe
|
|
|
|
}
|
|
|
|
if err == io.EOF {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
func (dm *DirectoryManagerInMap) findDirectory(dirPath string) (*DirectoryEntryInMap, error) {
|
|
|
|
if dirPath == "" {
|
|
|
|
return dm.Root, nil
|
|
|
|
}
|
|
|
|
dirPath = filepath.Clean(dirPath)
|
|
|
|
if dirPath == "/" {
|
|
|
|
return dm.Root, nil
|
|
|
|
}
|
|
|
|
parts := strings.Split(dirPath, "/")
|
|
|
|
dir := dm.Root
|
|
|
|
for i := 1; i < len(parts); i++ {
|
|
|
|
if sub, ok := dir.SubDirectories[parts[i]]; ok {
|
|
|
|
dir = sub
|
|
|
|
} else {
|
|
|
|
return dm.Root, fmt.Errorf("Directory %s Not Found", dirPath)
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return dir, nil
|
|
|
|
}
|
|
|
|
func (dm *DirectoryManagerInMap) FindDirectory(dirPath string) (DirectoryId, error) {
|
|
|
|
d, e := dm.findDirectory(dirPath)
|
|
|
|
if e == nil {
|
|
|
|
return d.Id, nil
|
|
|
|
}
|
|
|
|
return dm.Root.Id, e
|
|
|
|
}
|
|
|
|
|
|
|
|
func (dm *DirectoryManagerInMap) loadDirectory(dirPath string, dirId DirectoryId) error {
|
|
|
|
dirPath = filepath.Clean(dirPath)
|
|
|
|
if dirPath == "/" {
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
parts := strings.Split(dirPath, "/")
|
|
|
|
dir := dm.Root
|
|
|
|
for i := 1; i < len(parts); i++ {
|
|
|
|
sub, ok := dir.SubDirectories[parts[i]]
|
|
|
|
if !ok {
|
|
|
|
if i != len(parts)-1 {
|
|
|
|
return fmt.Errorf("%s should be created after parent %s!", dirPath, parts[i])
|
|
|
|
}
|
2014-09-05 10:34:43 +08:00
|
|
|
var err error
|
|
|
|
sub, err = dm.NewDirectoryEntryInMap(dir, parts[i])
|
|
|
|
if err != nil {
|
|
|
|
return err
|
|
|
|
}
|
2014-04-10 00:44:58 +08:00
|
|
|
if sub.Id != dirId {
|
|
|
|
return fmt.Errorf("%s should be have id %v instead of %v!", dirPath, sub.Id, dirId)
|
|
|
|
}
|
|
|
|
dir.SubDirectories[parts[i]] = sub
|
|
|
|
}
|
|
|
|
dir = sub
|
|
|
|
}
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (dm *DirectoryManagerInMap) makeDirectory(dirPath string) (dir *DirectoryEntryInMap, created bool) {
|
|
|
|
dirPath = filepath.Clean(dirPath)
|
|
|
|
if dirPath == "/" {
|
|
|
|
return dm.Root, false
|
|
|
|
}
|
|
|
|
parts := strings.Split(dirPath, "/")
|
|
|
|
dir = dm.Root
|
|
|
|
for i := 1; i < len(parts); i++ {
|
|
|
|
sub, ok := dir.SubDirectories[parts[i]]
|
|
|
|
if !ok {
|
2014-09-21 03:38:59 +08:00
|
|
|
var err error
|
2014-09-05 10:34:43 +08:00
|
|
|
sub, err = dm.NewDirectoryEntryInMap(dir, parts[i])
|
|
|
|
if err != nil {
|
2014-09-21 03:38:59 +08:00
|
|
|
return nil, false
|
2014-09-05 10:34:43 +08:00
|
|
|
}
|
2014-04-10 00:44:58 +08:00
|
|
|
dir.SubDirectories[parts[i]] = sub
|
|
|
|
created = true
|
|
|
|
}
|
|
|
|
dir = sub
|
|
|
|
}
|
|
|
|
return dir, created
|
|
|
|
}
|
|
|
|
|
|
|
|
func (dm *DirectoryManagerInMap) MakeDirectory(dirPath string) (DirectoryId, error) {
|
|
|
|
dir, _ := dm.makeDirectory(dirPath)
|
|
|
|
return dir.Id, nil
|
|
|
|
}
|
|
|
|
|
2014-07-21 14:12:49 +08:00
|
|
|
func (dm *DirectoryManagerInMap) MoveUnderDirectory(oldDirPath string, newParentDirPath string, newName string) error {
|
2014-09-05 10:26:31 +08:00
|
|
|
writeLock.Lock()
|
|
|
|
defer writeLock.Unlock()
|
2014-04-10 00:44:58 +08:00
|
|
|
oldDir, oe := dm.findDirectory(oldDirPath)
|
|
|
|
if oe != nil {
|
|
|
|
return oe
|
|
|
|
}
|
|
|
|
parentDir, pe := dm.findDirectory(newParentDirPath)
|
|
|
|
if pe != nil {
|
|
|
|
return pe
|
|
|
|
}
|
2014-07-21 14:12:49 +08:00
|
|
|
dm.log("mov", oldDirPath, newParentDirPath, newName)
|
2014-04-10 00:44:58 +08:00
|
|
|
delete(oldDir.Parent.SubDirectories, oldDir.Name)
|
2014-07-21 14:12:49 +08:00
|
|
|
if newName == "" {
|
|
|
|
newName = oldDir.Name
|
|
|
|
}
|
|
|
|
parentDir.SubDirectories[newName] = oldDir
|
|
|
|
oldDir.Name = newName
|
2014-04-10 00:44:58 +08:00
|
|
|
oldDir.Parent = parentDir
|
|
|
|
return nil
|
|
|
|
}
|
|
|
|
|
|
|
|
func (dm *DirectoryManagerInMap) ListDirectories(dirPath string) (dirNames []DirectoryEntry, err error) {
|
|
|
|
d, e := dm.findDirectory(dirPath)
|
|
|
|
if e != nil {
|
|
|
|
return dirNames, e
|
|
|
|
}
|
|
|
|
for k, v := range d.SubDirectories {
|
|
|
|
dirNames = append(dirNames, DirectoryEntry{Name: k, Id: v.Id})
|
|
|
|
}
|
|
|
|
return dirNames, nil
|
|
|
|
}
|
|
|
|
func (dm *DirectoryManagerInMap) DeleteDirectory(dirPath string) error {
|
2014-09-05 10:26:31 +08:00
|
|
|
writeLock.Lock()
|
|
|
|
defer writeLock.Unlock()
|
2014-04-10 00:44:58 +08:00
|
|
|
if dirPath == "/" {
|
|
|
|
return fmt.Errorf("Can not delete %s", dirPath)
|
|
|
|
}
|
|
|
|
d, e := dm.findDirectory(dirPath)
|
|
|
|
if e != nil {
|
|
|
|
return e
|
|
|
|
}
|
|
|
|
if len(d.SubDirectories) != 0 {
|
|
|
|
return fmt.Errorf("dir %s still has sub directories", dirPath)
|
|
|
|
}
|
|
|
|
delete(d.Parent.SubDirectories, d.Name)
|
|
|
|
d.Parent = nil
|
|
|
|
dm.log("del", dirPath)
|
|
|
|
return nil
|
|
|
|
}
|