func applyCompaction(kv mvcc.KV, req *etcdserverpb.CompactionRequest) (*etcdserverpb.CompactionResponse, error) { resp := &etcdserverpb.CompactionResponse{} resp.Header = &etcdserverpb.ResponseHeader{} _, err := kv.Compact(req.Revision) if err != nil { return nil, err } // get the current revision. which key to get is not important. _, resp.Header.Revision, _ = kv.Range([]byte("compaction"), nil, 1, 0) return resp, err }
// applyCompare applies the compare request. // It returns the revision at which the comparison happens. If the comparison // succeeds, the it returns true. Otherwise it returns false. func applyCompare(kv mvcc.KV, c *etcdserverpb.Compare) (int64, bool) { ckvs, rev, err := kv.Range(c.Key, nil, 1, 0) if err != nil { if err == mvcc.ErrTxnIDMismatch { panic("unexpected txn ID mismatch error") } return rev, false } var ckv mvccpb.KeyValue if len(ckvs) != 0 { ckv = ckvs[0] } else { // Use the zero value of ckv normally. However... if c.Target == etcdserverpb.Compare_VALUE { // Always fail if we're comparing a value on a key that doesn't exist. // We can treat non-existence as the empty set explicitly, such that // even a key with a value of length 0 bytes is still a real key // that was written that way return rev, false } } // -1 is less, 0 is equal, 1 is greater var result int switch c.Target { case etcdserverpb.Compare_VALUE: tv, _ := c.TargetUnion.(*etcdserverpb.Compare_Value) if tv != nil { result = bytes.Compare(ckv.Value, tv.Value) } case etcdserverpb.Compare_CREATE: tv, _ := c.TargetUnion.(*etcdserverpb.Compare_CreateRevision) if tv != nil { result = compareInt64(ckv.CreateRevision, tv.CreateRevision) } case etcdserverpb.Compare_MOD: tv, _ := c.TargetUnion.(*etcdserverpb.Compare_ModRevision) if tv != nil { result = compareInt64(ckv.ModRevision, tv.ModRevision) } case etcdserverpb.Compare_VERSION: tv, _ := c.TargetUnion.(*etcdserverpb.Compare_Version) if tv != nil { result = compareInt64(ckv.Version, tv.Version) } } switch c.Result { case etcdserverpb.Compare_EQUAL: if result != 0 { return rev, false } case etcdserverpb.Compare_GREATER: if result != 1 { return rev, false } case etcdserverpb.Compare_LESS: if result != -1 { return rev, false } } return rev, true }
func applyRange(txnID int64, kv mvcc.KV, r *etcdserverpb.RangeRequest) (*etcdserverpb.RangeResponse, error) { resp := &etcdserverpb.RangeResponse{} resp.Header = &etcdserverpb.ResponseHeader{} var ( kvs []mvccpb.KeyValue rev int64 err error ) if isGteRange(r.RangeEnd) { r.RangeEnd = []byte{} } limit := r.Limit if r.SortOrder != etcdserverpb.RangeRequest_NONE { // fetch everything; sort and truncate afterwards limit = 0 } if limit > 0 { // fetch one extra for 'more' flag limit = limit + 1 } if txnID != noTxn { kvs, rev, err = kv.TxnRange(txnID, r.Key, r.RangeEnd, limit, r.Revision) if err != nil { return nil, err } } else { kvs, rev, err = kv.Range(r.Key, r.RangeEnd, limit, r.Revision) if err != nil { return nil, err } } if r.SortOrder != etcdserverpb.RangeRequest_NONE { var sorter sort.Interface switch { case r.SortTarget == etcdserverpb.RangeRequest_KEY: sorter = &kvSortByKey{&kvSort{kvs}} case r.SortTarget == etcdserverpb.RangeRequest_VERSION: sorter = &kvSortByVersion{&kvSort{kvs}} case r.SortTarget == etcdserverpb.RangeRequest_CREATE: sorter = &kvSortByCreate{&kvSort{kvs}} case r.SortTarget == etcdserverpb.RangeRequest_MOD: sorter = &kvSortByMod{&kvSort{kvs}} case r.SortTarget == etcdserverpb.RangeRequest_VALUE: sorter = &kvSortByValue{&kvSort{kvs}} } switch { case r.SortOrder == etcdserverpb.RangeRequest_ASCEND: sort.Sort(sorter) case r.SortOrder == etcdserverpb.RangeRequest_DESCEND: sort.Sort(sort.Reverse(sorter)) } } if r.Limit > 0 && len(kvs) > int(r.Limit) { kvs = kvs[:r.Limit] resp.More = true } resp.Header.Revision = rev for i := range kvs { resp.Kvs = append(resp.Kvs, &kvs[i]) } return resp, nil }