replication related work on data nodes

weed-fs/src/cmd/weed/volume.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+  "encoding/json"
 	"log"
 	"math/rand"
 	"mime"
@@ -38,9 +39,23 @@ var (
 func statusHandler(w http.ResponseWriter, r *http.Request) {
 	writeJson(w, r, store.Status())
 }
-func addVolumeHandler(w http.ResponseWriter, r *http.Request) {
-	store.AddVolume(r.FormValue("volume"))
-	writeJson(w, r, store.Status())
+func assignVolumeHandler(w http.ResponseWriter, r *http.Request) {
+	err := store.AddVolume(r.FormValue("volume"), r.FormValue("replicationType"))
+	if err == nil {
+		writeJson(w, r, map[string]string{"error": ""})
+	} else {
+		writeJson(w, r, map[string]string{"error": err.Error()})
+	}
+}
+func setVolumeLocationsHandler(w http.ResponseWriter, r *http.Request) {
+  volumeLocationsList := new([]storage.VolumeLocations)
+  json.Unmarshal([]byte(r.FormValue("volumeLocations")), volumeLocationsList)
+	err := store.SetVolumeLocations(*volumeLocationsList)
+  if err == nil {
+    writeJson(w, r, map[string]string{"error": ""})
+  } else {
+    writeJson(w, r, map[string]string{"error": err.Error()})
+  }
 }
 func storeHandler(w http.ResponseWriter, r *http.Request) {
 	switch r.Method {
@@ -157,7 +172,8 @@ func runVolume(cmd *Command, args []string) bool {
 	defer store.Close()
 	http.HandleFunc("/", storeHandler)
 	http.HandleFunc("/status", statusHandler)
-	http.HandleFunc("/add_volume", addVolumeHandler)
+	http.HandleFunc("/admin/assign_volume", assignVolumeHandler)
+	http.HandleFunc("/admin/set_volume_locations", setVolumeLocationsHandler)
 
 	go func() {
 		for {

weed-fs/src/pkg/storage/store.go

@@ -5,9 +5,9 @@ import (
 	"errors"
 	"log"
 	"net/url"
+	"pkg/util"
 	"strconv"
 	"strings"
-	"pkg/util"
 )
 
 type Store struct {
@@ -22,12 +22,12 @@ func NewStore(port int, publicUrl, dirname string, volumeListString string) (s *
 	s = &Store{Port: port, PublicUrl: publicUrl, dir: dirname}
 	s.volumes = make(map[VolumeId]*Volume)
 
-	s.AddVolume(volumeListString)
+	s.AddVolume(volumeListString, "00")
 
 	log.Println("Store started on dir:", dirname, "with", len(s.volumes), "volumes")
 	return
 }
-func (s *Store) AddVolume(volumeListString string) error {
+func (s *Store) AddVolume(volumeListString string, replicationType string) error {
 	for _, range_string := range strings.Split(volumeListString, ",") {
 		if strings.Index(range_string, "-") < 0 {
 			id_string := range_string
@@ -35,7 +35,7 @@ func (s *Store) AddVolume(volumeListString string) error {
 			if err != nil {
 				return errors.New("Volume Id " + id_string + " is not a valid unsigned integer!")
 			}
-			s.addVolume(VolumeId(id))
+			s.addVolume(VolumeId(id), NewReplicationType(replicationType))
 		} else {
 			pair := strings.Split(range_string, "-")
 			start, start_err := strconv.ParseUint(pair[0], 10, 64)
@@ -47,24 +47,24 @@ func (s *Store) AddVolume(volumeListString string) error {
 				return errors.New("Volume End Id" + pair[1] + " is not a valid unsigned integer!")
 			}
 			for id := start; id <= end; id++ {
-				s.addVolume(VolumeId(id))
+				s.addVolume(VolumeId(id), NewReplicationType(replicationType))
 			}
 		}
 	}
 	return nil
 }
-func (s *Store) addVolume(vid VolumeId) error {
+func (s *Store) addVolume(vid VolumeId, replicationType ReplicationType) error {
 	if s.volumes[vid] != nil {
 		return errors.New("Volume Id " + vid.String() + " already exists!")
 	}
-	s.volumes[vid] = NewVolume(s.dir, vid)
+	s.volumes[vid] = NewVolume(s.dir, vid, replicationType)
 	return nil
 }
 func (s *Store) Status() *[]*VolumeInfo {
 	stats := new([]*VolumeInfo)
 	for k, v := range s.volumes {
 		s := new(VolumeInfo)
-		s.Id, s.Size = VolumeId(k), v.Size()
+		s.Id, s.Size, s.RepType = VolumeId(k), v.Size(), v.replicaType
 		*stats = append(*stats, s)
 	}
 	return stats
@@ -73,7 +73,7 @@ func (s *Store) Join(mserver string) {
 	stats := new([]*VolumeInfo)
 	for k, v := range s.volumes {
 		s := new(VolumeInfo)
-		s.Id, s.Size = VolumeId(k), v.Size()
+		s.Id, s.Size, s.RepType = VolumeId(k), v.Size(), v.replicaType
 		*stats = append(*stats, s)
 	}
 	bytes, _ := json.Marshal(stats)
@@ -89,23 +89,39 @@ func (s *Store) Close() {
 	}
 }
 func (s *Store) Write(i VolumeId, n *Needle) uint32 {
-  v := s.volumes[i]
-  if v!=nil{
-    return v.write(n)
-  }
-  return 0
+	v := s.volumes[i]
+	if v != nil {
+		return v.write(n)
+	}
+	return 0
 }
 func (s *Store) Delete(i VolumeId, n *Needle) uint32 {
-  v := s.volumes[i]
-  if v!=nil{
-    return v.delete(n)
-  }
-  return 0
+	v := s.volumes[i]
+	if v != nil {
+		return v.delete(n)
+	}
+	return 0
 }
 func (s *Store) Read(i VolumeId, n *Needle) (int, error) {
-  v := s.volumes[i]
-  if v!=nil{
-    return v.read(n)
-  }
-  return 0, errors.New("Not Found")
+	v := s.volumes[i]
+	if v != nil {
+		return v.read(n)
+	}
+	return 0, errors.New("Not Found")
+}
+
+type VolumeLocations struct {
+	Vid       VolumeId
+	Locations []string
+}
+
+func (s *Store) SetVolumeLocations(volumeLocationList []VolumeLocations) error {
+	for _, volumeLocations := range volumeLocationList {
+		vid := volumeLocations.Vid
+		v := s.volumes[vid]
+		if v != nil {
+			v.locations = volumeLocations.Locations
+		}
+	}
+	return nil
 }

weed-fs/src/pkg/storage/volume.go

@@ -18,12 +18,17 @@ type Volume struct {
 	dataFile *os.File
 	nm       *NeedleMap
 
+  replicaType ReplicationType
+
 	accessLock sync.Mutex
+	
+	//transient
+	locations []string
 }
 
-func NewVolume(dirname string, id VolumeId) (v *Volume) {
+func NewVolume(dirname string, id VolumeId, replicationType ReplicationType) (v *Volume) {
 	var e error
-	v = &Volume{dir: dirname, Id: id}
+	v = &Volume{dir: dirname, Id: id, replicaType:replicationType}
 	fileName := id.String()
 	v.dataFile, e = os.OpenFile(path.Join(v.dir, fileName+".dat"), os.O_RDWR|os.O_CREATE, 0644)
 	if e != nil {
@@ -53,7 +58,7 @@ func (v *Volume) maybeWriteSuperBlock() {
 	stat, _ := v.dataFile.Stat()
 	if stat.Size() == 0 {
 		header := make([]byte, SuperBlockSize)
-		header[0] = 1 //number of copies
+		header[0] = byte(v.replicaType)
 		v.dataFile.Write(header)
 	}
 }

weed-fs/src/pkg/storage/volume_info.go

@@ -3,48 +3,64 @@ package storage
 import ()
 
 type VolumeInfo struct {
-	Id              VolumeId
-	Size            int64
-	ReplicationType ReplicationType
+	Id      VolumeId
+	Size    int64
+	RepType ReplicationType
 }
-type ReplicationType int
+type ReplicationType byte
 
 const (
-  Copy00 = ReplicationType(00) // single copy
-  Copy01 = ReplicationType(01) // 2 copies, each on different racks, same data center
-  Copy10 = ReplicationType(10) // 2 copies, each on different data center
-  Copy11 = ReplicationType(11) // 3 copies, 2 on different racks and local data center, 1 on different data center
-  Copy20 = ReplicationType(20) // 3 copies, each on dffereint data center
-  LengthRelicationType = 5
+	Copy00               = ReplicationType(00) // single copy
+	Copy01               = ReplicationType(01) // 2 copies, each on different racks, same data center
+	Copy10               = ReplicationType(10) // 2 copies, each on different data center
+	Copy11               = ReplicationType(11) // 3 copies, 2 on different racks and local data center, 1 on different data center
+	Copy20               = ReplicationType(20) // 3 copies, each on dffereint data center
+	LengthRelicationType = 5
 )
 
-func GetReplicationLevelIndex(v *VolumeInfo) int {
-  switch v.ReplicationType {
-  case Copy00:
-    return 0
-  case Copy01:
-    return 1
-  case Copy10:
-    return 2
-  case Copy11:
-    return 3
-  case Copy20:
-    return 4
+func NewReplicationType(t string) ReplicationType {
+  switch t {
+  case "00":
+    return Copy00
+  case "01":
+    return Copy01
+  case "10":
+    return Copy10
+  case "11":
+    return Copy11
+  case "20":
+    return Copy20
   }
-  return -1
+  return Copy00
+}
+
+func GetReplicationLevelIndex(v *VolumeInfo) int {
+	switch v.RepType {
+	case Copy00:
+		return 0
+	case Copy01:
+		return 1
+	case Copy10:
+		return 2
+	case Copy11:
+		return 3
+	case Copy20:
+		return 4
+	}
+	return -1
 }
 func GetCopyCount(v *VolumeInfo) int {
-  switch v.ReplicationType {
-  case Copy00:
-    return 1
-  case Copy01:
-    return 2
-  case Copy10:
-    return 2
-  case Copy11:
-    return 3
-  case Copy20:
-    return 3
-  }
-  return 0
+	switch v.RepType {
+	case Copy00:
+		return 1
+	case Copy01:
+		return 2
+	case Copy10:
+		return 2
+	case Copy11:
+		return 3
+	case Copy20:
+		return 3
+	}
+	return 0
 }

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

@@ -1,7 +1,7 @@
 package topology
 
 import (
-  "errors"
+	"errors"
 	"fmt"
 	"math/rand"
 	"pkg/storage"
@@ -29,20 +29,22 @@ func (vl *VolumeLayout) RegisterVolume(v *storage.VolumeInfo, dn *DataNode) {
 	}
 	vl.vid2location[v.Id].Add(dn)
 	if len(vl.vid2location[v.Id].list) >= storage.GetCopyCount(v) {
-	  vl.writables = append(vl.writables,v.Id)
+		if uint64(v.Size) < vl.volumeSizeLimit {
+			vl.writables = append(vl.writables, v.Id)
+		}
 	}
 }
 
 func (vl *VolumeLayout) PickForWrite(count int) (int, *DataNodeLocationList, error) {
-  len_writers := len(vl.writables)
-  if len_writers <= 0 {
-    fmt.Println("No more writable volumes!")
-    return 0, nil, errors.New("No more writable volumes!")
-  }
-  vid := vl.writables[rand.Intn(len_writers)]
-  locationList := vl.vid2location[vid]
-  if locationList != nil {
-    return count, locationList, nil
-  }
-  return 0, nil, errors.New("Strangely vid " + vid.String() + " is on no machine!")
+	len_writers := len(vl.writables)
+	if len_writers <= 0 {
+		fmt.Println("No more writable volumes!")
+		return 0, nil, errors.New("No more writable volumes!")
+	}
+	vid := vl.writables[rand.Intn(len_writers)]
+	locationList := vl.vid2location[vid]
+	if locationList != nil {
+		return count, locationList, nil
+	}
+	return 0, nil, errors.New("Strangely vid " + vid.String() + " is on no machine!")
 }

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

@@ -1,21 +1,39 @@
 package topology
 
-import (
-)
+import ()
 
 type DataNodeLocationList struct {
-  list []*DataNode
+	list []*DataNode
 }
 
 func NewDataNodeLocationList() *DataNodeLocationList {
-  return &DataNodeLocationList{}
+	return &DataNodeLocationList{}
 }
 
-func (dnll *DataNodeLocationList) Add(loc *DataNode){
-  for _, dnl := range dnll.list {
-    if loc.ip == dnl.ip && loc.port == dnl.port {
-      break
-    }
-  }
-  dnll.list = append(dnll.list, loc)
+func (dnll *DataNodeLocationList) Add(loc *DataNode) {
+	for _, dnl := range dnll.list {
+		if loc.ip == dnl.ip && loc.port == dnl.port {
+			break
+		}
+	}
+	dnll.list = append(dnll.list, loc)
+}
+
+func (dnll *DataNodeLocationList) Refresh(freshThreshHold int64) {
+	var changed bool
+	for _, dnl := range dnll.list {
+		if dnl.lastSeen < freshThreshHold {
+			changed = true
+			break
+		}
+	}
+	if changed {
+		var l []*DataNode
+		for _, dnl := range dnll.list {
+			if dnl.lastSeen >= freshThreshHold {
+				l = append(l, dnl)
+			}
+		}
+		dnll.list = l
+	}
 }