示例#1
0
文件: boot.go 项目: zyxar/doozerd
// 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
}
示例#2
0
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
}
示例#3
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))
		}
	}
}
示例#4
0
func setC(cl *doozer.Conn, path, body string, rev int64) {
	_, err := cl.Set(path, rev, []byte(body))
	if err != nil {
		panic(err)
	}
}