// Elect chooses a seed node, and returns a connection to a cal.
// If this process is the seed, returns nil.
func elect(name, id, laddr string, b *doozer.Conn) *doozer.Conn {
// advertise our presence, since we might become a cal
nspath := "/ctl/ns/" + name + "/" + id
r, err := b.Set(nspath, 0, []byte(laddr))
if err != nil {
panic(err)
}
// fight to be the seed
_, err = b.Set("/ctl/boot/"+name, 0, []byte(id))
if err, ok := err.(*doozer.Error); ok && err.Err == doozer.ErrOldRev {
// we lost, lookup addresses again
cl := lookupAndAttach(b, name)
if cl == nil {
panic("failed to attach after losing election")
}
// also delete our entry, since we're not officially a cal yet.
// it gets set again in peer.Main when we become a cal.
err := b.Del(nspath, r)
if err != nil {
panic(err)
}
return cl
} else if err != nil {
panic(err)
}
return nil // we are the seed node -- don't attach
}
func activate(st *store.Store, self string, c *doozer.Conn) int64 {
rev, _ := st.Snap()
for _, base := range store.Getdir(st, calDir) {
p := calDir + "/" + base
v, rev := st.Get(p)
if rev != store.Dir && v[0] == "" {
seqn, err := c.Set(p, rev, []byte(self))
if err != nil {
log.Println(err)
continue
}
return seqn
}
}
for {
ch, err := st.Wait(calGlob, rev+1)
if err != nil {
panic(err)
}
ev, ok := <-ch
if !ok {
panic(io.EOF)
}
rev = ev.Rev
// TODO ev.IsEmpty()
if ev.IsSet() && ev.Body == "" {
seqn, err := c.Set(ev.Path, ev.Rev, []byte(self))
if err != nil {
log.Println(err)
continue
}
return seqn
} else if ev.IsSet() && ev.Body == self {
return ev.Seqn
}
}
return 0
}
func writer(
conn *doozer.Conn,
root string,
entryc chan *journal.Entry,
errc chan error,
) {
for entry := range entryc {
if strings.HasPrefix(entry.Path, root) &&
!strings.HasPrefix(entry.Path, journal.InternalPrefix) {
var err error
switch entry.Op {
case journal.OpSet:
_, e := conn.Set(entry.Path, -1, entry.Value)
if e != nil {
err = fmt.Errorf("unable setting '%s' to '%s'", entry.Path, string(entry.Value))
}
case journal.OpDel:
e := conn.Del(entry.Path, -1)
if e != nil {
err = fmt.Errorf("unable deleting '%s'", entry.Path)
}
default:
err = fmt.Errorf("unknown operation %s", entry.Op)
}
if err != nil {
errc <- err
return
}
b, err := journal.Marshal(entry)
if err != nil {
continue
}
fmt.Println(string(b))
}
}
}
func setC(cl *doozer.Conn, path, body string, rev int64) {
_, err := cl.Set(path, rev, []byte(body))
if err != nil {
panic(err)
}
}