seaweedfs/weed/topology/topology.go

172 lines
4.6 KiB
Go
Raw Normal View History

2012-08-24 05:33:37 +00:00
package topology
import (
"errors"
"math/rand"
2015-05-03 19:37:49 +00:00
"github.com/chrislusf/raft"
"github.com/chrislusf/seaweedfs/weed/glog"
"github.com/chrislusf/seaweedfs/weed/pb/master_pb"
"github.com/chrislusf/seaweedfs/weed/sequence"
"github.com/chrislusf/seaweedfs/weed/storage"
"github.com/chrislusf/seaweedfs/weed/util"
2012-08-24 05:33:37 +00:00
)
type Topology struct {
NodeImpl
collectionMap *util.ConcurrentReadMap
pulse int64
volumeSizeLimit uint64
Sequence sequence.Sequencer
2012-09-18 21:05:12 +00:00
2017-01-10 09:01:12 +00:00
chanFullVolumes chan storage.VolumeInfo
2017-01-10 09:01:12 +00:00
Configuration *Configuration
RaftServer raft.Server
2012-08-31 08:35:11 +00:00
}
2017-02-13 05:58:44 +00:00
func NewTopology(id string, seq sequence.Sequencer, volumeSizeLimit uint64, pulse int) *Topology {
t := &Topology{}
t.id = NodeId(id)
t.nodeType = "Topology"
t.NodeImpl.value = t
t.children = make(map[NodeId]Node)
t.collectionMap = util.NewConcurrentReadMap()
t.pulse = int64(pulse)
t.volumeSizeLimit = volumeSizeLimit
t.Sequence = seq
t.chanFullVolumes = make(chan storage.VolumeInfo)
2017-02-13 05:58:44 +00:00
t.Configuration = &Configuration{}
2017-02-13 05:58:44 +00:00
return t
}
func (t *Topology) IsLeader() bool {
2019-02-15 08:09:48 +00:00
if t.RaftServer != nil {
2019-01-28 18:36:16 +00:00
return t.RaftServer.State() == raft.Leader
}
return false
}
func (t *Topology) Leader() (string, error) {
l := ""
if t.RaftServer != nil {
l = t.RaftServer.Leader()
} else {
return "", errors.New("Raft Server not ready yet!")
}
if l == "" {
// We are a single node cluster, we are the leader
return t.RaftServer.Name(), errors.New("Raft Server not initialized!")
}
return l, nil
}
2013-11-12 10:21:22 +00:00
func (t *Topology) Lookup(collection string, vid storage.VolumeId) []*DataNode {
//maybe an issue if lots of collections?
if collection == "" {
2016-05-30 19:30:26 +00:00
for _, c := range t.collectionMap.Items() {
if list := c.(*Collection).Lookup(vid); list != nil {
return list
}
}
2013-11-12 10:21:22 +00:00
} else {
2016-05-30 19:30:26 +00:00
if c, ok := t.collectionMap.Find(collection); ok {
return c.(*Collection).Lookup(vid)
2013-11-12 10:21:22 +00:00
}
}
return nil
}
2012-09-03 08:50:04 +00:00
func (t *Topology) NextVolumeId() storage.VolumeId {
vid := t.GetMaxVolumeId()
next := vid.Next()
go t.RaftServer.Do(NewMaxVolumeIdCommand(next))
return next
}
2014-10-26 06:45:31 +00:00
func (t *Topology) HasWritableVolume(option *VolumeGrowOption) bool {
vl := t.GetVolumeLayout(option.Collection, option.ReplicaPlacement, option.Ttl)
return vl.GetActiveVolumeCount(option) > 0
}
func (t *Topology) PickForWrite(count uint64, option *VolumeGrowOption) (string, uint64, *DataNode, error) {
vid, count, datanodes, err := t.GetVolumeLayout(option.Collection, option.ReplicaPlacement, option.Ttl).PickForWrite(count, option)
2013-03-20 12:12:55 +00:00
if err != nil || datanodes.Length() == 0 {
2015-01-13 10:46:56 +00:00
return "", 0, nil, errors.New("No writable volumes available!")
}
fileId, count := t.Sequence.NextFileId(count)
return storage.NewFileId(*vid, fileId, rand.Uint32()).String(), count, datanodes.Head(), nil
}
func (t *Topology) GetVolumeLayout(collectionName string, rp *storage.ReplicaPlacement, ttl *storage.TTL) *VolumeLayout {
return t.collectionMap.Get(collectionName, func() interface{} {
return NewCollection(collectionName, t.volumeSizeLimit)
}).(*Collection).GetOrCreateVolumeLayout(rp, ttl)
2012-09-14 08:17:13 +00:00
}
2016-05-30 19:30:26 +00:00
func (t *Topology) FindCollection(collectionName string) (*Collection, bool) {
c, hasCollection := t.collectionMap.Find(collectionName)
if !hasCollection {
return nil, false
}
return c.(*Collection), hasCollection
}
func (t *Topology) DeleteCollection(collectionName string) {
2016-05-30 19:30:26 +00:00
t.collectionMap.Delete(collectionName)
}
func (t *Topology) RegisterVolumeLayout(v storage.VolumeInfo, dn *DataNode) {
t.GetVolumeLayout(v.Collection, v.ReplicaPlacement, v.Ttl).RegisterVolume(&v, dn)
}
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)
volumeLayout.UnRegisterVolume(&v, dn)
if volumeLayout.isEmpty() {
t.DeleteCollection(v.Collection)
}
}
func (t *Topology) GetOrCreateDataCenter(dcName string) *DataCenter {
for _, c := range t.Children() {
dc := c.(*DataCenter)
if string(dc.Id()) == dcName {
return dc
}
}
dc := NewDataCenter(dcName)
t.LinkChildNode(dc)
return dc
}
2018-06-25 07:01:53 +00:00
func (t *Topology) SyncDataNodeRegistration(volumes []*master_pb.VolumeInformationMessage, dn *DataNode) (newVolumes, deletedVolumes []storage.VolumeInfo) {
2018-06-25 07:01:53 +00:00
var volumeInfos []storage.VolumeInfo
for _, v := range volumes {
if vi, err := storage.NewVolumeInfo(v); err == nil {
volumeInfos = append(volumeInfos, vi)
} else {
glog.V(0).Infof("Fail to convert joined volume information: %v", err)
}
}
newVolumes, deletedVolumes = dn.UpdateVolumes(volumeInfos)
2018-06-25 07:01:53 +00:00
for _, v := range volumeInfos {
t.RegisterVolumeLayout(v, dn)
}
for _, v := range deletedVolumes {
t.UnRegisterVolumeLayout(v, dn)
}
return
2018-06-25 07:01:53 +00:00
}