mount/unmount ec shards

weed/storage/disk_location_ec.go

@@ -16,26 +16,83 @@ var (
 	re = regexp.MustCompile("\\.ec[0-9][0-9]")
 )
 
-func (l *DiskLocation) loadEcShards(baseName string, shards []string, collection string, vid needle.VolumeId) (err error){
+func (l *DiskLocation) FindEcShard(vid needle.VolumeId, shardId erasure_coding.ShardId) (*erasure_coding.EcVolumeShard, bool) {
+	l.ecShardsLock.RLock()
+	defer l.ecShardsLock.RUnlock()
 
-	for _, shard := range shards{
+	ecShards, ok := l.ecShards[vid]
+	if !ok {
+		return nil, false
+	}
+	for _, ecShard := range ecShards {
+		if ecShard.ShardId == shardId {
+			return ecShard, true
+		}
+	}
+	return nil, false
+}
+
+func (l *DiskLocation) LoadEcShard(collection string, vid needle.VolumeId, shardId erasure_coding.ShardId) (err error) {
+
+	ecVolumeShard, err := erasure_coding.NewEcVolumeShard(l.Directory, collection, vid, shardId)
+	if err != nil {
+		return fmt.Errorf("failed to create ec shard %d.%d: %v", vid, shardId, err)
+	}
+	l.ecShardsLock.Lock()
+	l.ecShards[vid] = append(l.ecShards[vid], ecVolumeShard)
+	l.ecShardsLock.Unlock()
+
+	return nil
+}
+
+func (l *DiskLocation) UnloadEcShard(vid needle.VolumeId, shardId erasure_coding.ShardId) bool {
+
+	l.ecShardsLock.Lock()
+	defer l.ecShardsLock.Unlock()
+
+	vidShards, found := l.ecShards[vid]
+	if !found {
+		return false
+	}
+	shardIndex := -1
+	for i, shard := range vidShards {
+		if shard.ShardId == shardId {
+			shardIndex = i
+			break
+		}
+	}
+	if shardIndex < 0 {
+		return false
+	}
+
+	if len(vidShards) == 1 {
+		delete(l.ecShards, vid)
+		return true
+	}
+
+	l.ecShards[vid] = append(vidShards[:shardIndex], vidShards[shardIndex+1:]...)
+
+	return true
+}
+
+func (l *DiskLocation) loadEcShards(shards []string, collection string, vid needle.VolumeId) (err error) {
+
+	for _, shard := range shards {
 		shardId, err := strconv.ParseInt(path.Ext(shard)[3:], 10, 64)
 		if err != nil {
 			return fmt.Errorf("failed to parse ec shard name %v: %v", shard, err)
 		}
-		ecVolumeShard, err := erasure_coding.NewEcVolumeShard(l.Directory, collection, vid, int(shardId))
+
+		err = l.LoadEcShard(collection, vid, erasure_coding.ShardId(shardId))
 		if err != nil {
-			return fmt.Errorf("failed to create ec shard %v: %v", shard, err)
+			return fmt.Errorf("failed to load ec shard %v: %v", shard, err)
 		}
-		l.ecShardsLock.Lock()
-		l.ecShards[vid] = append(l.ecShards[vid], ecVolumeShard)
-		l.ecShardsLock.Unlock()
 	}
 
 	return nil
 }
 
-func (l *DiskLocation) loadAllEcShards() (err error){
+func (l *DiskLocation) loadAllEcShards() (err error) {
 
 	fileInfos, err := ioutil.ReadDir(l.Directory)
 	if err != nil {
@@ -48,8 +105,8 @@ func (l *DiskLocation) loadAllEcShards() (err error){
 
 	var sameVolumeShards []string
 	var prevVolumeId needle.VolumeId
-	for _, fileInfo := range fileInfos{
-		if fileInfo.IsDir(){
+	for _, fileInfo := range fileInfos {
+		if fileInfo.IsDir() {
 			continue
 		}
 		ext := path.Ext(fileInfo.Name())
@@ -61,18 +118,18 @@ func (l *DiskLocation) loadAllEcShards() (err error){
 			continue
 		}
 
-		if re.MatchString(ext){
+		if re.MatchString(ext) {
 			if prevVolumeId == 0 || volumeId == prevVolumeId {
 				sameVolumeShards = append(sameVolumeShards, fileInfo.Name())
-			}else{
+			} else {
 				sameVolumeShards = []string{fileInfo.Name()}
 			}
 			prevVolumeId = volumeId
 			continue
 		}
 
-		if ext == ".ecx" && volumeId == prevVolumeId{
-			if err = l.loadEcShards(baseName, sameVolumeShards, collection, volumeId);err!=nil{
+		if ext == ".ecx" && volumeId == prevVolumeId {
+			if err = l.loadEcShards(sameVolumeShards, collection, volumeId); err != nil {
 				return fmt.Errorf("loadEcShards collection:%v volumeId:%d : %v", collection, volumeId, err)
 			}
 			prevVolumeId = volumeId

weed/storage/erasure_coding/ec_volume.go

@@ -24,16 +24,16 @@ type EcVolumeShard struct {
 }
 type EcVolumeShards []*EcVolumeShard
 
-func NewEcVolumeShard(dirname string, collection string, id needle.VolumeId, shardId int) (v *EcVolumeShard, e error) {
+func NewEcVolumeShard(dirname string, collection string, id needle.VolumeId, shardId ShardId) (v *EcVolumeShard, e error) {
 
-	v = &EcVolumeShard{dir: dirname, Collection: collection, VolumeId: id, ShardId: ShardId(shardId)}
+	v = &EcVolumeShard{dir: dirname, Collection: collection, VolumeId: id, ShardId: shardId}
 
 	baseFileName := v.FileName()
 	if v.ecxFile, e = os.OpenFile(baseFileName+".ecx", os.O_RDONLY, 0644); e != nil {
 		return nil, fmt.Errorf("cannot read ec volume index %s.ecx: %v", baseFileName, e)
 	}
-	if v.ecdFile, e = os.OpenFile(baseFileName+ToExt(shardId), os.O_RDONLY, 0644); e != nil {
-		return nil, fmt.Errorf("cannot read ec volume shard %s.%s: %v", baseFileName, ToExt(shardId), e)
+	if v.ecdFile, e = os.OpenFile(baseFileName+ToExt(int(shardId)), os.O_RDONLY, 0644); e != nil {
+		return nil, fmt.Errorf("cannot read ec volume shard %s.%s: %v", baseFileName, ToExt(int(shardId)), e)
 	}
 
 	return

weed/storage/store.go

@@ -271,6 +271,7 @@ func (s *Store) UnmountVolume(i needle.VolumeId) error {
 		Version:          uint32(v.Version()),
 		Ttl:              v.Ttl.ToUint32(),
 	}
+
 	for _, location := range s.Locations {
 		if err := location.UnloadVolume(i); err == nil {
 			glog.V(0).Infof("UnmountVolume %d", i)

weed/storage/store_ec.go

@@ -1,7 +1,12 @@
 package storage
 
 import (
+	"fmt"
+
+	"github.com/chrislusf/seaweedfs/weed/glog"
 	"github.com/chrislusf/seaweedfs/weed/pb/master_pb"
+	"github.com/chrislusf/seaweedfs/weed/storage/erasure_coding"
+	"github.com/chrislusf/seaweedfs/weed/storage/needle"
 )
 
 func (s *Store) CollectErasureCodingHeartbeat() *master_pb.Heartbeat {
@@ -19,3 +24,56 @@ func (s *Store) CollectErasureCodingHeartbeat() *master_pb.Heartbeat {
 	}
 
 }
+
+func (s *Store) MountEcShards(collection string, vid needle.VolumeId, shardId erasure_coding.ShardId) error {
+	for _, location := range s.Locations {
+		if err := location.LoadEcShard(collection, vid, shardId); err == nil {
+			glog.V(0).Infof("MountEcShards %d.%d", vid, shardId)
+
+			var shardBits erasure_coding.ShardBits
+
+			s.NewEcShardsChan <- master_pb.VolumeEcShardInformationMessage{
+				Id:               uint32(vid),
+				Collection:       collection,
+				EcIndexBits:      uint32(shardBits.AddShardId(shardId)),
+			}
+			return nil
+		}
+	}
+
+	return fmt.Errorf("MountEcShards %d.%d not found on disk", vid, shardId)
+}
+
+func (s *Store) UnmountEcShards(vid needle.VolumeId, shardId erasure_coding.ShardId) error {
+
+	ecShard, found := s.findEcShard(vid, shardId)
+	if !found {
+		return nil
+	}
+
+	var shardBits erasure_coding.ShardBits
+	message := master_pb.VolumeEcShardInformationMessage{
+		Id:               uint32(vid),
+		Collection:       ecShard.Collection,
+		EcIndexBits:      uint32(shardBits.AddShardId(shardId)),
+	}
+
+	for _, location := range s.Locations {
+		if deleted := location.UnloadEcShard(vid, shardId); deleted {
+			glog.V(0).Infof("UnmountEcShards %d.%d", vid, shardId)
+			s.DeletedEcShardsChan <- message
+			return nil
+		}
+	}
+
+	return fmt.Errorf("UnmountEcShards %d.%d not found on disk", vid, shardId)
+}
+
+func (s *Store) findEcShard(vid needle.VolumeId, shardId erasure_coding.ShardId) (*erasure_coding.EcVolumeShard, bool)  {
+	for _, location := range s.Locations {
+		if v, found := location.FindEcShard(vid, shardId); found {
+			return v, found
+		}
+	}
+	return nil, false
+}