1 files changed, 13 insertions, 101 deletions

diff --git a/weed/storage/volume_super_block.go b/weed/storage/volume_super_block.go
index bce5af465..5e913e062 100644
--- a/weed/storage/volume_super_block.go
+++ b/weed/storage/volume_super_block.go
@@ -5,92 +5,29 @@ import (
 	"os"
 
 	"github.com/chrislusf/seaweedfs/weed/glog"
-	"github.com/chrislusf/seaweedfs/weed/pb/master_pb"
 	"github.com/chrislusf/seaweedfs/weed/storage/backend"
 	"github.com/chrislusf/seaweedfs/weed/storage/needle"
-	"github.com/chrislusf/seaweedfs/weed/util"
-	"github.com/golang/protobuf/proto"
+	"github.com/chrislusf/seaweedfs/weed/storage/super_block"
 )
 
-const (
-	_SuperBlockSize = 8
-)
-
-/*
-* Super block currently has 8 bytes allocated for each volume.
-* Byte 0: version, 1 or 2
-* Byte 1: Replica Placement strategy, 000, 001, 002, 010, etc
-* Byte 2 and byte 3: Time to live. See TTL for definition
-* Byte 4 and byte 5: The number of times the volume has been compacted.
-* Rest bytes: Reserved
- */
-type SuperBlock struct {
-	version            needle.Version
-	ReplicaPlacement   *ReplicaPlacement
-	Ttl                *needle.TTL
-	CompactionRevision uint16
-	Extra              *master_pb.SuperBlockExtra
-	extraSize          uint16
-}
-
-func (s *SuperBlock) BlockSize() int {
-	switch s.version {
-	case needle.Version2, needle.Version3:
-		return _SuperBlockSize + int(s.extraSize)
-	}
-	return _SuperBlockSize
-}
-
-func (s *SuperBlock) Version() needle.Version {
-	return s.version
-}
-func (s *SuperBlock) Bytes() []byte {
-	header := make([]byte, _SuperBlockSize)
-	header[0] = byte(s.version)
-	header[1] = s.ReplicaPlacement.Byte()
-	s.Ttl.ToBytes(header[2:4])
-	util.Uint16toBytes(header[4:6], s.CompactionRevision)
-
-	if s.Extra != nil {
-		extraData, err := proto.Marshal(s.Extra)
-		if err != nil {
-			glog.Fatalf("cannot marshal super block extra %+v: %v", s.Extra, err)
-		}
-		extraSize := len(extraData)
-		if extraSize > 256*256-2 {
-			// reserve a couple of bits for future extension
-			glog.Fatalf("super block extra size is %d bigger than %d", extraSize, 256*256-2)
-		}
-		s.extraSize = uint16(extraSize)
-		util.Uint16toBytes(header[6:8], s.extraSize)
-
-		header = append(header, extraData...)
-	}
-
-	return header
-}
-
-func (s *SuperBlock) Initialized() bool {
-	return s.ReplicaPlacement != nil && s.Ttl != nil
-}
-
 func (v *Volume) maybeWriteSuperBlock() error {
 
 	datSize, _, e := v.DataBackend.GetStat()
 	if e != nil {
-		glog.V(0).Infof("failed to stat datafile %s: %v", v.DataBackend.String(), e)
+		glog.V(0).Infof("failed to stat datafile %s: %v", v.DataBackend.Name(), e)
 		return e
 	}
 	if datSize == 0 {
-		v.SuperBlock.version = needle.CurrentVersion
+		v.SuperBlock.Version = needle.CurrentVersion
 		_, e = v.DataBackend.WriteAt(v.SuperBlock.Bytes(), 0)
 		if e != nil && os.IsPermission(e) {
 			//read-only, but zero length - recreate it!
 			var dataFile *os.File
-			if dataFile, e = os.Create(v.DataBackend.String()); e == nil {
+			if dataFile, e = os.Create(v.DataBackend.Name()); e == nil {
 				v.DataBackend = backend.NewDiskFile(dataFile)
 				if _, e = v.DataBackend.WriteAt(v.SuperBlock.Bytes(), 0); e == nil {
-					v.readOnly = false
+					v.noWriteOrDelete = false
+					v.noWriteCanDelete = false
 				}
 			}
 		}
@@ -99,38 +36,13 @@ func (v *Volume) maybeWriteSuperBlock() error {
 }
 
 func (v *Volume) readSuperBlock() (err error) {
-	v.SuperBlock, err = ReadSuperBlock(v.DataBackend)
-	return err
-}
-
-// ReadSuperBlock reads from data file and load it into volume's super block
-func ReadSuperBlock(datBackend backend.DataStorageBackend) (superBlock SuperBlock, err error) {
-
-	header := make([]byte, _SuperBlockSize)
-	if _, e := datBackend.ReadAt(header, 0); e != nil {
-		err = fmt.Errorf("cannot read volume %s super block: %v", datBackend.String(), e)
-		return
-	}
-
-	superBlock.version = needle.Version(header[0])
-	if superBlock.ReplicaPlacement, err = NewReplicaPlacementFromByte(header[1]); err != nil {
-		err = fmt.Errorf("cannot read replica type: %s", err.Error())
-		return
-	}
-	superBlock.Ttl = needle.LoadTTLFromBytes(header[2:4])
-	superBlock.CompactionRevision = util.BytesToUint16(header[4:6])
-	superBlock.extraSize = util.BytesToUint16(header[6:8])
-
-	if superBlock.extraSize > 0 {
-		// read more
-		extraData := make([]byte, int(superBlock.extraSize))
-		superBlock.Extra = &master_pb.SuperBlockExtra{}
-		err = proto.Unmarshal(extraData, superBlock.Extra)
-		if err != nil {
-			err = fmt.Errorf("cannot read volume %s super block extra: %v", datBackend.String(), err)
-			return
+	v.SuperBlock, err = super_block.ReadSuperBlock(v.DataBackend)
+	if v.volumeInfo != nil && v.volumeInfo.Replication != "" {
+		if replication, err := super_block.NewReplicaPlacementFromString(v.volumeInfo.Replication); err != nil {
+			return fmt.Errorf("Error parse volume %d replication %s : %v", v.Id, v.volumeInfo.Replication, err)
+		} else {
+			v.SuperBlock.ReplicaPlacement = replication
 		}
 	}
-
-	return
+	return err
 }