2012-08-24 05:33:37 +00:00
|
|
|
package topology
|
|
|
|
|
|
|
|
import (
|
2014-10-26 18:34:55 +00:00
|
|
|
"errors"
|
|
|
|
"io/ioutil"
|
|
|
|
"math/rand"
|
|
|
|
|
2014-09-25 08:57:22 +00:00
|
|
|
"github.com/chrislusf/weed-fs/go/glog"
|
|
|
|
"github.com/chrislusf/weed-fs/go/operation"
|
|
|
|
"github.com/chrislusf/weed-fs/go/sequence"
|
|
|
|
"github.com/chrislusf/weed-fs/go/storage"
|
2014-12-09 04:29:25 +00:00
|
|
|
"github.com/chrislusf/weed-fs/go/util"
|
2014-03-16 06:03:49 +00:00
|
|
|
"github.com/goraft/raft"
|
2012-08-24 05:33:37 +00:00
|
|
|
)
|
|
|
|
|
|
|
|
type Topology struct {
|
2012-09-02 21:33:48 +00:00
|
|
|
NodeImpl
|
2012-09-10 07:18:07 +00:00
|
|
|
|
2014-12-09 04:29:25 +00:00
|
|
|
collectionMap *util.ConcurrentReadMap
|
2012-09-10 07:18:07 +00:00
|
|
|
|
|
|
|
pulse int64
|
|
|
|
|
|
|
|
volumeSizeLimit uint64
|
|
|
|
|
2014-04-17 06:43:27 +00:00
|
|
|
Sequence sequence.Sequencer
|
2012-09-18 21:05:12 +00:00
|
|
|
|
|
|
|
chanDeadDataNodes chan *DataNode
|
|
|
|
chanRecoveredDataNodes chan *DataNode
|
2012-12-04 04:28:12 +00:00
|
|
|
chanFullVolumes chan storage.VolumeInfo
|
2012-09-24 09:01:53 +00:00
|
|
|
|
2012-09-23 03:46:31 +00:00
|
|
|
configuration *Configuration
|
2014-03-16 06:03:49 +00:00
|
|
|
|
|
|
|
RaftServer raft.Server
|
2012-08-31 08:35:11 +00:00
|
|
|
}
|
2012-08-28 08:04:39 +00:00
|
|
|
|
2013-11-10 09:31:50 +00:00
|
|
|
func NewTopology(id string, confFile string, seq sequence.Sequencer, volumeSizeLimit uint64, pulse int) (*Topology, error) {
|
2012-09-02 21:33:48 +00:00
|
|
|
t := &Topology{}
|
|
|
|
t.id = NodeId(id)
|
|
|
|
t.nodeType = "Topology"
|
2012-09-19 08:45:30 +00:00
|
|
|
t.NodeImpl.value = t
|
2012-09-02 21:33:48 +00:00
|
|
|
t.children = make(map[NodeId]Node)
|
2014-12-09 04:29:25 +00:00
|
|
|
t.collectionMap = util.NewConcurrentReadMap()
|
2012-09-10 07:18:07 +00:00
|
|
|
t.pulse = int64(pulse)
|
|
|
|
t.volumeSizeLimit = volumeSizeLimit
|
2012-09-19 08:45:30 +00:00
|
|
|
|
2014-04-17 06:43:27 +00:00
|
|
|
t.Sequence = seq
|
2012-09-19 08:45:30 +00:00
|
|
|
|
2012-09-18 21:05:12 +00:00
|
|
|
t.chanDeadDataNodes = make(chan *DataNode)
|
|
|
|
t.chanRecoveredDataNodes = make(chan *DataNode)
|
2012-12-04 04:28:12 +00:00
|
|
|
t.chanFullVolumes = make(chan storage.VolumeInfo)
|
2012-09-19 08:45:30 +00:00
|
|
|
|
2013-02-27 06:54:22 +00:00
|
|
|
err := t.loadConfiguration(confFile)
|
2012-09-24 09:01:53 +00:00
|
|
|
|
2013-02-27 06:54:22 +00:00
|
|
|
return t, err
|
2012-09-02 21:33:48 +00:00
|
|
|
}
|
2012-09-17 00:31:15 +00:00
|
|
|
|
2014-03-16 06:03:49 +00:00
|
|
|
func (t *Topology) IsLeader() bool {
|
2014-04-11 23:23:58 +00:00
|
|
|
if leader, e := t.Leader(); e == nil {
|
|
|
|
return leader == t.RaftServer.Name()
|
|
|
|
}
|
|
|
|
return false
|
2014-03-16 06:03:49 +00:00
|
|
|
}
|
|
|
|
|
2014-04-11 23:23:58 +00:00
|
|
|
func (t *Topology) Leader() (string, error) {
|
2014-03-16 06:03:49 +00:00
|
|
|
l := ""
|
|
|
|
if t.RaftServer != nil {
|
|
|
|
l = t.RaftServer.Leader()
|
2014-04-11 23:23:58 +00:00
|
|
|
} else {
|
|
|
|
return "", errors.New("Raft Server not ready yet!")
|
2014-03-16 06:03:49 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
if l == "" {
|
|
|
|
// We are a single node cluster, we are the leader
|
2014-04-11 23:23:58 +00:00
|
|
|
return t.RaftServer.Name(), errors.New("Raft Server not initialized!")
|
2014-03-16 06:03:49 +00:00
|
|
|
}
|
|
|
|
|
2014-04-11 23:23:58 +00:00
|
|
|
return l, nil
|
2014-03-16 06:03:49 +00:00
|
|
|
}
|
|
|
|
|
2012-09-24 09:01:53 +00:00
|
|
|
func (t *Topology) loadConfiguration(configurationFile string) error {
|
|
|
|
b, e := ioutil.ReadFile(configurationFile)
|
|
|
|
if e == nil {
|
|
|
|
t.configuration, e = NewConfiguration(b)
|
2013-03-19 17:33:33 +00:00
|
|
|
return e
|
2013-03-19 17:36:29 +00:00
|
|
|
} else {
|
2013-08-09 06:57:22 +00:00
|
|
|
glog.V(0).Infoln("Using default configurations.")
|
2012-09-24 09:01:53 +00:00
|
|
|
}
|
2013-03-19 17:33:33 +00:00
|
|
|
return nil
|
2012-09-23 03:46:31 +00:00
|
|
|
}
|
|
|
|
|
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 == "" {
|
2014-12-09 04:29:25 +00:00
|
|
|
for _, c := range t.collectionMap.Items {
|
|
|
|
if list := c.(*Collection).Lookup(vid); list != nil {
|
2012-09-24 09:01:53 +00:00
|
|
|
return list
|
|
|
|
}
|
|
|
|
}
|
2013-11-12 10:21:22 +00:00
|
|
|
} else {
|
2014-12-09 04:29:25 +00:00
|
|
|
if c, ok := t.collectionMap.Items[collection]; ok {
|
|
|
|
return c.(*Collection).Lookup(vid)
|
2013-11-12 10:21:22 +00:00
|
|
|
}
|
2012-09-24 09:01:53 +00:00
|
|
|
}
|
|
|
|
return nil
|
2012-09-23 22:45:26 +00:00
|
|
|
}
|
|
|
|
|
2012-09-03 08:50:04 +00:00
|
|
|
func (t *Topology) NextVolumeId() storage.VolumeId {
|
2012-09-02 21:33:48 +00:00
|
|
|
vid := t.GetMaxVolumeId()
|
2014-03-16 06:03:49 +00:00
|
|
|
next := vid.Next()
|
|
|
|
go t.RaftServer.Do(NewMaxVolumeIdCommand(next))
|
|
|
|
return next
|
2012-08-28 08:04:39 +00:00
|
|
|
}
|
2012-09-10 07:18:07 +00:00
|
|
|
|
2014-10-26 06:45:31 +00:00
|
|
|
func (t *Topology) HasWritableVolume(option *VolumeGrowOption) bool {
|
2014-09-20 19:38:59 +00:00
|
|
|
vl := t.GetVolumeLayout(option.Collection, option.ReplicaPlacement, option.Ttl)
|
2014-04-13 08:29:52 +00:00
|
|
|
return vl.GetActiveVolumeCount(option) > 0
|
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Topology) PickForWrite(count int, option *VolumeGrowOption) (string, int, *DataNode, error) {
|
2014-09-20 19:38:59 +00:00
|
|
|
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!")
|
2012-09-17 00:31:15 +00:00
|
|
|
}
|
2014-04-17 06:43:27 +00:00
|
|
|
fileId, count := t.Sequence.NextFileId(count)
|
2013-04-16 07:10:21 +00:00
|
|
|
return storage.NewFileId(*vid, fileId, rand.Uint32()).String(), count, datanodes.Head(), nil
|
2012-09-17 00:31:15 +00:00
|
|
|
}
|
|
|
|
|
2014-09-20 19:38:59 +00:00
|
|
|
func (t *Topology) GetVolumeLayout(collectionName string, rp *storage.ReplicaPlacement, ttl *storage.TTL) *VolumeLayout {
|
2014-12-09 04:29:25 +00:00
|
|
|
return t.collectionMap.Get(collectionName, func() interface{} {
|
|
|
|
return NewCollection(collectionName, t.volumeSizeLimit)
|
|
|
|
}).(*Collection).GetOrCreateVolumeLayout(rp, ttl)
|
2012-09-14 08:17:13 +00:00
|
|
|
}
|
|
|
|
|
2014-12-09 04:29:25 +00:00
|
|
|
func (t *Topology) GetCollection(collectionName string) (*Collection, bool) {
|
|
|
|
c, hasCollection := t.collectionMap.Items[collectionName]
|
|
|
|
return c.(*Collection), hasCollection
|
2014-03-10 18:43:54 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
func (t *Topology) DeleteCollection(collectionName string) {
|
2014-12-09 04:29:25 +00:00
|
|
|
delete(t.collectionMap.Items, collectionName)
|
2014-03-10 18:43:54 +00:00
|
|
|
}
|
|
|
|
|
2014-03-19 11:48:13 +00:00
|
|
|
func (t *Topology) RegisterVolumeLayout(v storage.VolumeInfo, dn *DataNode) {
|
2014-09-20 19:38:59 +00:00
|
|
|
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)
|
|
|
|
t.GetVolumeLayout(v.Collection, v.ReplicaPlacement, v.Ttl).UnRegisterVolume(&v, dn)
|
2012-09-17 00:31:15 +00:00
|
|
|
}
|
|
|
|
|
2014-09-20 19:38:59 +00:00
|
|
|
func (t *Topology) ProcessJoinMessage(joinMessage *operation.JoinMessage) {
|
2014-04-21 09:11:10 +00:00
|
|
|
t.Sequence.SetMax(*joinMessage.MaxFileKey)
|
|
|
|
dcName, rackName := t.configuration.Locate(*joinMessage.Ip, *joinMessage.DataCenter, *joinMessage.Rack)
|
2012-09-23 03:46:31 +00:00
|
|
|
dc := t.GetOrCreateDataCenter(dcName)
|
|
|
|
rack := dc.GetOrCreateRack(rackName)
|
2014-04-21 09:11:10 +00:00
|
|
|
dn := rack.FindDataNode(*joinMessage.Ip, int(*joinMessage.Port))
|
|
|
|
if *joinMessage.IsInit && dn != nil {
|
2012-12-23 00:26:02 +00:00
|
|
|
t.UnRegisterDataNode(dn)
|
|
|
|
}
|
2015-01-19 01:03:38 +00:00
|
|
|
adminPort = *joinMessage.Port
|
|
|
|
if joinMessage.AdminPort != nil {
|
|
|
|
adminPort = *joinMessage.AdminPort
|
|
|
|
}
|
|
|
|
dn = rack.GetOrCreateDataNode(*joinMessage.Ip,
|
|
|
|
int(*joinMessage.Port), int(adminPort), *joinMessage.PublicUrl,
|
|
|
|
int(*joinMessage.MaxVolumeCount))
|
2014-04-21 09:11:10 +00:00
|
|
|
var volumeInfos []storage.VolumeInfo
|
|
|
|
for _, v := range joinMessage.Volumes {
|
|
|
|
if vi, err := storage.NewVolumeInfo(v); err == nil {
|
|
|
|
volumeInfos = append(volumeInfos, vi)
|
|
|
|
} else {
|
|
|
|
glog.V(0).Infoln("Fail to convert joined volume information:", err.Error())
|
|
|
|
}
|
|
|
|
}
|
2014-09-20 19:38:59 +00:00
|
|
|
deletedVolumes := dn.UpdateVolumes(volumeInfos)
|
2012-09-17 00:31:15 +00:00
|
|
|
for _, v := range volumeInfos {
|
2014-03-19 11:48:13 +00:00
|
|
|
t.RegisterVolumeLayout(v, dn)
|
2012-09-17 00:31:15 +00:00
|
|
|
}
|
2014-09-20 19:38:59 +00:00
|
|
|
for _, v := range deletedVolumes {
|
|
|
|
t.UnRegisterVolumeLayout(v, dn)
|
|
|
|
}
|
2012-09-14 08:17:13 +00:00
|
|
|
}
|
|
|
|
|
2012-09-23 03:46:31 +00:00
|
|
|
func (t *Topology) GetOrCreateDataCenter(dcName string) *DataCenter {
|
2012-09-17 00:31:15 +00:00
|
|
|
for _, c := range t.Children() {
|
|
|
|
dc := c.(*DataCenter)
|
2012-09-23 03:46:31 +00:00
|
|
|
if string(dc.Id()) == dcName {
|
2012-09-17 00:31:15 +00:00
|
|
|
return dc
|
|
|
|
}
|
|
|
|
}
|
2012-09-23 03:46:31 +00:00
|
|
|
dc := NewDataCenter(dcName)
|
2012-09-17 00:31:15 +00:00
|
|
|
t.LinkChildNode(dc)
|
|
|
|
return dc
|
|
|
|
}
|