27585a2c3450d5b36f7d87e1b1749e1e56051e53
[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 itm item holding a deleted value. A NULL value is passed
299                   if an empty body is to be used for deletion.
300      * @param[out] itemMeta the pointer to the metadata memory.
301      * @param[out] mutInfo mutation information
302      *
303      * @return the result of the operation
304      */
305     virtual ENGINE_ERROR_CODE deleteItem(const DocKey& key,
306                                          uint64_t& cas,
307                                          uint16_t vbucket,
308                                          const void* cookie,
309                                          Item* itm,
310                                          ItemMetaData* itemMeta,
311                                          mutation_descr_t* mutInfo) = 0;
312
313     /**
314      * Delete an item in the store from a non-front end operation (DCP, XDCR)
315      *
316      * @param key the key of the item
317      * @param[in, out] cas the CAS ID for a CASed delete (0 to override)
318      * @param[out] seqno Pointer to get the seqno generated for the item. A
319      *                   NULL value is passed if not needed
320      * @param vbucket the vbucket for the key
321      * @param cookie the cookie representing the client
322      * @param force override access to the vbucket even if the state of the
323      *              vbucket would deny mutations.
324      * @param itm item holding a deleted value. A NULL value is passed
325      *            if an empty body is to be used for deletion.
326      * @param itemMeta the metadata to use for this deletion.
327      * @param genBySeqno whether or not to generate sequence number
328      * @param generateCas whether or not to generate cas
329      * @param bySeqno seqno of the key being deleted
330      * @param emd ExtendedMetaData class object that contains any ext meta
331      * @param isReplication set to true if we are to use replication
332      *                      throttle threshold
333      *
334      * @return the result of the delete operation
335      */
336     virtual ENGINE_ERROR_CODE deleteWithMeta(const DocKey& key,
337                                              uint64_t& cas,
338                                              uint64_t* seqno,
339                                              uint16_t vbucket,
340                                              const void* cookie,
341                                              bool force,
342                                              const ItemMetaData& itemMeta,
343                                              bool backfill,
344                                              GenerateBySeqno genBySeqno,
345                                              GenerateCas generateCas,
346                                              uint64_t bySeqno,
347                                              ExtendedMetaData* emd,
348                                              bool isReplication) = 0;
349
350     /**
351      * Resets the Bucket. Removes all elements from each VBucket's &
352      * CheckpointManager.
353      * Specific subclasses (e.g. EPBucket) may have additional work to do
354      * (update disk etc).
355      */
356     virtual void reset() = 0;
357
358     /**
359      * Set the background fetch delay.
360      *
361      * This exists for debugging and testing purposes.  It
362      * artificially injects delays into background fetches that are
363      * performed when the user requests an item whose value is not
364      * currently resident.
365      *
366      * @param to how long to delay before performing a bg fetch
367      */
368     virtual void setBGFetchDelay(uint32_t to) = 0;
369
370     virtual double getBGFetchDelay(void) = 0;
371
372     /**
373      * Pause the bucket's Flusher.
374      * @return true if successful.
375      */
376     virtual bool pauseFlusher() = 0;
377
378     /**
379      * Resume the Flusher for all shards.
380      * @return true if successful.
381      */
382     virtual bool resumeFlusher() = 0;
383
384     /// Wake up the flusher for all shards, if the disk queue is non-empty.
385     virtual void wakeUpFlusher() = 0;
386
387     /**
388      * Takes a snapshot of the current stats and persists them to disk.
389      */
390     virtual void snapshotStats(void) = 0;
391
392     /**
393      * Get summarized vBucket stats for this bucket - total for all
394      * active,replica buckets.
395      */
396     virtual void getAggregatedVBucketStats(const void* cookie,
397                                            ADD_STAT add_stat) = 0;
398
399     /**
400      * Get file statistics
401      *
402      * @param cookie Cookie associated with ADD_STAT
403      * @param add_stat Callback to use to add stats to the caller.
404      * @return ENGINE_SUCCESS if stats were successfully retrieved, or
405      *         ENGINE_KEY_ENOENT if file stats are not available
406      *         from the store.
407      */
408     virtual ENGINE_ERROR_CODE getFileStats(const void* cookie,
409                                            ADD_STAT add_stat) = 0;
410
411     /**
412      * Get detailed (per-vbucket) disk stats.
413      *
414      * @param cookie Cookie associated with ADD_STAT
415      * @param add_stat Callback to use to add stats to the caller.
416      * @return ENGINE_SUCCESS if stats were successfully retrieved, or
417      *         ENGINE_KEY_ENOENT if per-vbucket disk stats are not available
418      *         from the store.
419      */
420     virtual ENGINE_ERROR_CODE getPerVBucketDiskStats(const void* cookie,
421                                                      ADD_STAT add_stat) = 0;
422
423     /**
424      * Complete a background fetch of a non resident value or metadata.
425      *
426      * @param key the key that was fetched
427      * @param vbucket the vbucket in which the key lived
428      * @param cookie the cookie of the requestor
429      * @param init the timestamp of when the request came in
430      * @param isMeta whether the fetch is for a non-resident value or metadata of
431      *               a (possibly) deleted item
432      */
433     virtual void completeBGFetch(const DocKey& key,
434                                  uint16_t vbucket,
435                                  const void* cookie,
436                                  ProcessClock::time_point init,
437                                  bool isMeta) = 0;
438     /**
439      * Complete a batch of background fetch of a non resident value or metadata.
440      *
441      * @param vbId the vbucket in which the requested key lived
442      * @param fetchedItems vector of completed background feches containing key,
443      *                     value, client cookies
444      * @param start the time when the background fetch was started
445      *
446      */
447     virtual void completeBGFetchMulti(
448             uint16_t vbId,
449             std::vector<bgfetched_item_t>& fetchedItems,
450             ProcessClock::time_point start) = 0;
451
452     virtual VBucketPtr getVBucket(uint16_t vbid) = 0;
453
454     /**
455      * Returns the last persisted checkpoint Id for the specified vBucket.
456      * @param vb VBucket ID to get checkpoint Id for.
457      * @return A pair of {checkpointId, true} if the persisted checkpointID is
458      *         available (Persistent bucket), or false if bucket is not
459      *         persistent.
460      */
461     virtual std::pair<uint64_t, bool> getLastPersistedCheckpointId(
462             uint16_t vb) = 0;
463
464     virtual uint64_t getLastPersistedSeqno(uint16_t vb) = 0;
465
466     /* transfer should be set to true *only* if this vbucket is becoming master
467      * as the result of the previous master cleanly handing off control. */
468     virtual ENGINE_ERROR_CODE setVBucketState(uint16_t vbid,
469                                               vbucket_state_t state,
470                                               bool transfer,
471                                               bool notify_dcp = true) = 0;
472
473     /**
474      * Physically deletes a VBucket from disk. This function should only
475      * be called on a VBucket that has already been logically deleted.
476      *
477      * @param vbid vbucket id
478      * @param cookie The connection that requested the deletion
479      */
480     virtual bool completeVBucketDeletion(uint16_t vbid, const void* cookie) = 0;
481
482     /**
483      * Deletes a vbucket
484      *
485      * @param vbid The vbucket to delete.
486      * @param c The cookie for this connection.
487      *          Used in synchronous bucket deletes
488      *          to notify the connection of operation completion.
489      */
490     virtual ENGINE_ERROR_CODE deleteVBucket(uint16_t vbid,
491                                             const void* c = NULL) = 0;
492
493     /**
494      * Check for the existence of a vbucket in the case of couchstore
495      * or shard in the case of forestdb. Note that this function will be
496      * deprecated once forestdb is the only backend supported
497      *
498      * @param db_file_id vbucketid for couchstore or shard id in the
499      *                   case of forestdb
500      */
501     virtual ENGINE_ERROR_CODE checkForDBExistence(uint16_t db_file_id) = 0;
502
503     /**
504      * Triggers compaction of a database file
505      *
506      * @param vbid The vbucket being compacted
507      * @param c The context for compaction of a DB file
508      * @param ck cookie used to notify connection of operation completion
509      */
510     virtual ENGINE_ERROR_CODE scheduleCompaction(uint16_t vbid,
511                                                  compaction_ctx c,
512                                                  const void *ck) = 0;
513
514     /**
515      * Compaction of a database file
516      *
517      * @param ctx Context for compaction hooks
518      * @param ck cookie used to notify connection of operation completion
519      *
520      * return true if the compaction needs to be rescheduled and false
521      *             otherwise
522      */
523     virtual bool doCompact(compaction_ctx *ctx, const void *ck) = 0;
524
525     /**
526      * Get the database file id for the compaction request
527      *
528      * @param req compaction request structure
529      *
530      * returns the database file id from the underlying KV store
531      */
532     virtual uint16_t getDBFileId(
533                             const protocol_binary_request_compact_db& req) = 0;
534
535     /**
536      * Remove completed compaction tasks or wake snoozed tasks
537      *
538      * @param db_file_id vbucket id for couchstore or shard id in the
539      *                   case of forestdb
540      */
541     virtual void updateCompactionTasks(uint16_t db_file_id) = 0;
542
543     /**
544      * Reset a given vbucket from memory and disk. This differs from vbucket
545      * deletion in that it does not delete the vbucket instance from memory hash
546      * table.
547      */
548     virtual bool resetVBucket(uint16_t vbid) = 0;
549
550     /**
551      * Run a vBucket visitor, visiting all items. Synchronous.
552      */
553     virtual void visit(VBucketVisitor &visitor) = 0;
554
555     /**
556      * Run a vbucket visitor with separate jobs per vbucket.
557      *
558      * Note that this is asynchronous.
559      */
560     virtual size_t visit(std::unique_ptr<VBucketVisitor> visitor,
561                          const char* lbl,
562                          TaskId id,
563                          double sleepTime = 0) = 0;
564
565     /**
566      * Visit the items in this epStore, starting the iteration from the
567      * given startPosition and allowing the visit to be paused at any point.
568      *
569      * During visitation, the visitor object can request that the visit
570      * is stopped after the current item. The position passed to the
571      * visitor can then be used to restart visiting at the *APPROXIMATE*
572      * same position as it paused.
573      * This is approximate as various locks are released when the
574      * function returns, so any changes to the underlying epStore may cause
575      * the visiting to restart at the slightly different place.
576      *
577      * As a consequence, *DO NOT USE THIS METHOD* if you need to guarantee
578      * that all items are visited!
579      *
580      * @param visitor The visitor object.
581      * @return The final epStore position visited; equal to
582      *         EPBucket::end() if all items were visited
583      *         otherwise the position to resume from.
584      */
585     virtual Position pauseResumeVisit(PauseResumeEPStoreVisitor& visitor,
586                                       Position& start_pos) = 0;
587
588
589     /**
590      * Return a position at the start of the epStore.
591      */
592     virtual Position startPosition() const = 0;
593
594     /**
595      * Return a position at the end of the epStore. Has similar semantics
596      * as STL end() (i.e. one past the last element).
597      */
598     virtual Position endPosition() const = 0;
599
600     virtual const Flusher* getFlusher(uint16_t shardId) = 0;
601
602     virtual Warmup* getWarmup(void) const = 0;
603
604     /**
605      * Looks up the key stats for the given {vbucket, key}.
606      * @param key The key to lookup
607      * @param vbucket The vbucket the key belongs to.
608      * @param cookie The client's cookie
609      * @param[out] kstats On success the keystats for this item.
610      * @param wantsDeleted If yes then return keystats even if the item is
611      *                     marked as deleted. If no then will return
612      *                     ENGINE_KEY_ENOENT for deleted items.
613      */
614     virtual ENGINE_ERROR_CODE getKeyStats(const DocKey& key,
615                                           uint16_t vbucket,
616                                           const void* cookie,
617                                           key_stats& kstats,
618                                           WantsDeleted wantsDeleted) = 0;
619
620     virtual std::string validateKey(const DocKey& key, uint16_t vbucket,
621                                     Item &diskItem) = 0;
622
623     virtual GetValue getLocked(const DocKey& key, uint16_t vbucket,
624                                rel_time_t currentTime, uint32_t lockTimeout,
625                                const void *cookie) = 0;
626
627     virtual ENGINE_ERROR_CODE unlockKey(const DocKey& key,
628                                         uint16_t vbucket,
629                                         uint64_t cas,
630                                         rel_time_t currentTime) = 0;
631
632
633     virtual KVStore* getRWUnderlying(uint16_t vbId) = 0;
634
635     virtual KVStore* getRWUnderlyingByShard(size_t shardId) = 0;
636
637     virtual KVStore* getROUnderlyingByShard(size_t shardId) = 0;
638
639     virtual KVStore* getROUnderlying(uint16_t vbId) = 0;
640
641     virtual void deleteExpiredItem(
642             uint16_t, const DocKey&, time_t, uint64_t, ExpireBy) = 0;
643     virtual void deleteExpiredItems(
644             std::list<std::pair<uint16_t, StoredDocKey>>&, ExpireBy) = 0;
645
646     /**
647      * Get the memoized storage properties from the DB.kv
648      */
649     virtual const StorageProperties getStorageProperties() const = 0;
650
651     /**
652      * schedule a vb_state snapshot task for a given shard.
653      */
654     virtual void scheduleVBStatePersist() = 0;
655
656     /**
657      * Schedule a vbstate persistence task for a given vbucket.
658      */
659     virtual void scheduleVBStatePersist(uint16_t vbid) = 0;
660
661     virtual const VBucketMap &getVBuckets() = 0;
662
663     virtual EventuallyPersistentEngine& getEPEngine() = 0;
664
665     virtual size_t getExpiryPagerSleeptime(void) = 0;
666
667     virtual size_t getTransactionTimePerItem() = 0;
668
669     virtual bool isDeleteAllScheduled() = 0;
670
671     virtual bool scheduleDeleteAllTask(const void* cookie) = 0;
672
673     virtual void setDeleteAllComplete() = 0;
674
675     virtual void setBackfillMemoryThreshold(double threshold) = 0;
676
677     virtual void setExpiryPagerSleeptime(size_t val) = 0;
678
679     virtual void setExpiryPagerTasktime(ssize_t val) = 0;
680
681     virtual void enableExpiryPager() = 0;
682     virtual void disableExpiryPager() = 0;
683
684     virtual void enableAccessScannerTask() = 0;
685     virtual void disableAccessScannerTask() = 0;
686     virtual void setAccessScannerSleeptime(size_t val, bool useStartTime) = 0;
687     virtual void resetAccessScannerStartTime() = 0;
688
689     virtual void resetAccessScannerTasktime() = 0;
690
691     virtual void setAllBloomFilters(bool to) = 0;
692
693     virtual float getBfiltersResidencyThreshold() = 0;
694
695     virtual void setBfiltersResidencyThreshold(float to) = 0;
696
697     virtual bool isMetaDataResident(VBucketPtr &vb,
698                                     const DocKey& key) = 0;
699
700     virtual void logQTime(TaskId taskType,
701                           const ProcessClock::duration enqTime) = 0;
702
703     virtual void logRunTime(TaskId taskType,
704                             const ProcessClock::duration runTime) = 0;
705
706     virtual bool multiBGFetchEnabled() = 0;
707
708     virtual void updateCachedResidentRatio(size_t activePerc,
709                                            size_t replicaPerc) = 0;
710
711     virtual bool isWarmingUp() = 0;
712
713     virtual bool maybeEnableTraffic(void) = 0;
714
715     /**
716      * Checks the memory consumption.
717      * To be used by backfill tasks (tap & dcp).
718      */
719     virtual bool isMemoryUsageTooHigh() = 0;
720
721     /**
722      * Flushes all items waiting for persistence in a given vbucket
723      * @param vbid The id of the vbucket to flush
724      * @return The number of items flushed
725      */
726     virtual int flushVBucket(uint16_t vbid) = 0;
727
728     virtual void commit(KVStore& kvstore, const Item* collectionsManifest) = 0;
729
730     virtual void addKVStoreStats(ADD_STAT add_stat, const void* cookie) = 0;
731
732     virtual void addKVStoreTimingStats(ADD_STAT add_stat,
733                                        const void* cookie) = 0;
734
735     /**
736      * The following options will be used to identify
737      * the kind of KVStores to be considered for stat collection.
738      */
739     enum class KVSOption {
740         RO,          // RO KVStore
741         RW,          // RW KVStore
742         BOTH         // Both KVStores
743     };
744
745     /* Given a named KVStore statistic, return the value of that statistic,
746      * accumulated across any shards.
747      *
748      * @param name The name of the statistic
749      * @param[out] value The value of the statistic.
750      * @param option the KVStore to read stats from.
751      * @return True if the statistic was successfully returned via {value},
752      *              else false.
753      */
754     virtual bool getKVStoreStat(const char* name, size_t& value,
755                                 KVSOption option) = 0;
756
757     virtual void resetUnderlyingStats(void) = 0;
758     virtual KVStore *getOneROUnderlying(void) = 0;
759     virtual KVStore *getOneRWUnderlying(void) = 0;
760
761     virtual item_eviction_policy_t getItemEvictionPolicy(void) const  = 0;
762     virtual ENGINE_ERROR_CODE rollback(uint16_t vbid,
763                                        uint64_t rollbackSeqno) = 0;
764
765     virtual void wakeUpItemPager() = 0;
766
767     virtual void wakeUpCheckpointRemover() = 0;
768
769     virtual void runDefragmenterTask() = 0;
770
771     virtual bool runAccessScannerTask() = 0;
772
773     virtual void runVbStatePersistTask(int vbid) = 0;
774
775     virtual void setCompactionWriteQueueCap(size_t to) = 0;
776
777     virtual void setCompactionExpMemThreshold(size_t to) = 0;
778
779     virtual bool compactionCanExpireItems() = 0;
780
781     virtual void setCursorDroppingLowerUpperThresholds(size_t maxSize) = 0;
782
783     virtual bool isAccessScannerEnabled() = 0;
784
785     virtual bool isExpPagerEnabled() = 0;
786
787     //Check if there were any out-of-memory errors during warmup
788     virtual bool isWarmupOOMFailure(void) = 0;
789
790     virtual size_t getActiveResidentRatio() const = 0;
791
792     virtual size_t getReplicaResidentRatio() const = 0;
793
794     /*
795      * Change the max_cas of the specified vbucket to cas without any
796      * care for the data or ongoing operations...
797      */
798     virtual ENGINE_ERROR_CODE forceMaxCas(uint16_t vbucket, uint64_t cas) = 0;
799
800     /**
801      * Create a VBucket object appropriate for this Bucket class.
802      */
803     virtual VBucketPtr makeVBucket(
804             VBucket::id_type id,
805             vbucket_state_t state,
806             KVShard* shard,
807             std::unique_ptr<FailoverTable> table,
808             NewSeqnoCallback newSeqnoCb,
809             vbucket_state_t initState = vbucket_state_dead,
810             int64_t lastSeqno = 0,
811             uint64_t lastSnapStart = 0,
812             uint64_t lastSnapEnd = 0,
813             uint64_t purgeSeqno = 0,
814             uint64_t maxCas = 0,
815             const std::string& collectionsManifest = "") = 0;
816
817     /**
818      * Notify all the clients of a new seqno being added in the vbucket
819      *
820      * @param vbid vBucket number
821      * @param notifyCtx notify information
822      */
823     virtual void notifyNewSeqno(const uint16_t vbid,
824                                 const VBNotifyCtx& notifyCtx) = 0;
825
826     /**
827      * Get the number of deleted items that are persisted to a vbucket file
828      *
829      * @param vbid The vbucket id of the file to get the number of deletes for.
830      *
831      * @returns the number of deletes which are persisted
832      *
833      * @throws std::runtime_error (and subclasses) if it was not possible to
834      *         obtain a count of persisted deletes.
835      */
836     virtual size_t getNumPersistedDeletes(uint16_t vbid) = 0;
837
838 protected:
839
840     // Methods called during warmup
841     virtual std::vector<vbucket_state *> loadVBucketState() = 0;
842
843     virtual void warmupCompleted() = 0;
844     virtual void stopWarmup(void) = 0;
845
846     /**
847      * Compaction of a database file
848      *
849      * @param ctx Context for compaction hooks
850      */
851     virtual void compactInternal(compaction_ctx *ctx) = 0;
852
853     virtual void scheduleVBDeletion(VBucketPtr &vb,
854                             const void* cookie,
855                             double delay = 0) = 0;
856
857     virtual void flushOneDeleteAll(void) = 0;
858     virtual PersistenceCallback* flushOneDelOrSet(const queued_item &qi,
859                                                   VBucketPtr &vb) = 0;
860
861     virtual GetValue getInternal(const DocKey& key, uint16_t vbucket,
862                                  const void *cookie,
863                                  vbucket_state_t allowedState,
864                                  get_options_t options = TRACK_REFERENCE) = 0;
865
866     /**
867      * Do rollback of data on the underlying disk / data structure
868      *
869      * @param vbid vBucket id
870      * @param rollbackSeqno intended point (in seqno) of rollback
871      *
872      * @result object that indicates if rollback was successful,
873      *         highSeqno of the vBucket after rollback,
874      *         and the last snaspshot range in the vb after rollback.
875      */
876     virtual RollbackResult doRollback(uint16_t vbid,
877                                       uint64_t rollbackSeqno) = 0;
878
879     /*
880      * Helper method for the rollback function.
881      * Purge all unpersisted items from the current checkpoint(s) and fixup
882      * the hashtable for any that are > the rollbackSeqno.
883      *
884      * @param vb ref to vBucket on which rollback is done
885      * @param rollbackSeqno intended point (in seqno) of rollback
886      */
887     virtual void rollbackUnpersistedItems(VBucket& vb,
888                                           int64_t rollbackSeqno) = 0;
889
890     // During the warmup phase we might want to enable external traffic
891     // at a given point in time.. The LoadStorageKvPairCallback will be
892     // triggered whenever we want to check if we could enable traffic..
893     friend class LoadStorageKVPairCallback;
894
895     friend class Warmup;
896     friend class PersistenceCallback;
897     friend class VBCBAdaptor;
898 };