]>
Commit | Line | Data |
---|---|---|
7c673cae FG |
1 | // -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*- |
2 | // vim: ts=8 sw=2 smarttab | |
3 | #ifndef CEPH_OS_BLUESTORE_BLUEROCKSENV_H | |
4 | #define CEPH_OS_BLUESTORE_BLUEROCKSENV_H | |
5 | ||
6 | #include <memory> | |
7 | #include <string> | |
8 | ||
9 | #include "rocksdb/status.h" | |
10 | #include "rocksdb/utilities/env_mirror.h" | |
11 | ||
12 | #include "include/assert.h" | |
13 | ||
14 | class BlueFS; | |
15 | ||
16 | class BlueRocksEnv : public rocksdb::EnvWrapper { | |
17 | void split(const std::string &fn, std::string *dir, std::string *file) { | |
18 | size_t slash = fn.rfind('/'); | |
19 | *file = fn.substr(slash + 1); | |
20 | while (slash && fn[slash-1] == '/') | |
21 | --slash; | |
22 | *dir = fn.substr(0, slash); | |
23 | } | |
24 | ||
25 | public: | |
26 | // Create a brand new sequentially-readable file with the specified name. | |
27 | // On success, stores a pointer to the new file in *result and returns OK. | |
28 | // On failure, stores nullptr in *result and returns non-OK. If the file does | |
29 | // not exist, returns a non-OK status. | |
30 | // | |
31 | // The returned file will only be accessed by one thread at a time. | |
32 | rocksdb::Status NewSequentialFile( | |
33 | const std::string& fname, | |
34 | std::unique_ptr<rocksdb::SequentialFile>* result, | |
35 | const rocksdb::EnvOptions& options) override; | |
36 | ||
37 | // Create a brand new random access read-only file with the | |
38 | // specified name. On success, stores a pointer to the new file in | |
39 | // *result and returns OK. On failure, stores nullptr in *result and | |
40 | // returns non-OK. If the file does not exist, returns a non-OK | |
41 | // status. | |
42 | // | |
43 | // The returned file may be concurrently accessed by multiple threads. | |
44 | rocksdb::Status NewRandomAccessFile( | |
45 | const std::string& fname, | |
46 | std::unique_ptr<rocksdb::RandomAccessFile>* result, | |
47 | const rocksdb::EnvOptions& options) override; | |
48 | ||
49 | // Create an object that writes to a new file with the specified | |
50 | // name. Deletes any existing file with the same name and creates a | |
51 | // new file. On success, stores a pointer to the new file in | |
52 | // *result and returns OK. On failure, stores nullptr in *result and | |
53 | // returns non-OK. | |
54 | // | |
55 | // The returned file will only be accessed by one thread at a time. | |
56 | rocksdb::Status NewWritableFile( | |
57 | const std::string& fname, | |
58 | std::unique_ptr<rocksdb::WritableFile>* result, | |
59 | const rocksdb::EnvOptions& options) override; | |
60 | ||
61 | // Reuse an existing file by renaming it and opening it as writable. | |
62 | rocksdb::Status ReuseWritableFile( | |
63 | const std::string& fname, | |
64 | const std::string& old_fname, | |
65 | std::unique_ptr<rocksdb::WritableFile>* result, | |
66 | const rocksdb::EnvOptions& options) override; | |
67 | ||
68 | // Create an object that represents a directory. Will fail if directory | |
69 | // doesn't exist. If the directory exists, it will open the directory | |
70 | // and create a new Directory object. | |
71 | // | |
72 | // On success, stores a pointer to the new Directory in | |
73 | // *result and returns OK. On failure stores nullptr in *result and | |
74 | // returns non-OK. | |
75 | rocksdb::Status NewDirectory( | |
76 | const std::string& name, | |
77 | std::unique_ptr<rocksdb::Directory>* result) override; | |
78 | ||
79 | // Returns OK if the named file exists. | |
80 | // NotFound if the named file does not exist, | |
81 | // the calling process does not have permission to determine | |
82 | // whether this file exists, or if the path is invalid. | |
83 | // IOError if an IO Error was encountered | |
84 | rocksdb::Status FileExists(const std::string& fname) override; | |
85 | ||
86 | // Store in *result the names of the children of the specified directory. | |
87 | // The names are relative to "dir". | |
88 | // Original contents of *results are dropped. | |
89 | rocksdb::Status GetChildren(const std::string& dir, | |
90 | std::vector<std::string>* result) override; | |
91 | ||
92 | // Delete the named file. | |
93 | rocksdb::Status DeleteFile(const std::string& fname) override; | |
94 | ||
95 | // Create the specified directory. Returns error if directory exists. | |
96 | rocksdb::Status CreateDir(const std::string& dirname) override; | |
97 | ||
98 | // Create directory if missing. Return Ok if it exists, or successful in | |
99 | // Creating. | |
100 | rocksdb::Status CreateDirIfMissing(const std::string& dirname) override; | |
101 | ||
102 | // Delete the specified directory. | |
103 | rocksdb::Status DeleteDir(const std::string& dirname) override; | |
104 | ||
105 | // Store the size of fname in *file_size. | |
106 | rocksdb::Status GetFileSize(const std::string& fname, uint64_t* file_size) override; | |
107 | ||
108 | // Store the last modification time of fname in *file_mtime. | |
109 | rocksdb::Status GetFileModificationTime(const std::string& fname, | |
110 | uint64_t* file_mtime) override; | |
111 | // Rename file src to target. | |
112 | rocksdb::Status RenameFile(const std::string& src, | |
113 | const std::string& target) override; | |
114 | // Hard Link file src to target. | |
115 | rocksdb::Status LinkFile(const std::string& src, const std::string& target) override; | |
116 | ||
117 | // Lock the specified file. Used to prevent concurrent access to | |
118 | // the same db by multiple processes. On failure, stores nullptr in | |
119 | // *lock and returns non-OK. | |
120 | // | |
121 | // On success, stores a pointer to the object that represents the | |
122 | // acquired lock in *lock and returns OK. The caller should call | |
123 | // UnlockFile(*lock) to release the lock. If the process exits, | |
124 | // the lock will be automatically released. | |
125 | // | |
126 | // If somebody else already holds the lock, finishes immediately | |
127 | // with a failure. I.e., this call does not wait for existing locks | |
128 | // to go away. | |
129 | // | |
130 | // May create the named file if it does not already exist. | |
131 | rocksdb::Status LockFile(const std::string& fname, rocksdb::FileLock** lock) override; | |
132 | ||
133 | // Release the lock acquired by a previous successful call to LockFile. | |
134 | // REQUIRES: lock was returned by a successful LockFile() call | |
135 | // REQUIRES: lock has not already been unlocked. | |
136 | rocksdb::Status UnlockFile(rocksdb::FileLock* lock) override; | |
137 | ||
138 | // *path is set to a temporary directory that can be used for testing. It may | |
139 | // or may not have just been created. The directory may or may not differ | |
140 | // between runs of the same process, but subsequent calls will return the | |
141 | // same directory. | |
142 | rocksdb::Status GetTestDirectory(std::string* path) override; | |
143 | ||
144 | // Create and return a log file for storing informational messages. | |
145 | rocksdb::Status NewLogger( | |
146 | const std::string& fname, | |
147 | std::shared_ptr<rocksdb::Logger>* result) override; | |
148 | ||
149 | // Get full directory name for this db. | |
150 | rocksdb::Status GetAbsolutePath(const std::string& db_path, | |
151 | std::string* output_path) override; | |
152 | ||
153 | explicit BlueRocksEnv(BlueFS *f); | |
154 | private: | |
155 | BlueFS *fs; | |
156 | }; | |
157 | ||
158 | #endif |