mirror of https://github.com/facebook/rocksdb.git
140 lines
5.5 KiB
C++
140 lines
5.5 KiB
C++
// Copyright (c) 2024-present, Facebook, Inc. All rights reserved.
|
|
// This source code is licensed under both the GPLv2 (found in the
|
|
// COPYING file in the root directory) and Apache 2.0 License
|
|
// (found in the LICENSE.Apache file in the root directory).
|
|
|
|
#pragma once
|
|
#include <string>
|
|
|
|
#include "rocksdb/file_system.h"
|
|
|
|
namespace ROCKSDB_NAMESPACE {
|
|
// A FileSystem that links files to a local (destination) directory from a
|
|
// corresponding remote (source) directory on demand. The decision to link
|
|
// depends on the file type, with appendable or rename-able files, such as,
|
|
// descriptors, logs, CURRENT, being read in place in the remote directory,
|
|
// and SST files being linked. In the future, files read in place may be
|
|
// mirrored to the local directory, so the local dir has a complete database
|
|
// for troubleshooting purposes.
|
|
|
|
class OnDemandFileSystem : public FileSystemWrapper {
|
|
public:
|
|
OnDemandFileSystem(const std::shared_ptr<FileSystem>& target,
|
|
const std::string& remote_path,
|
|
const std::string& local_path)
|
|
: FileSystemWrapper(target),
|
|
remote_path_(remote_path),
|
|
local_path_(local_path) {}
|
|
|
|
const char* Name() const override { return "OnDemandFileSystem"; }
|
|
|
|
IOStatus NewSequentialFile(const std::string& fname,
|
|
const FileOptions& file_opts,
|
|
std::unique_ptr<FSSequentialFile>* result,
|
|
IODebugContext* dbg) override;
|
|
|
|
IOStatus NewRandomAccessFile(const std::string& fname,
|
|
const FileOptions& file_opts,
|
|
std::unique_ptr<FSRandomAccessFile>* result,
|
|
IODebugContext* dbg) override;
|
|
|
|
IOStatus NewWritableFile(const std::string& fname,
|
|
const FileOptions& file_opts,
|
|
std::unique_ptr<FSWritableFile>* result,
|
|
IODebugContext* dbg) override;
|
|
|
|
IOStatus ReuseWritableFile(const std::string& /*fname*/,
|
|
const std::string& /*old_fname*/,
|
|
const FileOptions& /*fopts*/,
|
|
std::unique_ptr<FSWritableFile>* /*result*/,
|
|
IODebugContext* /*dbg*/) override {
|
|
return IOStatus::NotSupported("ReuseWritableFile");
|
|
}
|
|
|
|
IOStatus NewDirectory(const std::string& name, const IOOptions& io_opts,
|
|
std::unique_ptr<FSDirectory>* result,
|
|
IODebugContext* dbg) override;
|
|
|
|
IOStatus FileExists(const std::string& fname, const IOOptions& options,
|
|
IODebugContext* dbg) override;
|
|
|
|
IOStatus GetChildren(const std::string& dir, const IOOptions& options,
|
|
std::vector<std::string>* result,
|
|
IODebugContext* dbg) override;
|
|
|
|
IOStatus GetChildrenFileAttributes(const std::string& dir,
|
|
const IOOptions& options,
|
|
std::vector<FileAttributes>* result,
|
|
IODebugContext* dbg) override;
|
|
|
|
IOStatus GetFileSize(const std::string& fname, const IOOptions& options,
|
|
uint64_t* file_size, IODebugContext* dbg) override;
|
|
|
|
private:
|
|
bool CheckPathAndAdjust(const std::string& orig, const std::string& replace,
|
|
std::string& path);
|
|
bool LookupFileType(const std::string& name, FileType* type);
|
|
|
|
const std::string remote_path_;
|
|
const std::string local_path_;
|
|
};
|
|
|
|
// A wrapper class around an FSSequentialFile object. Its mainly
|
|
// intended to be used for appendable files like MANIFEST and logs.
|
|
// Beneath the covers, it tracks when EOF is reached, and reopens
|
|
// the file in order to read the latest appended data. This is
|
|
// necessary on some distributed file systems as they may have
|
|
// stale metadata about the file.
|
|
// TODO: Mirror the data read to a local file for troubleshooting
|
|
// purposes, as well as recovery in case the source dir is
|
|
// deleted.
|
|
class OnDemandSequentialFile : public FSSequentialFile {
|
|
public:
|
|
OnDemandSequentialFile(std::unique_ptr<FSSequentialFile>&& file,
|
|
OnDemandFileSystem* fs, const FileOptions& file_opts,
|
|
const std::string& path)
|
|
: file_(std::move(file)),
|
|
fs_(fs),
|
|
file_opts_(file_opts),
|
|
path_(path),
|
|
eof_(false),
|
|
offset_(0) {}
|
|
|
|
virtual ~OnDemandSequentialFile() {}
|
|
|
|
IOStatus Read(size_t n, const IOOptions& options, Slice* result,
|
|
char* scratch, IODebugContext* dbg) override;
|
|
|
|
IOStatus Skip(uint64_t n) override;
|
|
|
|
bool use_direct_io() const override;
|
|
|
|
size_t GetRequiredBufferAlignment() const override;
|
|
|
|
IOStatus InvalidateCache(size_t /*offset*/, size_t /*length*/) override {
|
|
return IOStatus::NotSupported("InvalidateCache not supported.");
|
|
}
|
|
|
|
IOStatus PositionedRead(uint64_t /*offset*/, size_t /*n*/,
|
|
const IOOptions& /*options*/, Slice* /*result*/,
|
|
char* /*scratch*/, IODebugContext* /*dbg*/) override {
|
|
return IOStatus::NotSupported("PositionedRead");
|
|
}
|
|
|
|
Temperature GetTemperature() const override;
|
|
|
|
private:
|
|
std::unique_ptr<FSSequentialFile> file_;
|
|
OnDemandFileSystem* fs_;
|
|
const FileOptions file_opts_;
|
|
const std::string path_;
|
|
bool eof_;
|
|
uint64_t offset_;
|
|
};
|
|
|
|
std::shared_ptr<FileSystem> NewOnDemandFileSystem(
|
|
const std::shared_ptr<FileSystem>& fs, std::string remote_path,
|
|
std::string local_path);
|
|
|
|
} // namespace ROCKSDB_NAMESPACE
|