add code to randomly select one new volume to grow

weed-fs/bin/.gitignore

@@ -1 +0,0 @@
-/weed

weed-fs/pkg/linux_amd64/.gitignore

@@ -1 +0,0 @@
-/pkg

weed-fs/src/pkg/topology/capacity.go

@@ -0,0 +1,8 @@
+package topology
+
+import ()
+
+type StorageCapacity struct {
+	countVolumeCount int
+	maxVolumeCount   int
+}

weed-fs/src/pkg/topology/data_center.go

@@ -1,10 +1,54 @@
 package topology
 
-import ()
+import (
+	"pkg/storage"
+)
 
 type DataCenterId string
 type DataCenter struct {
 	Id      DataCenterId
 	racks   map[RackId]*Rack
 	ipRange IpRange
+
+	//transient
+	allocation StorageCapacity
+	topology   *Topology
+}
+
+func (d *DataCenter) CreateOneVolume(r int, vid storage.VolumeId) storage.VolumeId {
+	for _, rack := range d.racks {
+		freeSpace := rack.allocation.maxVolumeCount - rack.allocation.countVolumeCount
+		if r > freeSpace {
+			r -= freeSpace
+		} else {
+			rack.CreateOneVolume(r, vid)
+		}
+	}
+	return vid
+}
+func (d *DataCenter) AddVolume(rack *Rack, v *storage.VolumeInfo) {
+	d.allocation.countVolumeCount += 1
+	d.topology.AddVolume(d, v)
+}
+func (d *DataCenter) AddNode(rack *Rack, n *Node) {
+	d.allocation.countVolumeCount += len(n.volumes)
+	d.allocation.maxVolumeCount += n.maxVolumeCount
+	d.topology.AddNode(d, n)
+}
+func (d *DataCenter) RemoveNode(rack *Rack, n *Node) {
+	d.allocation.countVolumeCount -= len(n.volumes)
+	d.allocation.maxVolumeCount -= n.maxVolumeCount
+	d.topology.RemoveNode(d, n)
+}
+func (d *DataCenter) AddRack(rack *Rack) {
+	d.racks[rack.Id] = rack
+	d.allocation.countVolumeCount += rack.allocation.countVolumeCount
+	d.allocation.maxVolumeCount += rack.allocation.maxVolumeCount
+	d.topology.AddRack(d, rack)
+}
+func (d *DataCenter) RemoveRack(rack *Rack) {
+	delete(d.racks, rack.Id)
+	d.allocation.countVolumeCount -= rack.allocation.countVolumeCount
+	d.allocation.maxVolumeCount -= rack.allocation.maxVolumeCount
+	d.topology.AddRack(d, rack)
 }

weed-fs/src/pkg/topology/node.go

@@ -4,26 +4,22 @@ import (
   "pkg/storage"
 )
 
-type NodeId uint32
+type NodeId string
 type Node struct {
-	volumes     map[storage.VolumeId]storage.VolumeInfo
+	volumes     map[storage.VolumeId]*storage.VolumeInfo
-	volumeLimit int
+	maxVolumeCount int
-	Ip          string
+	Ip          NodeId
 	Port        int
 	PublicUrl   string
 	
 	//transient
-	allocation *Allocation
+	rack *Rack
 }
