func localRangeKeyPrint(key roachpb.Key) string { var buf bytes.Buffer for _, s := range rangeSuffixDict { if s.atEnd { if bytes.HasSuffix(key, s.suffix) { key = key[:len(key)-len(s.suffix)] fmt.Fprintf(&buf, "%s/%s", decodeKeyPrint(key), s.name) return buf.String() } } else { begin := bytes.Index(key, s.suffix) if begin > 0 { addrKey := key[:begin] txnID, err := uuid.FromBytes(key[(begin + len(s.suffix)):]) if err != nil { return fmt.Sprintf("/%q/err:%v", key, err) } fmt.Fprintf(&buf, "%s/%s/addrKey:/id:%q", decodeKeyPrint(addrKey), s.name, txnID) return buf.String() } } } fmt.Fprintf(&buf, "%s", decodeKeyPrint(key)) return buf.String() }
func abortCacheKeyPrint(key roachpb.Key) string { _, id, err := encoding.DecodeBytesAscending([]byte(key), nil) if err != nil { return fmt.Sprintf("/%q/err:%v", key, err) } txnID, err := uuid.FromBytes(id) if err != nil { return fmt.Sprintf("/%q/err:%v", key, err) } return fmt.Sprintf("/%q", txnID) }
// DecodeAbortCacheKey decodes the provided abort cache entry, // returning the transaction ID. func DecodeAbortCacheKey(key roachpb.Key, dest []byte) (*uuid.UUID, error) { _, _, suffix, detail, err := DecodeRangeIDKey(key) if err != nil { return nil, err } if !bytes.Equal(suffix, LocalAbortCacheSuffix) { return nil, errors.Errorf("key %s does not contain the abort cache suffix %s", key, LocalAbortCacheSuffix) } // Decode the id. detail, idBytes, err := encoding.DecodeBytesAscending(detail, dest) if err != nil { return nil, err } if len(detail) > 0 { return nil, errors.Errorf("key %q has leftover bytes after decode: %s; indicates corrupt key", key, detail) } txnID, err := uuid.FromBytes(idBytes) return txnID, err }
func TestTransactionString(t *testing.T) { txnID, err := uuid.FromBytes([]byte("ת\x0f^\xe4-Fؽ\xf7\x16\xe4\xf9\xbe^\xbe")) if err != nil { t.Fatal(err) } ts1 := hlc.Timestamp{WallTime: 10, Logical: 11} txn := roachpb.Transaction{ TxnMeta: enginepb.TxnMeta{ Isolation: enginepb.SERIALIZABLE, Key: roachpb.Key("foo"), ID: &txnID, Epoch: 2, Timestamp: hlc.Timestamp{WallTime: 20, Logical: 21}, Priority: 957356782, }, Name: "name", Status: roachpb.COMMITTED, LastHeartbeat: &ts1, OrigTimestamp: hlc.Timestamp{WallTime: 30, Logical: 31}, MaxTimestamp: hlc.Timestamp{WallTime: 40, Logical: 41}, } expStr := `"name" id=d7aa0f5e key="foo" rw=false pri=44.58039917 iso=SERIALIZABLE stat=COMMITTED ` + `epo=2 ts=0.000000020,21 orig=0.000000030,31 max=0.000000040,41 wto=false rop=false` if str := txn.String(); str != expStr { t.Errorf("expected txn %s; got %s", expStr, str) } var txnEmpty roachpb.Transaction _ = txnEmpty.String() // prevent regression of NPE cmd := storagebase.RaftCommand{ BatchRequest: &roachpb.BatchRequest{}, } cmd.BatchRequest.Txn = &txn if actStr, idStr := fmt.Sprintf("%s", &cmd), txnID.String(); !strings.Contains(actStr, idStr) { t.Fatalf("expected to find '%s' in '%s'", idStr, actStr) } }
// connectGossip connects to gossip network and reads cluster ID. If // this node is already part of a cluster, the cluster ID is verified // for a match. If not part of a cluster, the cluster ID is set. The // node's address is gossiped with node ID as the gossip key. func (n *Node) connectGossip(ctx context.Context) { log.Infof(ctx, "connecting to gossip network to verify cluster ID...") // No timeout or stop condition is needed here. Log statements should be // sufficient for diagnosing this type of condition. <-n.storeCfg.Gossip.Connected uuidBytes, err := n.storeCfg.Gossip.GetInfo(gossip.KeyClusterID) if err != nil { log.Fatalf(ctx, "unable to ascertain cluster ID from gossip network: %s", err) } gossipClusterID, err := uuid.FromBytes(uuidBytes) if err != nil { log.Fatalf(ctx, "unable to ascertain cluster ID from gossip network: %s", err) } if n.ClusterID == (uuid.UUID{}) { n.ClusterID = gossipClusterID } else if n.ClusterID != gossipClusterID { log.Fatalf(ctx, "node %d belongs to cluster %q but is attempting to connect to a gossip network for cluster %q", n.Descriptor.NodeID, n.ClusterID, gossipClusterID) } log.Infof(ctx, "node connected via gossip and verified as part of cluster %q", gossipClusterID) }
uv, err := uuid.FromString(s) if err != nil { return nil, err } return NewDBytes(DBytes(uv.GetBytes())), nil }, }, }, "from_uuid": { Builtin{ Types: ArgTypes{TypeBytes}, ReturnType: TypeString, fn: func(_ *EvalContext, args DTuple) (Datum, error) { b := []byte(*args[0].(*DBytes)) uv, err := uuid.FromBytes(b) if err != nil { return nil, err } return NewDString(uv.String()), nil }, }, }, "from_ip": { Builtin{ Types: ArgTypes{TypeBytes}, ReturnType: TypeString, fn: func(_ *EvalContext, args DTuple) (Datum, error) { ipstr := args[0].(*DBytes) nboip := net.IP(*ipstr)