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)