func (s *CmdCtrlClient) ringUpdateNodeCmd(filename string) error {
ctx, _ := context.WithTimeout(context.Background(), 60*time.Second)
r, _, err := ring.RingOrBuilder(filename)
if err != nil {
return err
}
if r == nil {
return fmt.Errorf("Provided builder file rather than ring file")
}
ru := &cc.Ring{}
ru.Version = r.Version()
ru.Ring, err = ioutil.ReadFile(filename)
if err != nil {
return err
}
status, err := s.client.RingUpdate(ctx, ru)
if err != nil {
return err
}
if status.Newversion != ru.Version {
return fmt.Errorf("Ring update seems to have failed. Expected: %d, but remote host reports: %d\n", ru.Version, status.Newversion)
}
fmt.Println("Remote version is now", status.Newversion)
return nil
}
func (o *Server) ObtainConfig() (err error) {
e := NewEnvGetter(fmt.Sprintf("OORT_%s", strings.ToUpper(o.serviceName)), "_")
envSkipSRV := e.Get("SKIP_SRV")
// Check whether we're supposed to skip loading via srv method
if strings.ToLower(envSkipSRV) != "true" {
s := &srvconf.SRVLoader{
SyndicateURL: e.Get("SYNDICATE_OVERRIDE"),
}
s.Record, err = GenServiceID(o.serviceName, "syndicate", "tcp")
if err != nil {
if e.Get("SYNDICATE_OVERRIDE") == "" {
log.Println(err)
} else {
log.Fatalln("No SYNDICATE_OVERRIDE provided and", err)
}
}
if e.Get("SYNDICATE_OVERRIDE") != "" {
log.Println("Over wrote syndicate url with url from env!", e.Get("SYNDICATE_OVERRIDE"))
}
nc, err := s.Load()
if err != nil {
return err
}
o.ring, err = ring.LoadRing(bytes.NewReader(nc.Ring))
if err != nil {
return fmt.Errorf("Error while loading ring for config get via srv lookup: %s", err)
}
err = ring.PersistRingOrBuilder(o.ring, nil, fmt.Sprintf("%s/ring/%d-%s.ring", o.cwd, o.ring.Version(), o.serviceName))
if err != nil {
return err
}
o.localID = nc.Localid
o.ring.SetLocalNode(o.localID)
o.ringFile = fmt.Sprintf("%s/ring/%d-%s.ring", o.cwd, o.ring.Version(), o.serviceName)
err = o.loadCmdCtrlConfig()
if err != nil {
return err
}
} else {
// if you skip the srv load you have to provide all of the info in env vars!
log.Println("Skipped SRV Config attempting to load from env")
s, err := strconv.ParseUint(e.Get("LOCALID"), 10, 64)
if err != nil {
return fmt.Errorf("Unable to load env specified local id")
}
o.localID = s
o.ringFile = e.Get("RING_FILE")
o.ring, _, err = ring.RingOrBuilder(o.ringFile)
if err != nil {
return fmt.Errorf("Unable to road env specified ring: %s", err)
}
o.ring.SetLocalNode(o.localID)
err = o.loadCmdCtrlConfig()
if err != nil {
return err
}
}
return nil
}
func (s *ringslave) Store(c context.Context, r *pb.RingMsg) (*pb.StoreResult, error) {
log.Println("Got store request:", r.Version, r.Deadline, r.Rollback)
s.Lock()
defer s.Unlock()
s.last = time.Now()
bs, rs, err := s.saveRingAndBuilderBytes(&r.Ring, &r.Builder, r.Version)
if err != nil {
return &pb.StoreResult{
Version: r.Version,
Ring: rs,
Builder: bs,
ErrMsg: fmt.Sprintf("Encountered error during save: %s", err),
}, nil
}
s.version = r.Version
_, builder, err := ring.RingOrBuilder(path.Join(s.spath, fmt.Sprintf("%d.oort.builder", r.Version)))
if err != nil || builder == nil {
return &pb.StoreResult{
Version: r.Version,
Ring: false,
Builder: false,
ErrMsg: fmt.Sprintf("Encountered error during builder load: %s", err),
}, nil
}
oldbuilder := s.b
s.b = builder
ring, _, err := ring.RingOrBuilder(path.Join(s.spath, fmt.Sprintf("%d.oort.ring.gz", r.Version)))
if err != nil || ring == nil || ring.Version() != r.Version {
//restore builder
s.b = oldbuilder
return &pb.StoreResult{
Version: r.Version,
Ring: false,
Builder: false,
ErrMsg: fmt.Sprintf("Encountered error during ring load: %s", err),
}, nil
}
s.r = ring
s.version = r.Version
return &pb.StoreResult{Version: r.Version, Ring: true, Builder: true, ErrMsg: ""}, nil
}
//getRing loads a ring from disk
func (s *Server) getRing(path string) (ring.Ring, error) {
r, _, err := ring.RingOrBuilder(path)
return r, err
}
//getBuilder loads a builder from disk
func (s *Server) getBuilder(path string) (*ring.Builder, error) {
_, b, err := ring.RingOrBuilder(path)
return b, err
}
//NewServer returns a new instance of an up and running syndicate mangement node
func NewServer(cfg *Config, servicename string, opts ...MockOpt) (*Server, error) {
var err error
s := new(Server)
s.cfg = cfg
s.servicename = servicename
log.SetFormatter(&log.TextFormatter{})
if s.cfg.Debug {
log.SetLevel(log.DebugLevel)
}
s.ctxlog = log.WithField("service", s.servicename)
s.metrics = metricsInit(s.servicename)
s.parseConfig()
for _, opt := range opts {
opt(s)
}
if s.rbPersistFn == nil {
s.rbPersistFn = s.ringBuilderPersisterFn
}
if s.rbLoaderFn == nil {
s.rbLoaderFn = func(path string) ([]byte, error) {
return ioutil.ReadFile(path)
}
}
if s.getBuilderFn == nil {
s.getBuilderFn = s.getBuilder
}
bfile, rfile, err := getRingPaths(cfg, s.servicename)
if err != nil {
panic(err)
}
_, s.b, err = ring.RingOrBuilder(bfile)
FatalIf(err, fmt.Sprintf("Builder file (%s) load failed:", bfile))
s.r, _, err = ring.RingOrBuilder(rfile)
FatalIf(err, fmt.Sprintf("Ring file (%s) load failed:", rfile))
//TODO: verify ring version in bytes matches what we expect
s.rb, s.bb, err = s.loadRingBuilderBytes(s.r.Version())
FatalIf(err, "Attempting to load ring/builder bytes")
for _, v := range cfg.NetFilter {
_, n, err := net.ParseCIDR(v)
if err != nil {
FatalIf(err, "Invalid network range provided")
}
s.netlimits = append(s.netlimits, n)
}
s.tierlimits = cfg.TierFilter
s.managedNodes = bootstrapManagedNodes(s.r, s.cfg.CmdCtrlPort, s.ctxlog)
s.metrics.managedNodes.Set(float64(len(s.managedNodes)))
s.changeChan = make(chan *changeMsg, 1)
s.subsChangeChan = make(chan *changeMsg, 1)
go s.RingChangeManager()
s.ringSubs = &RingSubscribers{
subs: make(map[string]chan *pb.Ring),
}
go s.ringSubscribersNotify()
s.slaves = parseSlaveAddrs(cfg.Slaves)
if len(s.slaves) == 0 {
s.ctxlog.Debug("running without slaves")
return s, nil
}
failcount := 0
for _, slave := range s.slaves {
if err = s.RegisterSlave(slave); err != nil {
s.ctxlog.WithFields(
log.Fields{
"slave": slave.addr,
"status": slave.status,
"err": err,
}).Warning("Error registering slave")
failcount++
}
}
if failcount > (len(s.slaves) / 2) {
return s, fmt.Errorf("More than half of the ring slaves failed to respond. Exiting.")
}
return s, nil
}