func (rs *ReplValueStore) SetRing(r ring.Ring) {
if r == nil {
return
}
rs.ringLock.Lock()
if rs.ringCachePath != "" {
dir, name := path.Split(rs.ringCachePath)
_ = os.MkdirAll(dir, 0755)
fp, err := ioutil.TempFile(dir, name)
if err != nil {
rs.logDebug("replValueStore: error caching ring %q: %s", rs.ringCachePath, err)
} else if err := r.Persist(fp); err != nil {
fp.Close()
os.Remove(fp.Name())
rs.logDebug("replValueStore: error caching ring %q: %s", rs.ringCachePath, err)
} else {
fp.Close()
if err := os.Rename(fp.Name(), rs.ringCachePath); err != nil {
os.Remove(fp.Name())
rs.logDebug("replValueStore: error caching ring %q: %s", rs.ringCachePath, err)
}
}
}
rs.ring = r
var currentAddrs map[string]struct{}
if r != nil {
nodes := r.Nodes()
currentAddrs = make(map[string]struct{}, len(nodes))
for _, n := range nodes {
currentAddrs[n.Address(rs.addressIndex)] = struct{}{}
}
}
var shutdownAddrs []string
rs.storesLock.RLock()
for a := range rs.stores {
if _, ok := currentAddrs[a]; !ok {
shutdownAddrs = append(shutdownAddrs, a)
}
}
rs.storesLock.RUnlock()
if len(shutdownAddrs) > 0 {
shutdownStores := make([]*replValueStoreAndTicketChan, len(shutdownAddrs))
rs.storesLock.Lock()
for i, a := range shutdownAddrs {
shutdownStores[i] = rs.stores[a]
rs.stores[a] = nil
}
rs.storesLock.Unlock()
for i, s := range shutdownStores {
if err := s.store.Shutdown(context.Background()); err != nil {
rs.logDebug("replValueStore: error during shutdown of store %s: %s", shutdownAddrs[i], err)
}
}
}
rs.ringLock.Unlock()
}
func bootstrapManagedNodes(ring ring.Ring, ccport int, ctxlog *log.Entry, gopts ...grpc.DialOption) map[uint64]ManagedNode {
nodes := ring.Nodes()
m := make(map[uint64]ManagedNode, len(nodes))
for _, node := range nodes {
addr, err := ParseManagedNodeAddress(node.Address(0), ccport)
if err != nil {
ctxlog.WithFields(log.Fields{
"node": node.ID(),
"address": node.Address(0),
}).Info("Can't split address in node (skipped node)")
continue
}
m[node.ID()], err = NewManagedNode(&ManagedNodeOpts{Address: addr, GrpcOpts: gopts})
if err != nil {
ctxlog.WithFields(log.Fields{
"node": node.ID(),
"address": node.Address(0),
"err": err,
}).Warning("Unable to bootstrap node")
} else {
ctxlog.WithFields(log.Fields{
"node": node.ID(),
"address": node.Address(0),
}).Debug("Added node")
}
}
return m
}
func nodeCmd(r ring.Ring, b *ring.Builder, args []string, full bool) (changed bool, err error) {
var nodes ring.NodeSlice
if r != nil {
nodes = r.Nodes()
} else {
bnodes := b.Nodes()
nodes = make(ring.NodeSlice, len(bnodes))
for i := len(nodes) - 1; i >= 0; i-- {
nodes[i] = bnodes[i]
}
}
filterArgs := make([]string, 0)
setArgs := make([]string, 0)
setFound := false
for _, arg := range args {
if arg == "set" {
setFound = true
continue
}
if setFound {
setArgs = append(setArgs, arg)
} else {
filterArgs = append(filterArgs, arg)
}
}
if len(setArgs) > 0 && b == nil {
err = fmt.Errorf("set is only valid for builder files")
return
}
if nodes, err = nodes.Filter(filterArgs); err != nil {
return
}
if len(nodes) > 0 && len(setArgs) > 0 {
for _, n := range nodes {
if err = addOrSetCmd(r, b, setArgs, n.(ring.BuilderNode)); err != nil {
return
}
changed = true
}
}
if full || len(nodes) == 1 {
first := true
for _, n := range nodes {
if first {
first = false
} else {
fmt.Println()
}
report := [][]string{
[]string{"ID:", fmt.Sprintf("%016x", n.ID())},
[]string{"Active:", fmt.Sprintf("%v", n.Active())},
[]string{"Capacity:", fmt.Sprintf("%d", n.Capacity())},
[]string{"Tiers:", strings.Join(n.Tiers(), "\n")},
[]string{"Addresses:", strings.Join(n.Addresses(), "\n")},
[]string{"Meta:", n.Meta()},
}
fmt.Print(brimtext.Align(report, nil))
}
return
}
header := []string{
"ID",
"Active",
"Capacity",
"Address",
"Meta",
}
report := [][]string{header}
reportAlign := brimtext.NewDefaultAlignOptions()
reportAlign.Alignments = []brimtext.Alignment{
brimtext.Left,
brimtext.Right,
brimtext.Right,
brimtext.Right,
brimtext.Left,
}
reportLine := func(n ring.Node) []string {
return []string{
fmt.Sprintf("%016x", n.ID()),
fmt.Sprintf("%v", n.Active()),
fmt.Sprintf("%d", n.Capacity()),
n.Address(0),
n.Meta(),
}
}
for _, n := range nodes {
if n.Active() {
report = append(report, reportLine(n))
}
}
for _, n := range nodes {
if !n.Active() {
report = append(report, reportLine(n))
}
}
fmt.Print(brimtext.Align(report, reportAlign))
return
}
