NetworkCacheStorage.h [plain text]
#pragma once
#include "NetworkCacheBlobStorage.h"
#include "NetworkCacheData.h"
#include "NetworkCacheKey.h"
#include <WebCore/Timer.h>
#include <wtf/BloomFilter.h>
#include <wtf/CompletionHandler.h>
#include <wtf/Deque.h>
#include <wtf/Function.h>
#include <wtf/HashSet.h>
#include <wtf/MonotonicTime.h>
#include <wtf/Optional.h>
#include <wtf/WallTime.h>
#include <wtf/WorkQueue.h>
#include <wtf/text/WTFString.h>
namespace WebKit {
namespace NetworkCache {
class IOChannel;
class Storage : public ThreadSafeRefCounted<Storage> {
public:
enum class Mode { Normal, Testing };
static RefPtr<Storage> open(const String& cachePath, Mode);
struct Record {
Key key;
WallTime timeStamp;
Data header;
Data body;
std::optional<SHA1::Digest> bodyHash;
WTF_MAKE_FAST_ALLOCATED;
};
struct Timings {
MonotonicTime startTime;
MonotonicTime dispatchTime;
MonotonicTime recordIOStartTime;
MonotonicTime recordIOEndTime;
MonotonicTime blobIOStartTime;
MonotonicTime blobIOEndTime;
MonotonicTime completionTime;
size_t dispatchCountAtStart { 0 };
size_t dispatchCountAtDispatch { 0 };
bool synchronizationInProgressAtDispatch { false };
bool shrinkInProgressAtDispatch { false };
bool wasCanceled { false };
WTF_MAKE_FAST_ALLOCATED;
};
using RetrieveCompletionHandler = Function<bool (std::unique_ptr<Record>, const Timings&)>;
void retrieve(const Key&, unsigned priority, RetrieveCompletionHandler&&);
using MappedBodyHandler = Function<void (const Data& mappedBody)>;
void store(const Record&, MappedBodyHandler&&, CompletionHandler<void()>&& = { });
void remove(const Key&);
void remove(const Vector<Key>&, Function<void ()>&&);
void clear(const String& type, WallTime modifiedSinceTime, Function<void ()>&& completionHandler);
struct RecordInfo {
size_t bodySize;
double worth; unsigned bodyShareCount;
String bodyHash;
};
enum TraverseFlag {
ComputeWorth = 1 << 0,
ShareCount = 1 << 1,
};
typedef unsigned TraverseFlags;
typedef Function<void (const Record*, const RecordInfo&)> TraverseHandler;
void traverse(const String& type, TraverseFlags, TraverseHandler&&);
void setCapacity(size_t);
size_t capacity() const { return m_capacity; }
size_t approximateSize() const;
static const unsigned version = 13;
#if PLATFORM(MAC)
static const unsigned lastStableVersion = 12;
#endif
String basePath() const;
String versionPath() const;
String recordsPath() const;
const Salt& salt() const { return m_salt; }
~Storage();
void writeWithoutWaiting() { m_initialWriteDelay = 0_s; };
private:
Storage(const String& directoryPath, Mode, Salt);
String recordDirectoryPathForKey(const Key&) const;
String recordPathForKey(const Key&) const;
String blobPathForKey(const Key&) const;
void synchronize();
void deleteOldVersions();
void shrinkIfNeeded();
void shrink();
struct ReadOperation;
void dispatchReadOperation(std::unique_ptr<ReadOperation>);
void dispatchPendingReadOperations();
void finishReadOperation(ReadOperation&);
void cancelAllReadOperations();
struct WriteOperation;
void dispatchWriteOperation(std::unique_ptr<WriteOperation>);
void dispatchPendingWriteOperations();
void finishWriteOperation(WriteOperation&);
bool shouldStoreBodyAsBlob(const Data& bodyData);
std::optional<BlobStorage::Blob> storeBodyAsBlob(WriteOperation&);
Data encodeRecord(const Record&, std::optional<BlobStorage::Blob>);
void readRecord(ReadOperation&, const Data&);
void updateFileModificationTime(const String& path);
void removeFromPendingWriteOperations(const Key&);
WorkQueue& ioQueue() { return m_ioQueue.get(); }
WorkQueue& backgroundIOQueue() { return m_backgroundIOQueue.get(); }
WorkQueue& serialBackgroundIOQueue() { return m_serialBackgroundIOQueue.get(); }
bool mayContain(const Key&) const;
bool mayContainBlob(const Key&) const;
void addToRecordFilter(const Key&);
void deleteFiles(const Key&);
const String m_basePath;
const String m_recordsPath;
const Mode m_mode;
const Salt m_salt;
const bool m_canUseBlobsForForBodyData;
size_t m_capacity { std::numeric_limits<size_t>::max() };
size_t m_approximateRecordsSize { 0 };
using ContentsFilter = BloomFilter<18>;
std::unique_ptr<ContentsFilter> m_recordFilter;
std::unique_ptr<ContentsFilter> m_blobFilter;
bool m_synchronizationInProgress { false };
bool m_shrinkInProgress { false };
size_t m_readOperationDispatchCount { 0 };
Vector<Key::HashType> m_recordFilterHashesAddedDuringSynchronization;
Vector<Key::HashType> m_blobFilterHashesAddedDuringSynchronization;
static const int maximumRetrievePriority = 4;
Deque<std::unique_ptr<ReadOperation>> m_pendingReadOperationsByPriority[maximumRetrievePriority + 1];
HashSet<std::unique_ptr<ReadOperation>> m_activeReadOperations;
WebCore::Timer m_readOperationTimeoutTimer;
Deque<std::unique_ptr<WriteOperation>> m_pendingWriteOperations;
HashSet<std::unique_ptr<WriteOperation>> m_activeWriteOperations;
WebCore::Timer m_writeOperationDispatchTimer;
struct TraverseOperation;
HashSet<std::unique_ptr<TraverseOperation>> m_activeTraverseOperations;
Ref<WorkQueue> m_ioQueue;
Ref<WorkQueue> m_backgroundIOQueue;
Ref<WorkQueue> m_serialBackgroundIOQueue;
BlobStorage m_blobStorage;
Seconds m_initialWriteDelay { 1_s };
};
using RecordFileTraverseFunction = Function<void (const String& fileName, const String& hashString, const String& type, bool isBlob, const String& recordDirectoryPath)>;
void traverseRecordsFiles(const String& recordsPath, const String& type, const RecordFileTraverseFunction&);
}
}