22cd85aa1a903a52b09d4c666130ad91205a6731
[ep-engine.git] / src / ephemeral_vb.h
1 /* -*- Mode: C++; tab-width: 4; c-basic-offset: 4; indent-tabs-mode: nil -*- */
2 /*
3  *     Copyright 2017 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 #include "seqlist.h"
22 #include "vbucket.h"
23
24 class EphemeralVBucket : public VBucket {
25 public:
26     class CountVisitor;
27     class HTTombstonePurger;
28     class VBTombstonePurger;
29
30     EphemeralVBucket(id_type i,
31                      vbucket_state_t newState,
32                      EPStats& st,
33                      CheckpointConfig& chkConfig,
34                      KVShard* kvshard,
35                      int64_t lastSeqno,
36                      uint64_t lastSnapStart,
37                      uint64_t lastSnapEnd,
38                      std::unique_ptr<FailoverTable> table,
39                      NewSeqnoCallback newSeqnoCb,
40                      Configuration& config,
41                      item_eviction_policy_t evictionPolicy,
42                      vbucket_state_t initState = vbucket_state_dead,
43                      uint64_t purgeSeqno = 0,
44                      uint64_t maxCas = 0,
45                      const std::string& collectionsManifest = "");
46
47     ENGINE_ERROR_CODE completeBGFetchForSingleItem(
48             const DocKey& key,
49             const VBucketBGFetchItem& fetched_item,
50             const ProcessClock::time_point startTime) override;
51
52     void resetStats() override;
53
54     vb_bgfetch_queue_t getBGFetchItems() override;
55
56     bool hasPendingBGFetchItems() override;
57
58     HighPriorityVBReqStatus checkAddHighPriorityVBEntry(
59             uint64_t seqnoOrChkId,
60             const void* cookie,
61             HighPriorityVBNotify reqType) override;
62
63     void notifyHighPriorityRequests(EventuallyPersistentEngine& engine,
64                                     uint64_t id,
65                                     HighPriorityVBNotify notifyType) override;
66
67     void notifyAllPendingConnsFailed(EventuallyPersistentEngine& e) override;
68
69     size_t getNumItems() const override;
70
71     ENGINE_ERROR_CODE statsVKey(const DocKey& key,
72                                 const void* cookie,
73                                 EventuallyPersistentEngine& engine,
74                                 int bgFetchDelay) override {
75         return ENGINE_ENOTSUP;
76     }
77
78     void completeStatsVKey(const DocKey& key,
79                            const RememberingCallback<GetValue>& gcb) override;
80
81     bool maybeKeyExistsInFilter(const DocKey& key) override {
82         /* There is no disk to indicate that a key may exist */
83         return false;
84     }
85
86     protocol_binary_response_status evictKey(const DocKey& key,
87                                              const char** msg) override {
88         /* There is nothing (no disk) to evictKey to. Later on if we decide to
89            use this as a deletion, then we can handle it differently */
90         return PROTOCOL_BINARY_RESPONSE_NOT_SUPPORTED;
91     }
92
93     bool pageOut(const HashTable::HashBucketLock& lh, StoredValue*& v) override;
94
95     void addStats(bool details, ADD_STAT add_stat, const void* c) override;
96
97     KVShard* getShard() override {
98         return nullptr;
99     }
100
101     std::unique_ptr<DCPBackfill> createDCPBackfill(
102             EventuallyPersistentEngine& e,
103             const active_stream_t& stream,
104             uint64_t startSeqno,
105             uint64_t endSeqno) override;
106
107     /**
108      * Reads backfill items from in memory ordered data structure.
109      *
110      * Because the backfill may have to be extended to ensure consistency (e.g.,
111      * an item in the range has been updated and the new version is
112      * outside of the original range would result in a missing item), the
113      * end of the range may be at a higher seqno than was requested; this new
114      * end value is returned.
115      *
116      * @param startSeqno requested start sequence number of the backfill
117      * @param endSeqno requested end sequence number of the backfill
118      *
119      * @return ENGINE_SUCCESS, items in the snapshot, adjusted endSeqno
120      *         ENGINE_ENOMEM on no memory to copy items
121      *         ENGINE_ERANGE on incorrect start and end
122      */
123     std::tuple<ENGINE_ERROR_CODE, std::vector<UniqueItemPtr>, seqno_t>
124     inMemoryBackfill(uint64_t start, uint64_t end);
125
126     void dump() const override;
127
128     uint64_t getPersistenceSeqno() const override {
129         /* Technically we do not have persistence in an ephemeral vb, however
130          * logically the "persistence" seqno is used internally as the
131          * value to use for replication / takeover. Hence we return
132            the last seen seqno (highSeqno) as the persisted seqno. */
133         return static_cast<uint64_t>(getHighSeqno());
134     }
135
136     uint64_t getPublicPersistenceSeqno() const override {
137         return 0;
138     }
139
140     void queueBackfillItem(queued_item& qi,
141                            const GenerateBySeqno generateBySeqno) override;
142
143     /** Purge the Tombstones in this VBucket which are older than the specified
144      *  duration.
145      * @param purgeAge Items older than this should be purged.
146      * @return Number of items purged.
147      */
148     size_t purgeTombstones(rel_time_t purgeAge);
149
150     void setupDeferredDeletion(const void* cookie) override;
151
152     /**
153      * Schedule a VBucketMemoryDeletionTask to delete this object.
154      * @param engine owning engine (required for task construction)
155      */
156     void scheduleDeferredDeletion(EventuallyPersistentEngine& engine) override;
157
158 protected:
159     /* Data structure for in-memory sequential storage */
160     std::unique_ptr<SequenceList> seqList;
161
162 private:
163     std::tuple<StoredValue*, MutationStatus, VBNotifyCtx> updateStoredValue(
164             const HashTable::HashBucketLock& hbl,
165             StoredValue& v,
166             const Item& itm,
167             const VBQueueItemCtx* queueItmCtx) override;
168
169     std::pair<StoredValue*, VBNotifyCtx> addNewStoredValue(
170             const HashTable::HashBucketLock& hbl,
171             const Item& itm,
172             const VBQueueItemCtx* queueItmCtx) override;
173
174     std::tuple<StoredValue*, VBNotifyCtx> softDeleteStoredValue(
175             const HashTable::HashBucketLock& hbl,
176             StoredValue& v,
177             bool onlyMarkDeleted,
178             const VBQueueItemCtx& queueItmCtx,
179             uint64_t bySeqno) override;
180
181     void bgFetch(const DocKey& key,
182                  const void* cookie,
183                  EventuallyPersistentEngine& engine,
184                  int bgFetchDelay,
185                  bool isMeta = false) override;
186
187     ENGINE_ERROR_CODE
188     addTempItemAndBGFetch(HashTable::HashBucketLock& hbl,
189                           const DocKey& key,
190                           const void* cookie,
191                           EventuallyPersistentEngine& engine,
192                           int bgFetchDelay,
193                           bool metadataOnly,
194                           bool isReplication = false) override;
195
196     GetValue getInternalNonResident(const DocKey& key,
197                                     const void* cookie,
198                                     EventuallyPersistentEngine& engine,
199                                     int bgFetchDelay,
200                                     get_options_t options,
201                                     const StoredValue& v) override;
202
203     /**
204      * Lock to synchronize order of bucket elements.
205      * The sequence number is not generated in EphemeralVBucket for now. It is
206      * generated in the CheckpointManager and is synchronized on "queueLock" in
207      * CheckpointManager. This, though undesirable, is needed because the
208      * CheckpointManager relies on seqno for its meta(dummy) items and also self
209      * generates them.
210      *
211      * All operations/data structures that rely on ordered sequence of items
212      * must hold i) sequenceLock in 'EphemeralVBucket' and then
213      * ii) queueLock in 'CheckpointManager'.
214      */
215     mutable std::mutex sequenceLock;
216
217     /**
218      * Count of how many items have been deleted via the 'auto_delete' policy
219      */
220     EPStats::Counter autoDeleteCount;
221
222     /**
223      * Count of how many deleted items have been purged from the HashTable
224      * (marked as stale and transferred from HT to sequence list).
225      */
226     EPStats::Counter htDeletedPurgeCount;
227
228     /** Count of how many items have been purged from the sequence list
229      *  (removed from seqList and deleted).
230      */
231     EPStats::Counter seqListPurgeCount;
232 };
233
234 using EphemeralVBucketPtr = std::shared_ptr<EphemeralVBucket>;