func (p *Peer) Accept(conn net.Conn) (_err error) { defer conn.Close() p.logFields(SERVE, log.Fields{ "remoteAddr": conn.RemoteAddr(), }).Debug("accepted connection") defer func() { if _err != nil { p.logErr(SERVE, _err).Error() } }() var failResp string if p.readAcquire() { defer p.wg.Done() } else { failResp = "sync not available, currently mutating" } remoteConfig, err := p.handleConfig(conn, SERVE, failResp) if err != nil { return errgo.Mask(err) } if failResp == "" { return p.interactWithClient(conn, remoteConfig, cf.NewBitstring(0)) } return nil }
func (t *prefixTree) newChildNode(parent *prefixNode, childIndex int) *prefixNode { n := &prefixNode{prefixTree: t, Leaf: true} var key *cf.Bitstring if parent != nil { parentKey := parent.Key() key = cf.NewBitstring(parentKey.BitLen() + t.BitQuantum) key.SetBytes(parentKey.Bytes()) for j := 0; j < parent.BitQuantum; j++ { if (1<<uint(j))&childIndex == 0 { key.Clear(parentKey.BitLen() + j) } else { key.Set(parentKey.BitLen() + j) } } } else { key = cf.NewBitstring(0) } n.NodeKey = mustEncodeBitstring(key) svalues := make([]*cf.Zp, t.NumSamples()) for i := 0; i < len(svalues); i++ { svalues[i] = cf.Zi(cf.P_SKS, 1) } n.NodeSValues = mustEncodeZZarray(svalues) return n }
func (n *prefixNode) Children() ([]recon.PrefixNode, error) { if n.IsLeaf() { return nil, nil } key := n.Key() numChildren := 1 << uint(n.BitQuantum) var result []recon.PrefixNode for i := 0; i < numChildren; i++ { childKey := cf.NewBitstring(key.BitLen() + n.BitQuantum) childKey.SetBytes(key.Bytes()) for j := 0; j < n.BitQuantum; j++ { if (1<<uint(j))&i == 0 { childKey.Clear(key.BitLen() + j) } else { childKey.Set(key.BitLen() + j) } } child, err := n.Node(childKey) if err != nil { return nil, fmt.Errorf("children failed on child#%v, key=%v: %v", i, childKey, err) } result = append(result, child) } return result, nil }
func (n *prefixNode) Parent() (recon.PrefixNode, bool, error) { key := n.Key() if key.BitLen() == 0 { return nil, false, nil } parentKey := cf.NewBitstring(key.BitLen() - n.BitQuantum) parentKey.SetBytes(key.Bytes()) parent, err := n.Node(parentKey) if err != nil { return nil, false, fmt.Errorf("failed to get parent: %v", err) } return parent, true, nil }
func (t *prefixTree) Node(bs *cf.Bitstring) (node recon.PrefixNode, err error) { nbq := t.BitQuantum key := bs nodeKey := mustEncodeBitstring(key) for { node, err = t.getNode(nodeKey) if err != recon.ErrNodeNotFound || key.BitLen() == 0 { break } key = cf.NewBitstring(key.BitLen() - nbq) key.SetBytes(bs.Bytes()) nodeKey = mustEncodeBitstring(key) } return node, err }
func (n *MemPrefixNode) Key() *cf.Bitstring { var keys []int for cur := n; cur != nil && cur.parent != nil; cur = cur.parent { keys = append([]int{cur.key}, keys...) } bs := cf.NewBitstring(len(keys) * n.BitQuantum) for i := len(keys) - 1; i >= 0; i-- { for j := 0; j < n.BitQuantum; j++ { if ((keys[i] >> uint(j)) & 0x01) == 1 { bs.Set(i*n.BitQuantum + j) } else { bs.Clear(i*n.BitQuantum + j) } } } return bs }
func ReadBitstring(r io.Reader) (*cf.Bitstring, error) { nbits, err := ReadLen(r) if err != nil { return nil, err } bs := cf.NewBitstring(nbits) nbytes, err := ReadLen(r) if err != nil { return nil, err } if nbits == 0 { return bs, nil } buf := make([]byte, nbytes) _, err = io.ReadFull(r, buf) bs.SetBytes(buf) return bs, err }
func (t *prefixTree) Root() (recon.PrefixNode, error) { return t.Node(cf.NewBitstring(0)) }