MB-23906: Implement delete-with-value with store() instead of delete()
[ep-engine.git] / src / kv_bucket_iface.h
1 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2 /*
3  *     Copyright 2016 Couchbase, Inc
4  *
5  *   Licensed under the Apache License, Version 2.0 (the "License");
6  *   you may not use this file except in compliance with the License.
7  *   You may obtain a copy of the License at
8  *
9  *       http://www.apache.org/licenses/LICENSE-2.0
10  *
11  *   Unless required by applicable law or agreed to in writing, software
12  *   distributed under the License is distributed on an "AS IS" BASIS,
13  *   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
14  *   See the License for the specific language governing permissions and
15  *   limitations under the License.
16  */
17
18 #pragma once
19
20 #include "config.h"
21
22 #include "task_type.h"
23 #include "vbucket.h"
24
25 /* Forward declarations */
26 class ExtendedMetaData;
27 class BGFetchCallback;
28 class ConflictResolution;
29 class DefragmenterTask;
30 class Flusher;
31 class HashTable;
32 class ItemMetaData;
33 class KVBucket;
34 class MutationLog;
35 class PauseResumeEPStoreVisitor;
36 class PersistenceCallback;
37 class Producer;
38 class VBucketMap;
39 class Warmup;
40
41 /**
42  * vbucket-aware hashtable visitor.
43  */
44 class VBucketVisitor {
45 public:
46     VBucketVisitor() = default;
47
48     VBucketVisitor(const VBucketFilter &filter)
49         : vBucketFilter(filter) { }
50
51     virtual ~VBucketVisitor() = default;
52
53     /**
54      * Begin visiting a bucket.
55      *
56      * @param vb the vbucket we are beginning to visit
57      */
58     virtual void visitBucket(VBucketPtr &vb) = 0;
59
60     const VBucketFilter &getVBucketFilter() {
61         return vBucketFilter;
62     }
63
64     /**
65      * Called after all vbuckets have been visited.
66      */
67     virtual void complete() { }
68
69     /**
70      * Return true if visiting vbuckets should be paused temporarily.
71      */
72     virtual bool pauseVisitor() {
73         return false;
74     }
75
76 protected:
77     VBucketFilter vBucketFilter;
78 };
79
80 /**
81  * Base class for visiting an epStore with pause/resume support.
82  */
83 class PauseResumeEPStoreVisitor {
84 public:
85     virtual ~PauseResumeEPStoreVisitor() {}
86
87     /**
88      * Visit a hashtable within an epStore.
89      *
90      * @param vbucket_id ID of the vbucket being visited.
91      * @param ht a reference to the hashtable.
92      * @return True if visiting should continue, otherwise false.
93      */
94     virtual bool visit(uint16_t vbucket_id, HashTable& ht) = 0;
95 };
96
97 /**
98  * This is the abstract base class that manages the bucket behavior in
99  * ep-engine.
100  * Different bucket types can be derived from this class.
101  */
102
103 class KVBucketIface {
104 public:
105
106     /**
107      * Represents a position within the epStore, used when visiting items.
108      *
109      * Currently opaque (and constant), clients can pass them around but
110      * cannot reposition the iterator.
111      */
112     class Position {
113     public:
114         bool operator==(const Position& other) const {
115             return (vbucket_id == other.vbucket_id);
116         }
117
118     private:
119         Position(uint16_t vbucket_id_) : vbucket_id(vbucket_id_) {}
120
121         uint16_t vbucket_id;
122
123         friend class KVBucket;
124         friend std::ostream& operator<<(std::ostream& os, const Position& pos);
125     };
126
127     KVBucketIface() {}
128     virtual ~KVBucketIface() {}
129
130     /**
131      * Start necessary tasks.
132      * Client calling initialize must also call deinitialize before deleting
133      * the EPBucket instance
134      */
135     virtual bool initialize() = 0;
136
137     /**
138      * Stop tasks started in initialize()
139      */
140     virtual void deinitialize() = 0;
141
142     /**
143      * Set an item in the store.
144      * @param item the item to set
145      * @param cookie the cookie representing the client to store the item
146      * @return the result of the store operation
147      */
148     virtual ENGINE_ERROR_CODE set(Item &item, const void *cookie) = 0;
149
150     /**
151      * Add an item in the store.
152      * @param item the item to add
153      * @param cookie the cookie representing the client to store the item
154      * @return the result of the operation
155      */
156     virtual ENGINE_ERROR_CODE add(Item &item, const void *cookie) = 0;
157
158     /**
159      * Replace an item in the store.
160      * @param item the item to replace
161      * @param cookie the cookie representing the client to store the item
162      * @return the result of the operation
163      */
164     virtual ENGINE_ERROR_CODE replace(Item &item, const void *cookie) = 0;
165
166     /**
167      * Add an TAP backfill or DCP backfill item into its corresponding vbucket
168      * @param item the item to be added
169      * @param genBySeqno whether or not to generate sequence number
170      * @return the result of the operation
171      */
172     virtual ENGINE_ERROR_CODE addBackfillItem(Item& item,
173                                               GenerateBySeqno genBySeqno,
174                                               ExtendedMetaData* emd = NULL) = 0;
175
176     /**
177      * Retrieve a value.
178      *
179      * @param key     the key to fetch
180      * @param vbucket the vbucket from which to retrieve the key
181      * @param cookie  the connection cookie
182      * @param options options specified for retrieval
183      *
184      * @return a GetValue representing the result of the request
185      */
186     virtual GetValue get(const DocKey& key, uint16_t vbucket,
187                          const void *cookie, get_options_t options) = 0;
188
189     virtual GetValue getRandomKey(void) = 0;
190
191     /**
192      * Retrieve a value from a vbucket in replica state.
193      *
194      * @param key     the key to fetch
195      * @param vbucket the vbucket from which to retrieve the key
196      * @param cookie  the connection cookie
197      * @param options options specified for retrieval
198      *
199      * @return a GetValue representing the result of the request
200      */
201     virtual GetValue getReplica(const DocKey& key, uint16_t vbucket,
202                                 const void *cookie,
203                                 get_options_t options = static_cast<get_options_t>(
204                                                                                    QUEUE_BG_FETCH |
205                                                                                    HONOR_STATES |
206                                                                                    TRACK_REFERENCE |
207                                                                                    DELETE_TEMP |
208                                                                                    HIDE_LOCKED_CAS)) = 0;
209
210
211     /**
212      * Retrieve the meta data for an item
213      *
214      * @param key the key to get the meta data for
215      * @param vbucket the vbucket from which to retrieve the key
216      * @param cookie the connection cookie
217      * @param fetchDatatype whether to fetch datatype or not
218      * @param[out] metadata where to store the meta informaion
219      * @param[out] deleted specifies whether or not the key is deleted
220      * @param[out] datatype specifies the datatype of the item
221      */
222     virtual ENGINE_ERROR_CODE getMetaData(const DocKey& key,
223                                           uint16_t vbucket,
224                                           const void* cookie,
225                                           bool fetchDatatype,
226                                           ItemMetaData& metadata,
227                                           uint32_t& deleted,
228                                           uint8_t& datatype) = 0;
229
230     /**
231      * Set an item in the store.
232      * @param item the item to set
233      * @param cas value to match
234      * @param seqno sequence number of mutation
235      * @param cookie the cookie representing the client to store the item
236      * @param force override vbucket states
237      * @param allowExisting set to false if you want set to fail if the
238      *                      item exists already
239      * @param genBySeqno whether or not to generate sequence number
240      * @param emd ExtendedMetaData class object that contains any ext meta
241      * @param isReplication set to true if we are to use replication
242      *                      throttle threshold
243      *
244      * @return the result of the store operation
245      */
246     virtual ENGINE_ERROR_CODE setWithMeta(Item &item,
247                                           uint64_t cas,
248                                           uint64_t *seqno,
249                                           const void *cookie,
250                                           bool force,
251                                           bool allowExisting,
252                                           GenerateBySeqno genBySeqno = GenerateBySeqno::Yes,
253                                           GenerateCas genCas = GenerateCas::No,
254                                           ExtendedMetaData *emd = NULL,
255                                           bool isReplication = false) = 0;
256
257     /**
258      * Retrieve a value, but update its TTL first
259      *
260      * @param key the key to fetch
261      * @param vbucket the vbucket from which to retrieve the key
262      * @param cookie the connection cookie
263      * @param exptime the new expiry time for the object
264      *
265      * @return a GetValue representing the result of the request
266      */
267     virtual GetValue getAndUpdateTtl(const DocKey& key, uint16_t vbucket,
268                                      const void *cookie, time_t exptime) = 0;
269
270     /**
271      * Retrieve an item from the disk for vkey stats
272      *
273      * @param key the key to fetch
274      * @param vbucket the vbucket from which to retrieve the key
275      * @param cookie the connection cookie
276      * @param cb callback to return an item fetched from the disk
277      *
278      * @return a status resulting form executing the method
279      */
280     virtual ENGINE_ERROR_CODE statsVKey(const DocKey& key,
281                                         uint16_t vbucket,
282                                         const void *cookie) = 0;
283
284     virtual void completeStatsVKey(const void* cookie, const DocKey& key,
285                                    uint16_t vbid, uint64_t bySeqNum) = 0;
286
287     virtual protocol_binary_response_status evictKey(const DocKey& key,
288                                                      VBucket::id_type vbucket,
289                                                      const char** msg) = 0;
290
291     /**
292      * delete an item in the store
293      *
294      * @param key the key of the item
295      * @param[in, out] cas the CAS ID for a CASed delete (0 to override)
296      * @param vbucket the vbucket for the key
297      * @param cookie the cookie representing the client
298      * @param[out] itemMeta the pointer to the metadata memory.
299      * @param[out] mutInfo mutation information
300      *
301      * @return the result of the operation
302      */
303     virtual ENGINE_ERROR_CODE deleteItem(const DocKey& key,
304                                          uint64_t& cas,
305                                          uint16_t vbucket,
306                                          const void* cookie,
307                                          ItemMetaData* itemMeta,
308                                          mutation_descr_t* mutInfo) = 0;
309
310     /**
311      * Delete an item in the store from a non-front end operation (DCP, XDCR)
312      *
313      * @param key the key of the item
314      * @param[in, out] cas the CAS ID for a CASed delete (0 to override)
315      * @param[out] seqno Pointer to get the seqno generated for the item. A
316      *                   NULL value is passed if not needed
317      * @param vbucket the vbucket for the key
318      * @param cookie the cookie representing the client
319      * @param force override access to the vbucket even if the state of the
320      *              vbucket would deny mutations.
321      * @param itm item holding a deleted value. A NULL value is passed
322      *            if an empty body is to be used for deletion.
323      * @param itemMeta the metadata to use for this deletion.
324      * @param genBySeqno whether or not to generate sequence number
325      * @param generateCas whether or not to generate cas
326      * @param bySeqno seqno of the key being deleted
327      * @param emd ExtendedMetaData class object that contains any ext meta
328      * @param isReplication set to true if we are to use replication
329      *                      throttle threshold
330      *
331      * @return the result of the delete operation
332      */
333     virtual ENGINE_ERROR_CODE deleteWithMeta(const DocKey& key,
334                                              uint64_t& cas,
335                                              uint64_t* seqno,
336                                              uint16_t vbucket,
337                                              const void* cookie,
338                                              bool force,
339                                              const ItemMetaData& itemMeta,
340                                              bool backfill,
341                                              GenerateBySeqno genBySeqno,
342                                              GenerateCas generateCas,
343                                              uint64_t bySeqno,
344                                              ExtendedMetaData* emd,
345                                              bool isReplication) = 0;
346
347     /**
348      * Resets the Bucket. Removes all elements from each VBucket's &
349      * CheckpointManager.
350      * Specific subclasses (e.g. EPBucket) may have additional work to do
351      * (update disk etc).
352      */
353     virtual void reset() = 0;
354
355     /**
356      * Set the background fetch delay.
357      *
358      * This exists for debugging and testing purposes.  It
359      * artificially injects delays into background fetches that are
360      * performed when the user requests an item whose value is not
361      * currently resident.
362      *
363      * @param to how long to delay before performing a bg fetch
364      */
365     virtual void setBGFetchDelay(uint32_t to) = 0;
366
367     virtual double getBGFetchDelay(void) = 0;
368
369     /**
370      * Pause the bucket's Flusher.
371      * @return true if successful.
372      */
373     virtual bool pauseFlusher() = 0;
374
375     /**
376      * Resume the Flusher for all shards.
377      * @return true if successful.
378      */
379     virtual bool resumeFlusher() = 0;
380
381     /// Wake up the flusher for all shards, if the disk queue is non-empty.
382     virtual void wakeUpFlusher() = 0;
383
384     /**
385      * Takes a snapshot of the current stats and persists them to disk.
386      */
387     virtual void snapshotStats(void) = 0;
388
389     /**
390      * Get summarized vBucket stats for this bucket - total for all
391      * active,replica buckets.
392      */
393     virtual void getAggregatedVBucketStats(const void* cookie,
394                                            ADD_STAT add_stat) = 0;
395
396     /**
397      * Get file statistics
398      *
399      * @param cookie Cookie associated with ADD_STAT
400      * @param add_stat Callback to use to add stats to the caller.
401      * @return ENGINE_SUCCESS if stats were successfully retrieved, or
402      *         ENGINE_KEY_ENOENT if file stats are not available
403      *         from the store.
404      */
405     virtual ENGINE_ERROR_CODE getFileStats(const void* cookie,
406                                            ADD_STAT add_stat) = 0;
407
408     /**
409      * Get detailed (per-vbucket) disk stats.
410      *
411      * @param cookie Cookie associated with ADD_STAT
412      * @param add_stat Callback to use to add stats to the caller.
413      * @return ENGINE_SUCCESS if stats were successfully retrieved, or
414      *         ENGINE_KEY_ENOENT if per-vbucket disk stats are not available
415      *         from the store.
416      */
417     virtual ENGINE_ERROR_CODE getPerVBucketDiskStats(const void* cookie,
418                                                      ADD_STAT add_stat) = 0;
419
420     /**
421      * Complete a background fetch of a non resident value or metadata.
422      *
423      * @param key the key that was fetched
424      * @param vbucket the vbucket in which the key lived
425      * @param cookie the cookie of the requestor
426      * @param init the timestamp of when the request came in
427      * @param isMeta whether the fetch is for a non-resident value or metadata of
428      *               a (possibly) deleted item
429      */
430     virtual void completeBGFetch(const DocKey& key,
431                                  uint16_t vbucket,
432                                  const void* cookie,
433                                  ProcessClock::time_point init,
434                                  bool isMeta) = 0;
435     /**
436      * Complete a batch of background fetch of a non resident value or metadata.
437      *
438      * @param vbId the vbucket in which the requested key lived
439      * @param fetchedItems vector of completed background feches containing key,
440      *                     value, client cookies
441      * @param start the time when the background fetch was started
442      *
443      */
444     virtual void completeBGFetchMulti(
445             uint16_t vbId,
446             std::vector<bgfetched_item_t>& fetchedItems,
447             ProcessClock::time_point start) = 0;
448
449     virtual VBucketPtr getVBucket(uint16_t vbid) = 0;
450
451     /**
452      * Returns the last persisted checkpoint Id for the specified vBucket.
453      * @param vb VBucket ID to get checkpoint Id for.
454      * @return A pair of {checkpointId, true} if the persisted checkpointID is
455      *         available (Persistent bucket), or false if bucket is not
456      *         persistent.
457      */
458     virtual std::pair<uint64_t, bool> getLastPersistedCheckpointId(
459             uint16_t vb) = 0;
460
461     virtual uint64_t getLastPersistedSeqno(uint16_t vb) = 0;
462
463     /* transfer should be set to true *only* if this vbucket is becoming master
464      * as the result of the previous master cleanly handing off control. */
465     virtual ENGINE_ERROR_CODE setVBucketState(uint16_t vbid,
466                                               vbucket_state_t state,
467                                               bool transfer,
468                                               bool notify_dcp = true) = 0;
469
470     /**
471      * Physically deletes a VBucket from disk. This function should only
472      * be called on a VBucket that has already been logically deleted.
473      *
474      * @param vbid vbucket id
475      * @param cookie The connection that requested the deletion
476      */
477     virtual bool completeVBucketDeletion(uint16_t vbid, const void* cookie) = 0;
478
479     /**
480      * Deletes a vbucket
481      *
482      * @param vbid The vbucket to delete.
483      * @param c The cookie for this connection.
484      *          Used in synchronous bucket deletes
485      *          to notify the connection of operation completion.
486      */
487     virtual ENGINE_ERROR_CODE deleteVBucket(uint16_t vbid,
488                                             const void* c = NULL) = 0;
489
490     /**
491      * Check for the existence of a vbucket in the case of couchstore
492      * or shard in the case of forestdb. Note that this function will be
493      * deprecated once forestdb is the only backend supported
494      *
495      * @param db_file_id vbucketid for couchstore or shard id in the
496      *                   case of forestdb
497      */
498     virtual ENGINE_ERROR_CODE checkForDBExistence(uint16_t db_file_id) = 0;
499
500     /**
501      * Triggers compaction of a database file
502      *
503      * @param vbid The vbucket being compacted
504      * @param c The context for compaction of a DB file
505      * @param ck cookie used to notify connection of operation completion
506      */
507     virtual ENGINE_ERROR_CODE scheduleCompaction(uint16_t vbid,
508                                                  compaction_ctx c,
509                                                  const void *ck) = 0;
510
511     /**
512      * Compaction of a database file
513      *
514      * @param ctx Context for compaction hooks
515      * @param ck cookie used to notify connection of operation completion
516      *
517      * return true if the compaction needs to be rescheduled and false
518      *             otherwise
519      */
520     virtual bool doCompact(compaction_ctx *ctx, const void *ck) = 0;
521
522     /**
523      * Get the database file id for the compaction request
524      *
525      * @param req compaction request structure
526      *
527      * returns the database file id from the underlying KV store
528      */
529     virtual uint16_t getDBFileId(
530                             const protocol_binary_request_compact_db& req) = 0;
531
532     /**
533      * Remove completed compaction tasks or wake snoozed tasks
534      *
535      * @param db_file_id vbucket id for couchstore or shard id in the
536      *                   case of forestdb
537      */
538     virtual void updateCompactionTasks(uint16_t db_file_id) = 0;
539
540     /**
541      * Reset a given vbucket from memory and disk. This differs from vbucket
542      * deletion in that it does not delete the vbucket instance from memory hash
543      * table.
544      */
545     virtual bool resetVBucket(uint16_t vbid) = 0;
546
547     /**
548      * Run a vBucket visitor, visiting all items. Synchronous.
549      */
550     virtual void visit(VBucketVisitor &visitor) = 0;
551
552     /**
553      * Run a vbucket visitor with separate jobs per vbucket.
554      *
555      * Note that this is asynchronous.
556      */
557     virtual size_t visit(std::unique_ptr<VBucketVisitor> visitor,
558                          const char* lbl,
559                          TaskId id,
560                          double sleepTime = 0) = 0;
561
562     /**
563      * Visit the items in this epStore, starting the iteration from the
564      * given startPosition and allowing the visit to be paused at any point.
565      *
566      * During visitation, the visitor object can request that the visit
567      * is stopped after the current item. The position passed to the
568      * visitor can then be used to restart visiting at the *APPROXIMATE*
569      * same position as it paused.
570      * This is approximate as various locks are released when the
571      * function returns, so any changes to the underlying epStore may cause
572      * the visiting to restart at the slightly different place.
573      *
574      * As a consequence, *DO NOT USE THIS METHOD* if you need to guarantee
575      * that all items are visited!
576      *
577      * @param visitor The visitor object.
578      * @return The final epStore position visited; equal to
579      *         EPBucket::end() if all items were visited
580      *         otherwise the position to resume from.
581      */
582     virtual Position pauseResumeVisit(PauseResumeEPStoreVisitor& visitor,
583                                       Position& start_pos) = 0;
584
585
586     /**
587      * Return a position at the start of the epStore.
588      */
589     virtual Position startPosition() const = 0;
590
591     /**
592      * Return a position at the end of the epStore. Has similar semantics
593      * as STL end() (i.e. one past the last element).
594      */
595     virtual Position endPosition() const = 0;
596
597     virtual const Flusher* getFlusher(uint16_t shardId) = 0;
598
599     virtual Warmup* getWarmup(void) const = 0;
600
601     /**
602      * Looks up the key stats for the given {vbucket, key}.
603      * @param key The key to lookup
604      * @param vbucket The vbucket the key belongs to.
605      * @param cookie The client's cookie
606      * @param[out] kstats On success the keystats for this item.
607      * @param wantsDeleted If yes then return keystats even if the item is
608      *                     marked as deleted. If no then will return
609      *                     ENGINE_KEY_ENOENT for deleted items.
610      */
611     virtual ENGINE_ERROR_CODE getKeyStats(const DocKey& key,
612                                           uint16_t vbucket,
613                                           const void* cookie,
614                                           key_stats& kstats,
615                                           WantsDeleted wantsDeleted) = 0;
616
617     virtual std::string validateKey(const DocKey& key, uint16_t vbucket,
618                                     Item &diskItem) = 0;
619
620     virtual GetValue getLocked(const DocKey& key, uint16_t vbucket,
621                                rel_time_t currentTime, uint32_t lockTimeout,
622                                const void *cookie) = 0;
623
624     virtual ENGINE_ERROR_CODE unlockKey(const DocKey& key,
625                                         uint16_t vbucket,
626                                         uint64_t cas,
627                                         rel_time_t currentTime) = 0;
628
629
630     virtual KVStore* getRWUnderlying(uint16_t vbId) = 0;
631
632     virtual KVStore* getRWUnderlyingByShard(size_t shardId) = 0;
633
634     virtual KVStore* getROUnderlyingByShard(size_t shardId) = 0;
635
636     virtual KVStore* getROUnderlying(uint16_t vbId) = 0;
637
638     virtual void deleteExpiredItem(
639             uint16_t, const DocKey&, time_t, uint64_t, ExpireBy) = 0;
640     virtual void deleteExpiredItems(
641             std::list<std::pair<uint16_t, StoredDocKey>>&, ExpireBy) = 0;
642
643     /**
644      * Get the memoized storage properties from the DB.kv
645      */
646     virtual const StorageProperties getStorageProperties() const = 0;
647
648     /**
649      * schedule a vb_state snapshot task for a given shard.
650      */
651     virtual void scheduleVBStatePersist() = 0;
652
653     /**
654      * Schedule a vbstate persistence task for a given vbucket.
655      */
656     virtual void scheduleVBStatePersist(uint16_t vbid) = 0;
657
658     virtual const VBucketMap &getVBuckets() = 0;
659
660     virtual EventuallyPersistentEngine& getEPEngine() = 0;
661
662     virtual size_t getExpiryPagerSleeptime(void) = 0;
663
664     virtual size_t getTransactionTimePerItem() = 0;
665
666     virtual bool isDeleteAllScheduled() = 0;
667
668     virtual bool scheduleDeleteAllTask(const void* cookie) = 0;
669
670     virtual void setDeleteAllComplete() = 0;
671
672     virtual void setBackfillMemoryThreshold(double threshold) = 0;
673
674     virtual void setExpiryPagerSleeptime(size_t val) = 0;
675
676     virtual void setExpiryPagerTasktime(ssize_t val) = 0;
677
678     virtual void enableExpiryPager() = 0;
679     virtual void disableExpiryPager() = 0;
680
681     virtual void enableAccessScannerTask() = 0;
682     virtual void disableAccessScannerTask() = 0;
683     virtual void setAccessScannerSleeptime(size_t val, bool useStartTime) = 0;
684     virtual void resetAccessScannerStartTime() = 0;
685
686     virtual void resetAccessScannerTasktime() = 0;
687
688     virtual void setAllBloomFilters(bool to) = 0;
689
690     virtual float getBfiltersResidencyThreshold() = 0;
691
692     virtual void setBfiltersResidencyThreshold(float to) = 0;
693
694     virtual bool isMetaDataResident(VBucketPtr &vb,
695                                     const DocKey& key) = 0;
696
697     virtual void logQTime(TaskId taskType,
698                           const ProcessClock::duration enqTime) = 0;
699
700     virtual void logRunTime(TaskId taskType,
701                             const ProcessClock::duration runTime) = 0;
702
703     virtual bool multiBGFetchEnabled() = 0;
704
705     virtual void updateCachedResidentRatio(size_t activePerc,
706                                            size_t replicaPerc) = 0;
707
708     virtual bool isWarmingUp() = 0;
709
710     virtual bool maybeEnableTraffic(void) = 0;
711
712     /**
713      * Checks the memory consumption.
714      * To be used by backfill tasks (tap & dcp).
715      */
716     virtual bool isMemoryUsageTooHigh() = 0;
717
718     /**
719      * Flushes all items waiting for persistence in a given vbucket
720      * @param vbid The id of the vbucket to flush
721      * @return The number of items flushed
722      */
723     virtual int flushVBucket(uint16_t vbid) = 0;
724
725     virtual void commit(KVStore& kvstore, const Item* collectionsManifest) = 0;
726
727     virtual void addKVStoreStats(ADD_STAT add_stat, const void* cookie) = 0;
728
729     virtual void addKVStoreTimingStats(ADD_STAT add_stat,
730                                        const void* cookie) = 0;
731
732     /**
733      * The following options will be used to identify
734      * the kind of KVStores to be considered for stat collection.
735      */
736     enum class KVSOption {
737         RO,          // RO KVStore
738         RW,          // RW KVStore
739         BOTH         // Both KVStores
740     };
741
742     /* Given a named KVStore statistic, return the value of that statistic,
743      * accumulated across any shards.
744      *
745      * @param name The name of the statistic
746      * @param[out] value The value of the statistic.
747      * @param option the KVStore to read stats from.
748      * @return True if the statistic was successfully returned via {value},
749      *              else false.
750      */
751     virtual bool getKVStoreStat(const char* name, size_t& value,
752                                 KVSOption option) = 0;
753
754     virtual void resetUnderlyingStats(void) = 0;
755     virtual KVStore *getOneROUnderlying(void) = 0;
756     virtual KVStore *getOneRWUnderlying(void) = 0;
757
758     virtual item_eviction_policy_t getItemEvictionPolicy(void) const  = 0;
759     virtual ENGINE_ERROR_CODE rollback(uint16_t vbid,
760                                        uint64_t rollbackSeqno) = 0;
761
762     virtual void wakeUpItemPager() = 0;
763
764     virtual void wakeUpCheckpointRemover() = 0;
765
766     virtual void runDefragmenterTask() = 0;
767
768     virtual bool runAccessScannerTask() = 0;
769
770     virtual void runVbStatePersistTask(int vbid) = 0;
771
772     virtual void setCompactionWriteQueueCap(size_t to) = 0;
773
774     virtual void setCompactionExpMemThreshold(size_t to) = 0;
775
776     virtual bool compactionCanExpireItems() = 0;
777
778     virtual void setCursorDroppingLowerUpperThresholds(size_t maxSize) = 0;
779
780     virtual bool isAccessScannerEnabled() = 0;
781
782     virtual bool isExpPagerEnabled() = 0;
783
784     //Check if there were any out-of-memory errors during warmup
785     virtual bool isWarmupOOMFailure(void) = 0;
786
787     virtual size_t getActiveResidentRatio() const = 0;
788
789     virtual size_t getReplicaResidentRatio() const = 0;
790
791     /*
792      * Change the max_cas of the specified vbucket to cas without any
793      * care for the data or ongoing operations...
794      */
795     virtual ENGINE_ERROR_CODE forceMaxCas(uint16_t vbucket, uint64_t cas) = 0;
796
797     /**
798      * Create a VBucket object appropriate for this Bucket class.
799      */
800     virtual VBucketPtr makeVBucket(
801             VBucket::id_type id,
802             vbucket_state_t state,
803             KVShard* shard,
804             std::unique_ptr<FailoverTable> table,
805             NewSeqnoCallback newSeqnoCb,
806             vbucket_state_t initState = vbucket_state_dead,
807             int64_t lastSeqno = 0,
808             uint64_t lastSnapStart = 0,
809             uint64_t lastSnapEnd = 0,
810             uint64_t purgeSeqno = 0,
811             uint64_t maxCas = 0,
812             const std::string& collectionsManifest = "") = 0;
813
814     /**
815      * Notify all the clients of a new seqno being added in the vbucket
816      *
817      * @param vbid vBucket number
818      * @param notifyCtx notify information
819      */
820     virtual void notifyNewSeqno(const uint16_t vbid,
821                                 const VBNotifyCtx& notifyCtx) = 0;
822
823     /**
824      * Get the number of deleted items that are persisted to a vbucket file
825      *
826      * @param vbid The vbucket id of the file to get the number of deletes for.
827      *
828      * @returns the number of deletes which are persisted
829      *
830      * @throws std::runtime_error (and subclasses) if it was not possible to
831      *         obtain a count of persisted deletes.
832      */
833     virtual size_t getNumPersistedDeletes(uint16_t vbid) = 0;
834
835 protected:
836
837     // Methods called during warmup
838     virtual std::vector<vbucket_state *> loadVBucketState() = 0;
839
840     virtual void warmupCompleted() = 0;
841     virtual void stopWarmup(void) = 0;
842
843     /**
844      * Compaction of a database file
845      *
846      * @param ctx Context for compaction hooks
847      */
848     virtual void compactInternal(compaction_ctx *ctx) = 0;
849
850     virtual void scheduleVBDeletion(VBucketPtr &vb,
851                             const void* cookie,
852                             double delay = 0) = 0;
853
854     virtual void flushOneDeleteAll(void) = 0;
855     virtual PersistenceCallback* flushOneDelOrSet(const queued_item &qi,
856                                                   VBucketPtr &vb) = 0;
857
858     virtual GetValue getInternal(const DocKey& key, uint16_t vbucket,
859                                  const void *cookie,
860                                  vbucket_state_t allowedState,
861                                  get_options_t options = TRACK_REFERENCE) = 0;
862
863     /**
864      * Do rollback of data on the underlying disk / data structure
865      *
866      * @param vbid vBucket id
867      * @param rollbackSeqno intended point (in seqno) of rollback
868      *
869      * @result object that indicates if rollback was successful,
870      *         highSeqno of the vBucket after rollback,
871      *         and the last snaspshot range in the vb after rollback.
872      */
873     virtual RollbackResult doRollback(uint16_t vbid,
874                                       uint64_t rollbackSeqno) = 0;
875
876     /*
877      * Helper method for the rollback function.
878      * Purge all unpersisted items from the current checkpoint(s) and fixup
879      * the hashtable for any that are > the rollbackSeqno.
880      *
881      * @param vb ref to vBucket on which rollback is done
882      * @param rollbackSeqno intended point (in seqno) of rollback
883      */
884     virtual void rollbackUnpersistedItems(VBucket& vb,
885                                           int64_t rollbackSeqno) = 0;
886
887     // During the warmup phase we might want to enable external traffic
888     // at a given point in time.. The LoadStorageKvPairCallback will be
889     // triggered whenever we want to check if we could enable traffic..
890     friend class LoadStorageKVPairCallback;
891
892     friend class Warmup;
893     friend class PersistenceCallback;
894     friend class VBCBAdaptor;
895 };