-type Allocation struct {
+func (n *Node) CreateOneVolume(r int, vid storage.VolumeId) storage.VolumeId {
-  count int
+  n.AddVolume(&storage.VolumeInfo{Id:vid, Size: 32*1024*1024*1024})
-  limit int
+  return vid
 }
-
+func (n *Node) AddVolume(v *storage.VolumeInfo){
-func (n *Node) GetAllocation() *Allocation{
+  n.volumes[v.Id] = v
-  if n.allocation == nil {
+  n.rack.AddVolume(n,v)
-    n.allocation = &Allocation{count:len(n.volumes), limit : n.volumeLimit}
-  }
-  return n.allocation
 }
-

weed-fs/src/pkg/topology/rack.go

@@ -1,10 +1,43 @@
 package topology
 
-import ()
+import (
+  "pkg/storage"
+)
 
 type RackId uint32
 type Rack struct {
 	Id      RackId
 	nodes   map[NodeId]*Node
 	ipRange IpRange
+	
+  //transient
+  allocation StorageCapacity
+  dataCenter *DataCenter
+}
+func (rack *Rack) CreateOneVolume(r int, vid storage.VolumeId) storage.VolumeId {
+  for _, node := range rack.nodes {
+    freeSpace := node.maxVolumeCount - len(node.volumes)
+    if r > freeSpace {
+      r -= freeSpace
+    } else {
+      node.CreateOneVolume(r, vid)
+    }
+  }
+  return vid
+}
+func (r *Rack) AddVolume(n *Node, v *storage.VolumeInfo){
+  r.allocation.countVolumeCount += 1
+  r.dataCenter.AddVolume(r,v)
+}
+func (r *Rack) AddNode(n *Node){
+  r.nodes[n.Ip] = n
+  r.allocation.countVolumeCount += len(n.volumes)
+  r.allocation.maxVolumeCount += n.maxVolumeCount
+  r.dataCenter.AddNode(r,n)
+}
+func (r *Rack) RemoveNode(n *Node){
+  delete(r.nodes,n.Ip)
+  r.allocation.countVolumeCount -= len(n.volumes)
+  r.allocation.maxVolumeCount -= n.maxVolumeCount
+  r.dataCenter.RemoveNode(r,n)
 }

weed-fs/src/pkg/topology/topology.go

@@ -1,16 +1,61 @@
 package topology
 
 import (
-  "pkg/storage"
+	"math/rand"
+	"pkg/storage"
 )
 
 type Topology struct {
-  datacenters     map[DataCenterId]*DataCenter
+	datacenters map[DataCenterId]*DataCenter
+
+	//transient
+	allocation StorageCapacity
 }
+
 //FIXME
-func (t *Topology) RandomlyCreateOneVolume() storage.VolumeId{
+func (t *Topology) RandomlyCreateOneVolume() storage.VolumeId {
-  return t.findMaxVolumeId()
+	r := rand.Intn(t.allocation.maxVolumeCount-t.allocation.countVolumeCount)
+  vid := t.nextVolumeId()
+	for _, d := range t.datacenters {
+	  freeSpace := d.allocation.maxVolumeCount-d.allocation.countVolumeCount
+	  if r>freeSpace{
+	    r -= freeSpace
+	  }else{
+	    d.CreateOneVolume(r, vid)
+	    return vid
+	  }
+	}
+	return storage.VolumeId(0) //FIXME
 }
-func (t *Topology) findMaxVolumeId() storage.VolumeId{
+func (t *Topology) nextVolumeId() storage.VolumeId {
-  return storage.VolumeId(0);
+	return storage.VolumeId(0)
+}
+func (t *Topology) AddVolume(d *DataCenter, v *storage.VolumeInfo) {
+	t.allocation.countVolumeCount += 1
+}
+func (t *Topology) AddNode(d *DataCenter, n *Node){
+  t.allocation.countVolumeCount += len(n.volumes)
+  t.allocation.maxVolumeCount += n.maxVolumeCount
+}
+func (t *Topology) RemoveNode(d *DataCenter, n *Node){
+  t.allocation.countVolumeCount -= len(n.volumes)
+  t.allocation.maxVolumeCount -= n.maxVolumeCount
+}
+func (t *Topology) AddRack(d *DataCenter, rack *Rack){
+  t.allocation.countVolumeCount += rack.allocation.countVolumeCount
+  t.allocation.maxVolumeCount += rack.allocation.maxVolumeCount
+}
+func (t *Topology) RemoveRack(d *DataCenter, rack *Rack){
+  t.allocation.countVolumeCount -= rack.allocation.countVolumeCount
+  t.allocation.maxVolumeCount -= rack.allocation.maxVolumeCount
+}
+func (t *Topology) AddDataCenter(d *DataCenter) {
+  t.datacenters[d.Id] = d
+	t.allocation.countVolumeCount += d.allocation.countVolumeCount
+	t.allocation.maxVolumeCount += d.allocation.maxVolumeCount
+}
+func (t *Topology) RemoveDataCenter(d *DataCenter) {
+  delete(t.datacenters,d.Id)
+  t.allocation.countVolumeCount -= d.allocation.countVolumeCount
+  t.allocation.maxVolumeCount -= d.allocation.maxVolumeCount
 }