2018-07-28 21:22:46 +00:00
|
|
|
package wdclient
|
|
|
|
|
|
|
|
import (
|
2018-07-28 21:51:36 +00:00
|
|
|
"errors"
|
2018-07-29 04:02:56 +00:00
|
|
|
"fmt"
|
2021-09-13 05:47:52 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/pb"
|
2021-11-12 19:30:11 +00:00
|
|
|
"math/rand"
|
2018-07-28 21:51:36 +00:00
|
|
|
"strconv"
|
2018-07-29 04:02:56 +00:00
|
|
|
"strings"
|
|
|
|
"sync"
|
2019-09-13 12:06:02 +00:00
|
|
|
"sync/atomic"
|
2018-07-29 04:02:56 +00:00
|
|
|
|
2018-07-28 21:51:36 +00:00
|
|
|
"github.com/chrislusf/seaweedfs/weed/glog"
|
2018-07-28 21:22:46 +00:00
|
|
|
)
|
|
|
|
|
2019-09-14 08:21:51 +00:00
|
|
|
const (
|
|
|
|
maxCursorIndex = 4096
|
|
|
|
)
|
|
|
|
|
2021-01-06 12:21:34 +00:00
|
|
|
type HasLookupFileIdFunction interface {
|
|
|
|
GetLookupFileIdFunction() LookupFileIdFunctionType
|
|
|
|
}
|
|
|
|
|
|
|
|
type LookupFileIdFunctionType func(fileId string) (targetUrls []string, err error)
|
|
|
|
|
2018-07-28 21:22:46 +00:00
|
|
|
type Location struct {
|
2020-11-11 10:03:47 +00:00
|
|
|
Url string `json:"url,omitempty"`
|
|
|
|
PublicUrl string `json:"publicUrl,omitempty"`
|
|
|
|
DataCenter string `json:"dataCenter,omitempty"`
|
2021-09-13 05:47:52 +00:00
|
|
|
GrpcPort int `json:"grpcPort,omitempty"`
|
|
|
|
}
|
|
|
|
|
|
|
|
func (l Location) ServerAddress() pb.ServerAddress {
|
|
|
|
return pb.NewServerAddressWithGrpcPort(l.Url, l.GrpcPort)
|
2018-07-28 21:22:46 +00:00
|
|
|
}
|
|
|
|
|
2018-07-29 01:40:31 +00:00
|
|
|
type vidMap struct {
|
2018-07-28 21:22:46 +00:00
|
|
|
sync.RWMutex
|
2022-04-06 02:03:02 +00:00
|
|
|
vid2Locations map[uint32][]Location
|
|
|
|
ecVid2Locations map[uint32][]Location
|
|
|
|
DataCenter string
|
|
|
|
cursor int32
|
2018-07-28 21:22:46 +00:00
|
|
|
}
|
|
|
|
|
2020-11-11 21:13:33 +00:00
|
|
|
func newVidMap(dataCenter string) vidMap {
|
2018-07-29 01:40:31 +00:00
|
|
|
return vidMap{
|
2022-04-06 02:03:02 +00:00
|
|
|
vid2Locations: make(map[uint32][]Location),
|
|
|
|
ecVid2Locations: make(map[uint32][]Location),
|
|
|
|
DataCenter: dataCenter,
|
|
|
|
cursor: -1,
|
2019-09-13 12:06:02 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2019-09-14 08:21:51 +00:00
|
|
|
func (vc *vidMap) getLocationIndex(length int) (int, error) {
|
2019-09-13 12:06:02 +00:00
|
|
|
if length <= 0 {
|
|
|
|
return 0, fmt.Errorf("invalid length: %d", length)
|
2018-07-29 01:40:31 +00:00
|
|
|
}
|
2019-09-14 08:21:51 +00:00
|
|
|
if atomic.LoadInt32(&vc.cursor) == maxCursorIndex {
|
|
|
|
atomic.CompareAndSwapInt32(&vc.cursor, maxCursorIndex, -1)
|
2019-09-13 12:06:02 +00:00
|
|
|
}
|
2019-09-14 08:21:51 +00:00
|
|
|
return int(atomic.AddInt32(&vc.cursor, 1)) % length, nil
|
2018-07-29 01:40:31 +00:00
|
|
|
}
|
|
|
|
|
2020-10-08 05:49:04 +00:00
|
|
|
func (vc *vidMap) LookupVolumeServerUrl(vid string) (serverUrls []string, err error) {
|
2018-07-28 21:51:36 +00:00
|
|
|
id, err := strconv.Atoi(vid)
|
|
|
|
if err != nil {
|
|
|
|
glog.V(1).Infof("Unknown volume id %s", vid)
|
2020-10-08 05:49:04 +00:00
|
|
|
return nil, err
|
2018-07-28 21:51:36 +00:00
|
|
|
}
|
|
|
|
|
2020-10-08 05:49:04 +00:00
|
|
|
locations, found := vc.GetLocations(uint32(id))
|
|
|
|
if !found {
|
|
|
|
return nil, fmt.Errorf("volume %d not found", id)
|
2018-07-28 21:51:36 +00:00
|
|
|
}
|
2021-11-12 19:30:11 +00:00
|
|
|
var sameDcServers, otherDcServers []string
|
2020-10-08 05:49:04 +00:00
|
|
|
for _, loc := range locations {
|
2020-11-11 21:13:33 +00:00
|
|
|
if vc.DataCenter == "" || loc.DataCenter == "" || vc.DataCenter != loc.DataCenter {
|
2021-11-12 19:30:11 +00:00
|
|
|
otherDcServers = append(otherDcServers, loc.Url)
|
2021-11-16 17:14:01 +00:00
|
|
|
} else {
|
|
|
|
sameDcServers = append(sameDcServers, loc.Url)
|
2020-11-11 21:13:33 +00:00
|
|
|
}
|
2018-07-28 21:51:36 +00:00
|
|
|
}
|
2021-11-12 19:30:11 +00:00
|
|
|
rand.Shuffle(len(sameDcServers), func(i, j int) {
|
|
|
|
sameDcServers[i], sameDcServers[j] = sameDcServers[j], sameDcServers[i]
|
|
|
|
})
|
|
|
|
rand.Shuffle(len(otherDcServers), func(i, j int) {
|
|
|
|
otherDcServers[i], otherDcServers[j] = otherDcServers[j], otherDcServers[i]
|
|
|
|
})
|
|
|
|
serverUrls = append(sameDcServers, otherDcServers...)
|
2020-10-08 05:49:04 +00:00
|
|
|
return
|
2018-07-28 21:51:36 +00:00
|
|
|
}
|
|
|
|
|
2021-01-06 12:21:34 +00:00
|
|
|
func (vc *vidMap) GetLookupFileIdFunction() LookupFileIdFunctionType {
|
|
|
|
return vc.LookupFileId
|
|
|
|
}
|
|
|
|
|
2020-10-08 05:49:04 +00:00
|
|
|
func (vc *vidMap) LookupFileId(fileId string) (fullUrls []string, err error) {
|
2018-10-14 07:12:28 +00:00
|
|
|
parts := strings.Split(fileId, ",")
|
|
|
|
if len(parts) != 2 {
|
2020-10-08 05:49:04 +00:00
|
|
|
return nil, errors.New("Invalid fileId " + fileId)
|
2018-10-14 07:12:28 +00:00
|
|
|
}
|
2020-10-08 05:49:04 +00:00
|
|
|
serverUrls, lookupError := vc.LookupVolumeServerUrl(parts[0])
|
2018-10-14 07:12:28 +00:00
|
|
|
if lookupError != nil {
|
2020-10-08 05:49:04 +00:00
|
|
|
return nil, lookupError
|
2018-10-14 07:12:28 +00:00
|
|
|
}
|
2020-10-08 05:49:04 +00:00
|
|
|
for _, serverUrl := range serverUrls {
|
|
|
|
fullUrls = append(fullUrls, "http://"+serverUrl+"/"+fileId)
|
|
|
|
}
|
|
|
|
return
|
2018-10-14 07:12:28 +00:00
|
|
|
}
|
|
|
|
|
2019-07-28 10:58:13 +00:00
|
|
|
func (vc *vidMap) GetVidLocations(vid string) (locations []Location, err error) {
|
2018-11-21 04:56:28 +00:00
|
|
|
id, err := strconv.Atoi(vid)
|
|
|
|
if err != nil {
|
|
|
|
glog.V(1).Infof("Unknown volume id %s", vid)
|
2019-07-28 10:58:13 +00:00
|
|
|
return nil, fmt.Errorf("Unknown volume id %s", vid)
|
2018-11-21 04:56:28 +00:00
|
|
|
}
|
2019-07-28 10:58:13 +00:00
|
|
|
foundLocations, found := vc.GetLocations(uint32(id))
|
|
|
|
if found {
|
|
|
|
return foundLocations, nil
|
|
|
|
}
|
|
|
|
return nil, fmt.Errorf("volume id %s not found", vid)
|
2018-11-21 04:56:28 +00:00
|
|
|
}
|
|
|
|
|
2019-07-28 10:58:13 +00:00
|
|
|
func (vc *vidMap) GetLocations(vid uint32) (locations []Location, found bool) {
|
2018-07-28 21:22:46 +00:00
|
|
|
vc.RLock()
|
|
|
|
defer vc.RUnlock()
|
2020-11-11 23:10:06 +00:00
|
|
|
|
2022-04-06 02:03:02 +00:00
|
|
|
glog.V(4).Infof("~ lookup volume id %d: %+v ec:%+v", vid, vc.vid2Locations, vc.ecVid2Locations)
|
|
|
|
|
2019-07-28 10:58:13 +00:00
|
|
|
locations, found = vc.vid2Locations[vid]
|
2022-04-06 02:03:02 +00:00
|
|
|
if found && len(locations) > 0 {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
locations, found = vc.ecVid2Locations[vid]
|
2022-06-15 11:20:13 +00:00
|
|
|
return locations, found && len(locations) > 0
|
2018-07-28 21:22:46 +00:00
|
|
|
}
|
|
|
|
|
2018-07-29 01:40:31 +00:00
|
|
|
func (vc *vidMap) addLocation(vid uint32, location Location) {
|
2018-07-28 21:22:46 +00:00
|
|
|
vc.Lock()
|
|
|
|
defer vc.Unlock()
|
|
|
|
|
2022-04-06 02:03:02 +00:00
|
|
|
glog.V(4).Infof("+ volume id %d: %+v", vid, location)
|
|
|
|
|
2018-07-28 21:22:46 +00:00
|
|
|
locations, found := vc.vid2Locations[vid]
|
|
|
|
if !found {
|
|
|
|
vc.vid2Locations[vid] = []Location{location}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, loc := range locations {
|
|
|
|
if loc.Url == location.Url {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
vc.vid2Locations[vid] = append(locations, location)
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2022-04-06 02:03:02 +00:00
|
|
|
func (vc *vidMap) addEcLocation(vid uint32, location Location) {
|
|
|
|
vc.Lock()
|
|
|
|
defer vc.Unlock()
|
|
|
|
|
|
|
|
glog.V(4).Infof("+ ec volume id %d: %+v", vid, location)
|
|
|
|
|
|
|
|
locations, found := vc.ecVid2Locations[vid]
|
|
|
|
if !found {
|
|
|
|
vc.ecVid2Locations[vid] = []Location{location}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
for _, loc := range locations {
|
|
|
|
if loc.Url == location.Url {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
vc.ecVid2Locations[vid] = append(locations, location)
|
|
|
|
|
|
|
|
}
|
|
|
|
|
2018-07-29 01:40:31 +00:00
|
|
|
func (vc *vidMap) deleteLocation(vid uint32, location Location) {
|
2018-07-28 21:22:46 +00:00
|
|
|
vc.Lock()
|
|
|
|
defer vc.Unlock()
|
|
|
|
|
2022-04-06 02:03:02 +00:00
|
|
|
glog.V(4).Infof("- volume id %d: %+v", vid, location)
|
|
|
|
|
2018-07-28 21:22:46 +00:00
|
|
|
locations, found := vc.vid2Locations[vid]
|
|
|
|
if !found {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
for i, loc := range locations {
|
|
|
|
if loc.Url == location.Url {
|
|
|
|
vc.vid2Locations[vid] = append(locations[0:i], locations[i+1:]...)
|
2019-04-21 20:33:32 +00:00
|
|
|
break
|
2018-07-28 21:22:46 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|
2022-04-06 02:03:02 +00:00
|
|
|
|
|
|
|
func (vc *vidMap) deleteEcLocation(vid uint32, location Location) {
|
|
|
|
vc.Lock()
|
|
|
|
defer vc.Unlock()
|
|
|
|
|
|
|
|
glog.V(4).Infof("- ec volume id %d: %+v", vid, location)
|
|
|
|
|
|
|
|
locations, found := vc.ecVid2Locations[vid]
|
|
|
|
if !found {
|
|
|
|
return
|
|
|
|
}
|
|
|
|
|
|
|
|
for i, loc := range locations {
|
|
|
|
if loc.Url == location.Url {
|
|
|
|
vc.ecVid2Locations[vid] = append(locations[0:i], locations[i+1:]...)
|
|
|
|
break
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
}
|