Network cache Bloom filter is too big
[WebKit-https.git] / Source / WebKit2 / NetworkProcess / cache / NetworkCacheStorage.h
1 /*
2  * Copyright (C) 2014-2015 Apple Inc. All rights reserved.
3  *
4  * Redistribution and use in source and binary forms, with or without
5  * modification, are permitted provided that the following conditions
6  * are met:
7  * 1. Redistributions of source code must retain the above copyright
8  *    notice, this list of conditions and the following disclaimer.
9  * 2. Redistributions in binary form must reproduce the above copyright
10  *    notice, this list of conditions and the following disclaimer in the
11  *    documentation and/or other materials provided with the distribution.
12  *
13  * THIS SOFTWARE IS PROVIDED BY APPLE INC. AND ITS CONTRIBUTORS ``AS IS''
14  * AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO,
15  * THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
16  * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR ITS CONTRIBUTORS
17  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
18  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
19  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
20  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
21  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
22  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF
23  * THE POSSIBILITY OF SUCH DAMAGE.
24  */
25
26 #ifndef NetworkCacheStorage_h
27 #define NetworkCacheStorage_h
28
29 #if ENABLE(NETWORK_CACHE)
30
31 #include "NetworkCacheData.h"
32 #include "NetworkCacheKey.h"
33 #include <wtf/BloomFilter.h>
34 #include <wtf/Deque.h>
35 #include <wtf/HashSet.h>
36 #include <wtf/Optional.h>
37 #include <wtf/WorkQueue.h>
38 #include <wtf/text/WTFString.h>
39
40 namespace WebKit {
41 namespace NetworkCache {
42
43 class IOChannel;
44
45 class Storage {
46     WTF_MAKE_NONCOPYABLE(Storage);
47 public:
48     static std::unique_ptr<Storage> open(const String& cachePath);
49
50     struct Record {
51         Key key;
52         std::chrono::system_clock::time_point timeStamp;
53         Data header;
54         Data body;
55     };
56     // This may call completion handler synchronously on failure.
57     typedef std::function<bool (std::unique_ptr<Record>)> RetrieveCompletionHandler;
58     void retrieve(const Key&, unsigned priority, RetrieveCompletionHandler&&);
59
60     typedef std::function<void (bool success, const Data& mappedBody)> StoreCompletionHandler;
61     void store(const Record&, StoreCompletionHandler&&);
62     void update(const Record& updateRecord, const Record& existingRecord, StoreCompletionHandler&&);
63
64     void remove(const Key&);
65
66     struct RecordInfo {
67         size_t bodySize { 0 };
68         double worth { -1 }; // 0-1 where 1 is the most valuable.
69     };
70     enum TraverseFlag {
71         ComputeWorth = 1 << 0,
72     };
73     typedef unsigned TraverseFlags;
74     // Null record signals end.
75     void traverse(TraverseFlags, std::function<void (const Record*, const RecordInfo&)>&&);
76
77     void setMaximumSize(size_t);
78     void clear();
79
80     static const unsigned version = 2;
81
82     const String& baseDirectoryPath() const { return m_baseDirectoryPath; }
83     const String& directoryPath() const { return m_directoryPath; }
84
85 private:
86     Storage(const String& directoryPath);
87
88     void synchronize();
89     void deleteOldVersions();
90     void shrinkIfNeeded();
91     void shrink();
92
93     struct ReadOperation {
94         Key key;
95         RetrieveCompletionHandler completionHandler;
96     };
97     void dispatchReadOperation(const ReadOperation&);
98     void dispatchPendingReadOperations();
99
100     struct WriteOperation {
101         Record record;
102         Optional<Record> existingRecord;
103         StoreCompletionHandler completionHandler;
104     };
105     void dispatchFullWriteOperation(const WriteOperation&);
106     void dispatchHeaderWriteOperation(const WriteOperation&);
107     void dispatchPendingWriteOperations();
108
109     void updateFileModificationTime(IOChannel&);
110
111     WorkQueue& ioQueue() { return m_ioQueue.get(); }
112     WorkQueue& backgroundIOQueue() { return m_backgroundIOQueue.get(); }
113     WorkQueue& serialBackgroundIOQueue() { return m_serialBackgroundIOQueue.get(); }
114
115     bool mayContain(const Key&) const;
116
117     // 2^18 bit filter can support up to 26000 entries with false positive rate < 1%.
118     using ContentsFilter = BloomFilter<18>;
119     void addToContentsFilter(const Key&);
120
121     const String m_baseDirectoryPath;
122     const String m_directoryPath;
123
124     size_t m_maximumSize { std::numeric_limits<size_t>::max() };
125     size_t m_approximateSize { 0 };
126
127     std::unique_ptr<ContentsFilter> m_contentsFilter;
128
129     bool m_synchronizationInProgress { false };
130     bool m_shrinkInProgress { false };
131
132     Vector<unsigned> m_contentsFilterHashesAddedDuringSynchronization;
133
134     static const int maximumRetrievePriority = 4;
135     Deque<std::unique_ptr<const ReadOperation>> m_pendingReadOperationsByPriority[maximumRetrievePriority + 1];
136     HashSet<std::unique_ptr<const ReadOperation>> m_activeReadOperations;
137
138     Deque<std::unique_ptr<const WriteOperation>> m_pendingWriteOperations;
139     HashSet<std::unique_ptr<const WriteOperation>> m_activeWriteOperations;
140
141     Ref<WorkQueue> m_ioQueue;
142     Ref<WorkQueue> m_backgroundIOQueue;
143     Ref<WorkQueue> m_serialBackgroundIOQueue;
144 };
145
146 }
147 }
148 #endif
149 #endif