volume server set volume type and heartbeat to the master

weed/command/volume.go

@@ -49,6 +49,7 @@ type VolumeServerOptions struct {
 	rack                  *string
 	whiteList             []string
 	indexType             *string
+	volumeType            *string
 	fixJpgOrientation     *bool
 	readRedirect          *bool
 	cpuProfile            *string
@@ -76,6 +77,7 @@ func init() {
 	v.dataCenter = cmdVolume.Flag.String("dataCenter", "", "current volume server's data center name")
 	v.rack = cmdVolume.Flag.String("rack", "", "current volume server's rack name")
 	v.indexType = cmdVolume.Flag.String("index", "memory", "Choose [memory|leveldb|leveldbMedium|leveldbLarge] mode for memory~performance balance.")
+	v.volumeType = cmdVolume.Flag.String("volumeType", "", "[hdd|ssd] choose between hard drive or solid state drive")
 	v.fixJpgOrientation = cmdVolume.Flag.Bool("images.fix.orientation", false, "Adjust jpg orientation when uploading.")
 	v.readRedirect = cmdVolume.Flag.Bool("read.redirect", true, "Redirect moved or non-local volumes.")
 	v.cpuProfile = cmdVolume.Flag.String("cpuprofile", "", "cpu profile output file")
@@ -210,10 +212,15 @@ func (v VolumeServerOptions) startVolumeServer(volumeFolders, maxVolumeCounts, v
 
 	masters := *v.masters
 
+	volumeType, err := storage.ToVolumeType(*v.volumeType)
+	if err != nil {
+		glog.Fatalf("failed to parse volume type: %v", err)
+	}
+
 	volumeServer := weed_server.NewVolumeServer(volumeMux, publicVolumeMux,
 		*v.ip, *v.port, *v.publicUrl,
 		v.folders, v.folderMaxLimits, v.minFreeSpacePercents,
-		*v.idxFolder,
+		*v.idxFolder, volumeType,
 		volumeNeedleMapKind,
 		strings.Split(masters, ","), 5, *v.dataCenter, *v.rack,
 		v.whiteList,

weed/pb/master.proto

@@ -44,7 +44,6 @@ message Heartbeat {
     string ip = 1;
     uint32 port = 2;
     string public_url = 3;
-    uint32 max_volume_count = 4;
     uint64 max_file_key = 5;
     string data_center = 6;
     string rack = 7;
@@ -62,6 +61,9 @@ message Heartbeat {
     repeated VolumeEcShardInformationMessage deleted_ec_shards = 18;
     bool has_no_ec_shards = 19;
 
+    uint32 max_volume_count = 4;
+    uint32 max_ssd_volume_count = 20;
+
 }
 
 message HeartbeatResponse {
@@ -87,6 +89,7 @@ message VolumeInformationMessage {
     int64 modified_at_second = 12;
     string remote_storage_name = 13;
     string remote_storage_key = 14;
+    string volume_type = 15;
 }
 
 message VolumeShortInformationMessage {
@@ -95,6 +98,7 @@ message VolumeShortInformationMessage {
     uint32 replica_placement = 8;
     uint32 version = 9;
     uint32 ttl = 10;
+    string volume_type = 15;
 }
 
 message VolumeEcShardInformationMessage {
@@ -218,6 +222,8 @@ message DataNodeInfo {
     repeated VolumeInformationMessage volume_infos = 6;
     repeated VolumeEcShardInformationMessage ec_shard_infos = 7;
     uint64 remote_volume_count = 8;
+    uint64 max_ssd_volume_count = 9;
+    uint64 ssd_volume_count = 10;
 }
 message RackInfo {
     string id = 1;
@@ -227,6 +233,8 @@ message RackInfo {
     uint64 active_volume_count = 5;
     repeated DataNodeInfo data_node_infos = 6;
     uint64 remote_volume_count = 7;
+    uint64 max_ssd_volume_count = 8;
+    uint64 ssd_volume_count = 9;
 }
 message DataCenterInfo {
     string id = 1;
@@ -236,6 +244,8 @@ message DataCenterInfo {
     uint64 active_volume_count = 5;
     repeated RackInfo rack_infos = 6;
     uint64 remote_volume_count = 7;
+    uint64 max_ssd_volume_count = 8;
+    uint64 ssd_volume_count = 9;
 }
 message TopologyInfo {
     string id = 1;
@@ -245,6 +255,8 @@ message TopologyInfo {
     uint64 active_volume_count = 5;
     repeated DataCenterInfo data_center_infos = 6;
     uint64 remote_volume_count = 7;
+    uint64 max_ssd_volume_count = 8;
+    uint64 ssd_volume_count = 9;
 }
 message VolumeListRequest {
 }

weed/server/master_grpc_server.go

@@ -67,9 +67,7 @@ func (ms *MasterServer) SendHeartbeat(stream master_pb.Seaweed_SendHeartbeatServ
 			dcName, rackName := ms.Topo.Configuration.Locate(heartbeat.Ip, heartbeat.DataCenter, heartbeat.Rack)
 			dc := ms.Topo.GetOrCreateDataCenter(dcName)
 			rack := dc.GetOrCreateRack(rackName)
-			dn = rack.GetOrCreateDataNode(heartbeat.Ip,
-				int(heartbeat.Port), heartbeat.PublicUrl,
-				int64(heartbeat.MaxVolumeCount))
+			dn = rack.GetOrCreateDataNode(heartbeat.Ip, int(heartbeat.Port), heartbeat.PublicUrl, int64(heartbeat.MaxVolumeCount), int64(heartbeat.MaxSsdVolumeCount))
 			glog.V(0).Infof("added volume server %v:%d", heartbeat.GetIp(), heartbeat.GetPort())
 			if err := stream.Send(&master_pb.HeartbeatResponse{
 				VolumeSizeLimit: uint64(ms.option.VolumeSizeLimitMB) * 1024 * 1024,
@@ -83,6 +81,10 @@ func (ms *MasterServer) SendHeartbeat(stream master_pb.Seaweed_SendHeartbeatServ
 			delta := int64(heartbeat.MaxVolumeCount) - dn.GetMaxVolumeCount()
 			dn.UpAdjustMaxVolumeCountDelta(delta)
 		}
+		if heartbeat.MaxSsdVolumeCount != 0 && dn.GetMaxSsdVolumeCount() != int64(heartbeat.MaxSsdVolumeCount) {
+			delta := int64(heartbeat.MaxSsdVolumeCount) - dn.GetMaxSsdVolumeCount()
+			dn.UpAdjustMaxSsdVolumeCountDelta(delta)
+		}
 
 		glog.V(4).Infof("master received heartbeat %s", heartbeat.String())
 		message := &master_pb.VolumeLocation{

weed/server/master_grpc_server_volume.go

@@ -126,7 +126,7 @@ func (ms *MasterServer) Statistics(ctx context.Context, req *master_pb.Statistic
 	volumeLayout := ms.Topo.GetVolumeLayout(req.Collection, replicaPlacement, ttl, storage.VolumeType(req.VolumeType))
 	stats := volumeLayout.Stats()
 
-	totalSize := ms.Topo.GetMaxVolumeCount() * int64(ms.option.VolumeSizeLimitMB) * 1024 * 1024
+	totalSize := (ms.Topo.GetMaxVolumeCount() + ms.Topo.GetMaxSsdVolumeCount()) * int64(ms.option.VolumeSizeLimitMB) * 1024 * 1024
 
 	resp := &master_pb.StatisticsResponse{
 		TotalSize: uint64(totalSize),

weed/server/volume_server.go

@@ -20,6 +20,7 @@ type VolumeServer struct {
 	pulseSeconds    int
 	dataCenter      string
 	rack            string
+	VolumeType      storage.VolumeType
 	store           *storage.Store
 	guard           *security.Guard
 	grpcDialOption  grpc.DialOption
@@ -38,7 +39,7 @@ type VolumeServer struct {
 func NewVolumeServer(adminMux, publicMux *http.ServeMux, ip string,
 	port int, publicUrl string,
 	folders []string, maxCounts []int, minFreeSpacePercents []float32,
-	idxFolder string,
+	idxFolder string, volumeType storage.VolumeType,
 	needleMapKind storage.NeedleMapType,
 	masterNodes []string, pulseSeconds int,
 	dataCenter string, rack string,
@@ -63,6 +64,7 @@ func NewVolumeServer(adminMux, publicMux *http.ServeMux, ip string,
 		pulseSeconds:            pulseSeconds,
 		dataCenter:              dataCenter,
 		rack:                    rack,
+		VolumeType:              volumeType,
 		needleMapKind:           needleMapKind,
 		FixJpgOrientation:       fixJpgOrientation,
 		ReadRedirect:            readRedirect,
@@ -76,7 +78,7 @@ func NewVolumeServer(adminMux, publicMux *http.ServeMux, ip string,
 
 	vs.checkWithMaster()
 
-	vs.store = storage.NewStore(vs.grpcDialOption, port, ip, publicUrl, folders, maxCounts, minFreeSpacePercents, idxFolder, vs.needleMapKind)
+	vs.store = storage.NewStore(vs.grpcDialOption, port, ip, publicUrl, folders, maxCounts, minFreeSpacePercents, idxFolder, vs.needleMapKind, vs.VolumeType)
 	vs.guard = security.NewGuard(whiteList, signingKey, expiresAfterSec, readSigningKey, readExpiresAfterSec)
 
 	handleStaticResources(adminMux)

weed/storage/disk_location.go

@@ -19,6 +19,7 @@ import (
 type DiskLocation struct {
 	Directory              string
 	IdxDirectory           string
+	VolumeType             VolumeType
 	MaxVolumeCount         int
 	OriginalMaxVolumeCount int
 	MinFreeSpacePercent    float32
@@ -32,7 +33,7 @@ type DiskLocation struct {
 	isDiskSpaceLow bool
 }
 
-func NewDiskLocation(dir string, maxVolumeCount int, minFreeSpacePercent float32, idxDir string) *DiskLocation {
+func NewDiskLocation(dir string, maxVolumeCount int, minFreeSpacePercent float32, idxDir string, volumeType VolumeType) *DiskLocation {
 	dir = util.ResolvePath(dir)
 	if idxDir == "" {
 		idxDir = dir
@@ -42,6 +43,7 @@ func NewDiskLocation(dir string, maxVolumeCount int, minFreeSpacePercent float32
 	location := &DiskLocation{
 		Directory:              dir,
 		IdxDirectory:           idxDir,
+		VolumeType:             volumeType,
 		MaxVolumeCount:         maxVolumeCount,
 		OriginalMaxVolumeCount: maxVolumeCount,
 		MinFreeSpacePercent:    minFreeSpacePercent,

weed/storage/store.go

@@ -52,11 +52,11 @@ func (s *Store) String() (str string) {
 	return
 }
 
-func NewStore(grpcDialOption grpc.DialOption, port int, ip, publicUrl string, dirnames []string, maxVolumeCounts []int, minFreeSpacePercents []float32, idxFolder string, needleMapKind NeedleMapType) (s *Store) {
+func NewStore(grpcDialOption grpc.DialOption, port int, ip, publicUrl string, dirnames []string, maxVolumeCounts []int, minFreeSpacePercents []float32, idxFolder string, needleMapKind NeedleMapType, volumeType VolumeType) (s *Store) {
 	s = &Store{grpcDialOption: grpcDialOption, Port: port, Ip: ip, PublicUrl: publicUrl, NeedleMapType: needleMapKind}
 	s.Locations = make([]*DiskLocation, 0)
 	for i := 0; i < len(dirnames); i++ {
-		location := NewDiskLocation(dirnames[i], maxVolumeCounts[i], minFreeSpacePercents[i], idxFolder)
+		location := NewDiskLocation(dirnames[i], maxVolumeCounts[i], minFreeSpacePercents[i], idxFolder, volumeType)
 		location.loadExistingVolumes(needleMapKind)
 		s.Locations = append(s.Locations, location)
 		stats.VolumeServerMaxVolumeCounter.Add(float64(maxVolumeCounts[i]))
@@ -203,12 +203,18 @@ func (s *Store) GetRack() string {
 func (s *Store) CollectHeartbeat() *master_pb.Heartbeat {
 	var volumeMessages []*master_pb.VolumeInformationMessage
 	maxVolumeCount := 0
+	maxSsdVolumeCount := 0
 	var maxFileKey NeedleId
 	collectionVolumeSize := make(map[string]uint64)
 	collectionVolumeReadOnlyCount := make(map[string]map[string]uint8)
 	for _, location := range s.Locations {
 		var deleteVids []needle.VolumeId
-		maxVolumeCount = maxVolumeCount + location.MaxVolumeCount
+		switch location.VolumeType {
+		case SsdType:
+			maxSsdVolumeCount = maxSsdVolumeCount + location.MaxVolumeCount
+		case HardDriveType:
+			maxVolumeCount = maxVolumeCount + location.MaxVolumeCount
+		}
 		location.volumesLock.RLock()
 		for _, v := range location.volumes {
 			curMaxFileKey, volumeMessage := v.ToVolumeInformationMessage()
@@ -280,15 +286,16 @@ func (s *Store) CollectHeartbeat() *master_pb.Heartbeat {
 	}
 
 	return &master_pb.Heartbeat{
-		Ip:             s.Ip,
-		Port:           uint32(s.Port),
-		PublicUrl:      s.PublicUrl,
-		MaxVolumeCount: uint32(maxVolumeCount),
-		MaxFileKey:     NeedleIdToUint64(maxFileKey),
-		DataCenter:     s.dataCenter,
-		Rack:           s.rack,
-		Volumes:        volumeMessages,
-		HasNoVolumes:   len(volumeMessages) == 0,
+		Ip:                s.Ip,
+		Port:              uint32(s.Port),
+		PublicUrl:         s.PublicUrl,
+		MaxVolumeCount:    uint32(maxVolumeCount),
+		MaxSsdVolumeCount: uint32(maxSsdVolumeCount),
+		MaxFileKey:        NeedleIdToUint64(maxFileKey),
+		DataCenter:        s.dataCenter,
+		Rack:              s.rack,
+		Volumes:           volumeMessages,
+		HasNoVolumes:      len(volumeMessages) == 0,
 	}
 
 }

weed/storage/volume.go

@@ -47,7 +47,7 @@ type Volume struct {
 	volumeInfo *volume_server_pb.VolumeInfo
 	location   *DiskLocation
 
-	lastIoError     error
+	lastIoError error
 }
 
 func NewVolume(dirname string, dirIdx string, collection string, id needle.VolumeId, needleMapKind NeedleMapType, replicaPlacement *super_block.ReplicaPlacement, ttl *needle.TTL, preallocate int64, memoryMapMaxSizeMb uint32) (v *Volume, e error) {
@@ -262,6 +262,7 @@ func (v *Volume) ToVolumeInformationMessage() (types.NeedleId, *master_pb.Volume
 		Ttl:              v.Ttl.ToUint32(),
 		CompactRevision:  uint32(v.SuperBlock.CompactionRevision),
 		ModifiedAtSecond: modTime.Unix(),
+		VolumeType:       string(v.location.VolumeType),
 	}
 
 	volumeInfo.RemoteStorageName, volumeInfo.RemoteStorageKey = v.RemoteStorageNameKey()

weed/storage/volume_info.go

@@ -14,7 +14,7 @@ type VolumeInfo struct {
 	Size              uint64
 	ReplicaPlacement  *super_block.ReplicaPlacement
 	Ttl               *needle.TTL
-	VolumeType        VolumeType
+	VolumeType        string
 	Collection        string
 	Version           needle.Version
 	FileCount         int
@@ -41,6 +41,7 @@ func NewVolumeInfo(m *master_pb.VolumeInformationMessage) (vi VolumeInfo, err er
 		ModifiedAtSecond:  m.ModifiedAtSecond,
 		RemoteStorageName: m.RemoteStorageName,
 		RemoteStorageKey:  m.RemoteStorageKey,
+		VolumeType:        m.VolumeType,
 	}
 	rp, e := super_block.NewReplicaPlacementFromByte(byte(m.ReplicaPlacement))
 	if e != nil {
@@ -91,6 +92,7 @@ func (vi VolumeInfo) ToVolumeInformationMessage() *master_pb.VolumeInformationMe
 		ModifiedAtSecond:  vi.ModifiedAtSecond,
 		RemoteStorageName: vi.RemoteStorageName,
 		RemoteStorageKey:  vi.RemoteStorageKey,
+		VolumeType:        vi.VolumeType,
 	}
 }
 

weed/topology/collection.go

@@ -44,6 +44,17 @@ func (c *Collection) GetOrCreateVolumeLayout(rp *super_block.ReplicaPlacement, t
 	return vl.(*VolumeLayout)
 }
 
+func (c *Collection) DeleteVolumeLayout(rp *super_block.ReplicaPlacement, ttl *needle.TTL, volumeType storage.VolumeType) {
+	keyString := rp.String()
+	if ttl != nil {
+		keyString += ttl.String()
+	}
+	if volumeType != storage.HardDriveType {
+		keyString += string(volumeType)
+	}
+	c.storageType2VolumeLayout.Delete(keyString)
+}
+
 func (c *Collection) Lookup(vid needle.VolumeId) []*DataNode {
 	for _, vl := range c.storageType2VolumeLayout.Items() {
 		if vl != nil {

weed/topology/data_center.go

@@ -31,6 +31,7 @@ func (dc *DataCenter) ToMap() interface{} {
 	m := make(map[string]interface{})
 	m["Id"] = dc.Id()
 	m["Max"] = dc.GetMaxVolumeCount()
+	m["MaxSsd"] = dc.GetMaxSsdVolumeCount()
 	m["Free"] = dc.FreeSpace()
 	var racks []interface{}
 	for _, c := range dc.Children() {
@@ -46,6 +47,8 @@ func (dc *DataCenter) ToDataCenterInfo() *master_pb.DataCenterInfo {
 		Id:                string(dc.Id()),
 		VolumeCount:       uint64(dc.GetVolumeCount()),
 		MaxVolumeCount:    uint64(dc.GetMaxVolumeCount()),
+		MaxSsdVolumeCount: uint64(dc.GetMaxSsdVolumeCount()),
+		SsdVolumeCount:    uint64(dc.GetSsdVolumeCount()),
 		FreeVolumeCount:   uint64(dc.FreeSpace()),
 		ActiveVolumeCount: uint64(dc.GetActiveVolumeCount()),
 		RemoteVolumeCount: uint64(dc.GetRemoteVolumeCount()),

weed/topology/data_node.go

@@ -50,7 +50,11 @@ func (dn *DataNode) AddOrUpdateVolume(v storage.VolumeInfo) (isNew, isChangedRO
 func (dn *DataNode) doAddOrUpdateVolume(v storage.VolumeInfo) (isNew, isChangedRO bool) {
 	if oldV, ok := dn.volumes[v.Id]; !ok {
 		dn.volumes[v.Id] = v
-		dn.UpAdjustVolumeCountDelta(1)
+		if v.VolumeType == storage.SsdType {
+			dn.UpAdjustSsdVolumeCountDelta(1)
+		} else {
+			dn.UpAdjustVolumeCountDelta(1)
+		}
 		if v.IsRemote() {
 			dn.UpAdjustRemoteVolumeCountDelta(1)
 		}
@@ -89,7 +93,11 @@ func (dn *DataNode) UpdateVolumes(actualVolumes []storage.VolumeInfo) (newVolume
 			glog.V(0).Infoln("Deleting volume id:", vid)
 			delete(dn.volumes, vid)
 			deletedVolumes = append(deletedVolumes, v)
-			dn.UpAdjustVolumeCountDelta(-1)
+			if v.VolumeType == storage.SsdType {
+				dn.UpAdjustSsdVolumeCountDelta(-1)
+			} else {
+				dn.UpAdjustVolumeCountDelta(-1)
+			}
 			if v.IsRemote() {
 				dn.UpAdjustRemoteVolumeCountDelta(-1)
 			}
@@ -116,7 +124,11 @@ func (dn *DataNode) DeltaUpdateVolumes(newVolumes, deletedVolumes []storage.Volu
 
 	for _, v := range deletedVolumes {
 		delete(dn.volumes, v.Id)
-		dn.UpAdjustVolumeCountDelta(-1)
+		if v.VolumeType == storage.SsdType {
+			dn.UpAdjustSsdVolumeCountDelta(-1)
+		} else {
+			dn.UpAdjustVolumeCountDelta(-1)
+		}
 		if v.IsRemote() {
 			dn.UpAdjustRemoteVolumeCountDelta(-1)
 		}
@@ -182,6 +194,7 @@ func (dn *DataNode) ToMap() interface{} {
 	ret["VolumeIds"] = dn.GetVolumeIds()
 	ret["EcShards"] = dn.GetEcShardCount()
 	ret["Max"] = dn.GetMaxVolumeCount()
+	ret["MaxSsd"] = dn.GetMaxSsdVolumeCount()
 	ret["Free"] = dn.FreeSpace()
 	ret["PublicUrl"] = dn.PublicUrl
 	return ret
@@ -192,6 +205,8 @@ func (dn *DataNode) ToDataNodeInfo() *master_pb.DataNodeInfo {
 		Id:                string(dn.Id()),
 		VolumeCount:       uint64(dn.GetVolumeCount()),
 		MaxVolumeCount:    uint64(dn.GetMaxVolumeCount()),
+		MaxSsdVolumeCount: uint64(dn.GetMaxSsdVolumeCount()),
+		SsdVolumeCount:    uint64(dn.GetSsdVolumeCount()),
 		FreeVolumeCount:   uint64(dn.FreeSpace()),
 		ActiveVolumeCount: uint64(dn.GetActiveVolumeCount()),
 		RemoteVolumeCount: uint64(dn.GetRemoteVolumeCount()),

weed/topology/node.go

@@ -19,17 +19,21 @@ type Node interface {
 	FreeSpace() int64
 	ReserveOneVolume(r int64) (*DataNode, error)
 	UpAdjustMaxVolumeCountDelta(maxVolumeCountDelta int64)
+	UpAdjustMaxSsdVolumeCountDelta(maxSsdVolumeCountDelta int64)
 	UpAdjustVolumeCountDelta(volumeCountDelta int64)
+	UpAdjustSsdVolumeCountDelta(ssdVolumeCountDelta int64)
 	UpAdjustRemoteVolumeCountDelta(remoteVolumeCountDelta int64)
 	UpAdjustEcShardCountDelta(ecShardCountDelta int64)
 	UpAdjustActiveVolumeCountDelta(activeVolumeCountDelta int64)
 	UpAdjustMaxVolumeId(vid needle.VolumeId)
 
 	GetVolumeCount() int64
+	GetSsdVolumeCount() int64
 	GetEcShardCount() int64
 	GetActiveVolumeCount() int64
 	GetRemoteVolumeCount() int64
 	GetMaxVolumeCount() int64
+	GetMaxSsdVolumeCount() int64
 	GetMaxVolumeId() needle.VolumeId
 	SetParent(Node)
 	LinkChildNode(node Node)
@@ -47,9 +51,11 @@ type Node interface {
 type NodeImpl struct {
 	volumeCount       int64
 	remoteVolumeCount int64
+	ssdVolumeCount    int64
 	activeVolumeCount int64
 	ecShardCount      int64
 	maxVolumeCount    int64
+	maxSsdVolumeCount int64
 	id                NodeId
 	parent            Node
 	sync.RWMutex      // lock children
@@ -143,7 +149,7 @@ func (n *NodeImpl) Id() NodeId {
 	return n.id
 }
 func (n *NodeImpl) FreeSpace() int64 {
-	freeVolumeSlotCount := n.maxVolumeCount + n.remoteVolumeCount - n.volumeCount
+	freeVolumeSlotCount := n.maxVolumeCount + n.maxSsdVolumeCount + n.remoteVolumeCount - n.volumeCount - n.ssdVolumeCount
 	if n.ecShardCount > 0 {
 		freeVolumeSlotCount = freeVolumeSlotCount - n.ecShardCount/erasure_coding.DataShardsCount - 1
 	}
@@ -200,6 +206,15 @@ func (n *NodeImpl) UpAdjustMaxVolumeCountDelta(maxVolumeCountDelta int64) { //ca
 		n.parent.UpAdjustMaxVolumeCountDelta(maxVolumeCountDelta)
 	}
 }
+func (n *NodeImpl) UpAdjustMaxSsdVolumeCountDelta(maxSsdVolumeCountDelta int64) { //can be negative
+	if maxSsdVolumeCountDelta == 0 {
+		return
+	}
+	atomic.AddInt64(&n.maxSsdVolumeCount, maxSsdVolumeCountDelta)
+	if n.parent != nil {
+		n.parent.UpAdjustMaxSsdVolumeCountDelta(maxSsdVolumeCountDelta)
+	}
+}
 func (n *NodeImpl) UpAdjustVolumeCountDelta(volumeCountDelta int64) { //can be negative
 	if volumeCountDelta == 0 {
 		return
@@ -218,6 +233,15 @@ func (n *NodeImpl) UpAdjustRemoteVolumeCountDelta(remoteVolumeCountDelta int64)
 		n.parent.UpAdjustRemoteVolumeCountDelta(remoteVolumeCountDelta)
 	}
 }
+func (n *NodeImpl) UpAdjustSsdVolumeCountDelta(ssdVolumeCountDelta int64) { //can be negative
+	if ssdVolumeCountDelta == 0 {
+		return
+	}
+	atomic.AddInt64(&n.ssdVolumeCount, ssdVolumeCountDelta)
+	if n.parent != nil {
+		n.parent.UpAdjustSsdVolumeCountDelta(ssdVolumeCountDelta)
+	}
+}
 func (n *NodeImpl) UpAdjustEcShardCountDelta(ecShardCountDelta int64) { //can be negative
 	if ecShardCountDelta == 0 {
 		return
@@ -250,6 +274,9 @@ func (n *NodeImpl) GetMaxVolumeId() needle.VolumeId {
 func (n *NodeImpl) GetVolumeCount() int64 {
 	return n.volumeCount
 }
+func (n *NodeImpl) GetSsdVolumeCount() int64 {
+	return n.ssdVolumeCount
+}
 func (n *NodeImpl) GetEcShardCount() int64 {
 	return n.ecShardCount
 }
@@ -262,6 +289,9 @@ func (n *NodeImpl) GetActiveVolumeCount() int64 {
 func (n *NodeImpl) GetMaxVolumeCount() int64 {
 	return n.maxVolumeCount
 }
+func (n *NodeImpl) GetMaxSsdVolumeCount() int64 {
+	return n.maxSsdVolumeCount
+}
 
 func (n *NodeImpl) LinkChildNode(node Node) {
 	n.Lock()
@@ -269,8 +299,10 @@ func (n *NodeImpl) LinkChildNode(node Node) {
 	if n.children[node.Id()] == nil {
 		n.children[node.Id()] = node
 		n.UpAdjustMaxVolumeCountDelta(node.GetMaxVolumeCount())
+		n.UpAdjustMaxSsdVolumeCountDelta(node.GetMaxSsdVolumeCount())
 		n.UpAdjustMaxVolumeId(node.GetMaxVolumeId())
 		n.UpAdjustVolumeCountDelta(node.GetVolumeCount())
+		n.UpAdjustSsdVolumeCountDelta(node.GetSsdVolumeCount())
 		n.UpAdjustRemoteVolumeCountDelta(node.GetRemoteVolumeCount())
 		n.UpAdjustEcShardCountDelta(node.GetEcShardCount())
 		n.UpAdjustActiveVolumeCountDelta(node.GetActiveVolumeCount())
@@ -287,10 +319,12 @@ func (n *NodeImpl) UnlinkChildNode(nodeId NodeId) {
 		node.SetParent(nil)
 		delete(n.children, node.Id())
 		n.UpAdjustVolumeCountDelta(-node.GetVolumeCount())
+		n.UpAdjustSsdVolumeCountDelta(-node.GetSsdVolumeCount())
 		n.UpAdjustRemoteVolumeCountDelta(-node.GetRemoteVolumeCount())
 		n.UpAdjustEcShardCountDelta(-node.GetEcShardCount())
 		n.UpAdjustActiveVolumeCountDelta(-node.GetActiveVolumeCount())
 		n.UpAdjustMaxVolumeCountDelta(-node.GetMaxVolumeCount())
+		n.UpAdjustMaxSsdVolumeCountDelta(-node.GetMaxSsdVolumeCount())
 		glog.V(0).Infoln(n, "removes", node.Id())
 	}
 }

weed/topology/rack.go

@@ -28,7 +28,7 @@ func (r *Rack) FindDataNode(ip string, port int) *DataNode {
 	}
 	return nil
 }
-func (r *Rack) GetOrCreateDataNode(ip string, port int, publicUrl string, maxVolumeCount int64) *DataNode {
+func (r *Rack) GetOrCreateDataNode(ip string, port int, publicUrl string, maxVolumeCount int64, maxSsdVolumeCount int64) *DataNode {
 	for _, c := range r.Children() {
 		dn := c.(*DataNode)
 		if dn.MatchLocation(ip, port) {
@@ -41,6 +41,7 @@ func (r *Rack) GetOrCreateDataNode(ip string, port int, publicUrl string, maxVol
 	dn.Port = port
 	dn.PublicUrl = publicUrl
 	dn.maxVolumeCount = maxVolumeCount
+	dn.maxSsdVolumeCount = maxSsdVolumeCount
 	dn.LastSeen = time.Now().Unix()
 	r.LinkChildNode(dn)
 	return dn
@@ -50,6 +51,7 @@ func (r *Rack) ToMap() interface{} {
 	m := make(map[string]interface{})
 	m["Id"] = r.Id()
 	m["Max"] = r.GetMaxVolumeCount()
+	m["MaxSsd"] = r.GetMaxSsdVolumeCount()
 	m["Free"] = r.FreeSpace()
 	var dns []interface{}
 	for _, c := range r.Children() {
@@ -65,6 +67,8 @@ func (r *Rack) ToRackInfo() *master_pb.RackInfo {
 		Id:                string(r.Id()),
 		VolumeCount:       uint64(r.GetVolumeCount()),
 		MaxVolumeCount:    uint64(r.GetMaxVolumeCount()),
+		MaxSsdVolumeCount: uint64(r.GetMaxSsdVolumeCount()),
+		SsdVolumeCount:    uint64(r.GetSsdVolumeCount()),
 		FreeVolumeCount:   uint64(r.FreeSpace()),
 		ActiveVolumeCount: uint64(r.GetActiveVolumeCount()),
 		RemoteVolumeCount: uint64(r.GetRemoteVolumeCount()),

weed/topology/topology.go

@@ -176,17 +176,27 @@ func (t *Topology) DeleteCollection(collectionName string) {
 	t.collectionMap.Delete(collectionName)
 }
 
+func (t *Topology) DeleteLayout(collectionName string, rp *super_block.ReplicaPlacement, ttl *needle.TTL, volumeType storage.VolumeType) {
+	collection, found := t.FindCollection(collectionName)
+	if !found {
+		return
+	}
+	collection.DeleteVolumeLayout(rp, ttl, volumeType)
+}
+
 func (t *Topology) RegisterVolumeLayout(v storage.VolumeInfo, dn *DataNode) {
-	vl := t.GetVolumeLayout(v.Collection, v.ReplicaPlacement, v.Ttl, v.VolumeType)
+	volumeType, _ := storage.ToVolumeType(v.VolumeType)
+	vl := t.GetVolumeLayout(v.Collection, v.ReplicaPlacement, v.Ttl, volumeType)
 	vl.RegisterVolume(&v, dn)
 	vl.EnsureCorrectWritables(&v)
 }
 func (t *Topology) UnRegisterVolumeLayout(v storage.VolumeInfo, dn *DataNode) {
 	glog.Infof("removing volume info: %+v", v)
-	volumeLayout := t.GetVolumeLayout(v.Collection, v.ReplicaPlacement, v.Ttl, v.VolumeType)
+	volumeType, _ := storage.ToVolumeType(v.VolumeType)
+	volumeLayout := t.GetVolumeLayout(v.Collection, v.ReplicaPlacement, v.Ttl, volumeType)
 	volumeLayout.UnRegisterVolume(&v, dn)
 	if volumeLayout.isEmpty() {
-		t.DeleteCollection(v.Collection)
+		t.DeleteLayout(v.Collection, v.ReplicaPlacement, v.Ttl, volumeType)
 	}
 }
 
@@ -222,7 +232,8 @@ func (t *Topology) SyncDataNodeRegistration(volumes []*master_pb.VolumeInformati
 		t.UnRegisterVolumeLayout(v, dn)
 	}
 	for _, v := range changedVolumes {
-		vl := t.GetVolumeLayout(v.Collection, v.ReplicaPlacement, v.Ttl, v.VolumeType)
+		volumeType, _ := storage.ToVolumeType(v.VolumeType)
+		vl := t.GetVolumeLayout(v.Collection, v.ReplicaPlacement, v.Ttl, volumeType)
 		vl.EnsureCorrectWritables(&v)
 	}
 	return

weed/topology/topology_event_handling.go

@@ -37,7 +37,8 @@ func (t *Topology) StartRefreshWritableVolumes(grpcDialOption grpc.DialOption, g
 	}()
 }
 func (t *Topology) SetVolumeCapacityFull(volumeInfo storage.VolumeInfo) bool {
-	vl := t.GetVolumeLayout(volumeInfo.Collection, volumeInfo.ReplicaPlacement, volumeInfo.Ttl, volumeInfo.VolumeType)
+	volumeType, _ := storage.ToVolumeType(volumeInfo.VolumeType)
+	vl := t.GetVolumeLayout(volumeInfo.Collection, volumeInfo.ReplicaPlacement, volumeInfo.Ttl, volumeType)
 	if !vl.SetVolumeCapacityFull(volumeInfo.Id) {
 		return false
 	}
@@ -55,13 +56,16 @@ func (t *Topology) SetVolumeCapacityFull(volumeInfo storage.VolumeInfo) bool {
 func (t *Topology) UnRegisterDataNode(dn *DataNode) {
 	for _, v := range dn.GetVolumes() {
 		glog.V(0).Infoln("Removing Volume", v.Id, "from the dead volume server", dn.Id())
-		vl := t.GetVolumeLayout(v.Collection, v.ReplicaPlacement, v.Ttl, v.VolumeType)
+		volumeType, _ := storage.ToVolumeType(v.VolumeType)
+		vl := t.GetVolumeLayout(v.Collection, v.ReplicaPlacement, v.Ttl, volumeType)
 		vl.SetVolumeUnavailable(dn, v.Id)
 	}
 	dn.UpAdjustVolumeCountDelta(-dn.GetVolumeCount())
+	dn.UpAdjustSsdVolumeCountDelta(-dn.GetSsdVolumeCount())
 	dn.UpAdjustRemoteVolumeCountDelta(-dn.GetRemoteVolumeCount())
 	dn.UpAdjustActiveVolumeCountDelta(-dn.GetActiveVolumeCount())
 	dn.UpAdjustMaxVolumeCountDelta(-dn.GetMaxVolumeCount())
+	dn.UpAdjustMaxSsdVolumeCountDelta(-dn.GetMaxSsdVolumeCount())
 	if dn.Parent() != nil {
 		dn.Parent().UnlinkChildNode(dn.Id())
 	}

weed/topology/topology_map.go

@@ -5,6 +5,7 @@ import "github.com/chrislusf/seaweedfs/weed/pb/master_pb"
 func (t *Topology) ToMap() interface{} {
 	m := make(map[string]interface{})
 	m["Max"] = t.GetMaxVolumeCount()
+	m["MaxSsd"] = t.GetMaxSsdVolumeCount()
 	m["Free"] = t.FreeSpace()
 	var dcs []interface{}
 	for _, c := range t.Children() {
@@ -30,6 +31,7 @@ func (t *Topology) ToMap() interface{} {
 func (t *Topology) ToVolumeMap() interface{} {
 	m := make(map[string]interface{})
 	m["Max"] = t.GetMaxVolumeCount()
+	m["MaxSsd"] = t.GetMaxSsdVolumeCount()
 	m["Free"] = t.FreeSpace()
 	dcs := make(map[NodeId]interface{})
 	for _, c := range t.Children() {
@@ -83,9 +85,11 @@ func (t *Topology) ToTopologyInfo() *master_pb.TopologyInfo {
 		Id:                string(t.Id()),
 		VolumeCount:       uint64(t.GetVolumeCount()),
 		MaxVolumeCount:    uint64(t.GetMaxVolumeCount()),
+		MaxSsdVolumeCount: uint64(t.GetMaxSsdVolumeCount()),
 		FreeVolumeCount:   uint64(t.FreeSpace()),
 		ActiveVolumeCount: uint64(t.GetActiveVolumeCount()),
 		RemoteVolumeCount: uint64(t.GetRemoteVolumeCount()),
+		SsdVolumeCount:    uint64(t.GetSsdVolumeCount()),
 	}
 	for _, c := range t.Children() {
 		dc := c.(*DataCenter)

weed/topology/topology_test.go

@@ -27,7 +27,7 @@ func TestHandlingVolumeServerHeartbeat(t *testing.T) {
 
 	dc := topo.GetOrCreateDataCenter("dc1")
 	rack := dc.GetOrCreateRack("rack1")
-	dn := rack.GetOrCreateDataNode("127.0.0.1", 34534, "127.0.0.1", 25)
+	dn := rack.GetOrCreateDataNode("127.0.0.1", 34534, "127.0.0.1", 25, 12)
 
 	{
 		volumeCount := 7
@@ -48,10 +48,28 @@ func TestHandlingVolumeServerHeartbeat(t *testing.T) {
 			volumeMessages = append(volumeMessages, volumeMessage)
 		}
 
+		for k := 1; k <= volumeCount; k++ {
+			volumeMessage := &master_pb.VolumeInformationMessage{
+				Id:               uint32(volumeCount + k),
+				Size:             uint64(25432),
+				Collection:       "",
+				FileCount:        uint64(2343),
+				DeleteCount:      uint64(345),
+				DeletedByteCount: 34524,
+				ReadOnly:         false,
+				ReplicaPlacement: uint32(0),
+				Version:          uint32(needle.CurrentVersion),
+				Ttl:              0,
+				VolumeType:       "ssd",
+			}
+			volumeMessages = append(volumeMessages, volumeMessage)
+		}
+
 		topo.SyncDataNodeRegistration(volumeMessages, dn)
 
-		assert(t, "activeVolumeCount1", int(topo.activeVolumeCount), volumeCount)
+		assert(t, "activeVolumeCount1", int(topo.activeVolumeCount), volumeCount*2)
 		assert(t, "volumeCount", int(topo.volumeCount), volumeCount)
+		assert(t, "ssdVolumeCount", int(topo.ssdVolumeCount), volumeCount)
 	}
 
 	{
@@ -115,7 +133,7 @@ func TestHandlingVolumeServerHeartbeat(t *testing.T) {
 			nil,
 			dn)
 
-		for vid, _ := range layout.vid2location {
+		for vid := range layout.vid2location {
 			println("after add volume id", vid)
 		}
 		for _, vid := range layout.writables {
@@ -144,12 +162,13 @@ func TestAddRemoveVolume(t *testing.T) {
 
 	dc := topo.GetOrCreateDataCenter("dc1")
 	rack := dc.GetOrCreateRack("rack1")
-	dn := rack.GetOrCreateDataNode("127.0.0.1", 34534, "127.0.0.1", 25)
+	dn := rack.GetOrCreateDataNode("127.0.0.1", 34534, "127.0.0.1", 25, 12)
 
 	v := storage.VolumeInfo{
 		Id:               needle.VolumeId(1),
 		Size:             100,
 		Collection:       "xcollection",
+		VolumeType:       "ssd",
 		FileCount:        123,
 		DeleteCount:      23,
 		DeletedByteCount: 45,