volume: load ec shards during heartbeats to master

weed/storage/disk_location.go

@@ -9,6 +9,7 @@ import (
 	"fmt"
 
 	"github.com/chrislusf/seaweedfs/weed/glog"
+	"github.com/chrislusf/seaweedfs/weed/storage/erasure_coding"
 	"github.com/chrislusf/seaweedfs/weed/storage/needle"
 )
 
@@ -17,43 +18,52 @@ type DiskLocation struct {
 	MaxVolumeCount int
 	volumes        map[needle.VolumeId]*Volume
 	sync.RWMutex
+
+	// erasure coding
+	ecShards     map[needle.VolumeId]erasure_coding.EcVolumeShards
+	ecShardsLock sync.RWMutex
 }
 
 func NewDiskLocation(dir string, maxVolumeCount int) *DiskLocation {
 	location := &DiskLocation{Directory: dir, MaxVolumeCount: maxVolumeCount}
 	location.volumes = make(map[needle.VolumeId]*Volume)
+	location.ecShards = make(map[needle.VolumeId]erasure_coding.EcVolumeShards)
 	return location
 }
 
 func (l *DiskLocation) volumeIdFromPath(dir os.FileInfo) (needle.VolumeId, string, error) {
 	name := dir.Name()
 	if !dir.IsDir() && strings.HasSuffix(name, ".dat") {
-		collection := ""
 		base := name[:len(name)-len(".dat")]
-		i := strings.LastIndex(base, "_")
-		if i > 0 {
-			collection, base = base[0:i], base[i+1:]
-		}
-		vol, err := needle.NewVolumeId(base)
-		return vol, collection, err
+		collection, volumeId, err := parseCollectionVolumeId(base)
+		return volumeId, collection, err
 	}
 
 	return 0, "", fmt.Errorf("Path is not a volume: %s", name)
 }
 
-func (l *DiskLocation) loadExistingVolume(dir os.FileInfo, needleMapKind NeedleMapType, mutex *sync.RWMutex) {
-	name := dir.Name()
-	if !dir.IsDir() && strings.HasSuffix(name, ".dat") {
-		vid, collection, err := l.volumeIdFromPath(dir)
+func parseCollectionVolumeId(base string) (collection string, vid needle.VolumeId, err error) {
+	i := strings.LastIndex(base, "_")
+	if i > 0 {
+		collection, base = base[0:i], base[i+1:]
+	}
+	vol, err := needle.NewVolumeId(base)
+	return collection, vol, err
+}
+
+func (l *DiskLocation) loadExistingVolume(fileInfo os.FileInfo, needleMapKind NeedleMapType) {
+	name := fileInfo.Name()
+	if !fileInfo.IsDir() && strings.HasSuffix(name, ".dat") {
+		vid, collection, err := l.volumeIdFromPath(fileInfo)
 		if err == nil {
-			mutex.RLock()
+			l.RLock()
 			_, found := l.volumes[vid]
-			mutex.RUnlock()
+			l.RUnlock()
 			if !found {
 				if v, e := NewVolume(l.Directory, collection, vid, needleMapKind, nil, nil, 0); e == nil {
-					mutex.Lock()
+					l.Lock()
 					l.volumes[vid] = v
-					mutex.Unlock()
+					l.Unlock()
 					size, _, _ := v.FileStat()
 					glog.V(0).Infof("data file %s, replicaPlacement=%s v=%d size=%d ttl=%s",
 						l.Directory+"/"+name, v.ReplicaPlacement, v.Version(), size, v.Ttl.String())
@@ -80,13 +90,12 @@ func (l *DiskLocation) concurrentLoadingVolumes(needleMapKind NeedleMapType, con
 	}()
 
 	var wg sync.WaitGroup
-	var mutex sync.RWMutex
 	for workerNum := 0; workerNum < concurrency; workerNum++ {
 		wg.Add(1)
 		go func() {
 			defer wg.Done()
 			for dir := range task_queue {
-				l.loadExistingVolume(dir, needleMapKind, &mutex)
+				l.loadExistingVolume(dir, needleMapKind)
 			}
 		}()
 	}
@@ -95,12 +104,13 @@ func (l *DiskLocation) concurrentLoadingVolumes(needleMapKind NeedleMapType, con
 }
 
 func (l *DiskLocation) loadExistingVolumes(needleMapKind NeedleMapType) {
-	l.Lock()
-	defer l.Unlock()
 
 	l.concurrentLoadingVolumes(needleMapKind, 10)
+	glog.V(0).Infof("Store started on dir: %s with %d volumes max %d", l.Directory, len(l.volumes), l.MaxVolumeCount)
+
+	l.loadAllEcShards()
+	glog.V(0).Infof("Store started on dir: %s with %d ec shards", l.Directory, len(l.ecShards))
 
-	glog.V(0).Infoln("Store started on dir:", l.Directory, "with", len(l.volumes), "volumes", "max", l.MaxVolumeCount)
 }
 
 func (l *DiskLocation) DeleteCollectionFromDiskLocation(collection string) (e error) {
@@ -132,12 +142,11 @@ func (l *DiskLocation) deleteVolumeById(vid needle.VolumeId) (e error) {
 }
 
 func (l *DiskLocation) LoadVolume(vid needle.VolumeId, needleMapKind NeedleMapType) bool {
-	if dirs, err := ioutil.ReadDir(l.Directory); err == nil {
-		for _, dir := range dirs {
-			volId, _, err := l.volumeIdFromPath(dir)
+	if fileInfos, err := ioutil.ReadDir(l.Directory); err == nil {
+		for _, fileInfo := range fileInfos {
+			volId, _, err := l.volumeIdFromPath(fileInfo)
 			if vid == volId && err == nil {
-				var mutex sync.RWMutex
-				l.loadExistingVolume(dir, needleMapKind, &mutex)
+				l.loadExistingVolume(fileInfo, needleMapKind)
 				return true
 			}
 		}
@@ -194,10 +203,16 @@ func (l *DiskLocation) VolumesLen() int {
 
 func (l *DiskLocation) Close() {
 	l.Lock()
-	defer l.Unlock()
-
 	for _, v := range l.volumes {
 		v.Close()
 	}
+	l.Unlock()
+
+	l.ecShardsLock.Lock()
+	for _, shards := range l.ecShards {
+		shards.Close()
+	}
+	l.ecShardsLock.Unlock()
+
 	return
 }