DiskFile.h

/*
 * Copyright (c) Meta Platforms, Inc. and affiliates.
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *     http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */
 
#pragma once
 
#include <cstdio>
 
#include <vrs/WriteFileHandler.h>
#include <vrs/os/Platform.h>
 
namespace vrs {
 
using std::string;
using std::vector;
 
class DiskFileChunk;
 
template <class FileChunk>
class DiskFileT : public WriteFileHandler {
 public:
  static const std::string& staticName();
 
  DiskFileT();
  ~DiskFileT() override;
 
  std::unique_ptr<FileHandler> makeNew() const override;
 
  const string& getFileHandlerName() const override;
 
  int openSpec(const FileSpec& fileSpec) override;
 
  bool isOpened() const override;
 
  int create(const string& newFilePath, const map<string, string>& options = {}) override;
  void forgetFurtherChunks(int64_t fileSize) override;
  int64_t getTotalSize() const override;
  vector<std::pair<string, int64_t>> getFileChunks() const override;
  int close() override;
 
  int skipForward(int64_t offset) override;
  int setPos(int64_t offset) override;
 
  int read(void* buffer, size_t length) override;
  template <typename T, std::enable_if_t<std::is_trivially_copyable<T>::value, int> = 0>
  int read(T& object) {
    return read(&object, sizeof(object));
  }
  size_t getLastRWSize() const override;
 
  bool reopenForUpdatesSupported() const override;
  int reopenForUpdates() override;
  bool isReadOnly() const override;
  int write(const void* buffer, size_t length) override;
  template <typename T, std::enable_if_t<std::is_trivially_copyable<T>::value, int> = 0>
  int write(const T& object) {
    return write(&object, sizeof(object));
  }
  int overwrite(const void* buffer, size_t length) override;
  template <typename T, std::enable_if_t<std::is_trivially_copyable<T>::value, int> = 0>
  int overwrite(const T& object) {
    return overwrite(&object, sizeof(object));
  }
  int addChunk() override;
  int truncate() override;
 
  int getLastError() const override;
  bool isEof() const override;
  int64_t getPos() const override;
  int64_t getChunkPos() const override;
  int getChunkRange(int64_t& outChunkOffset, int64_t& outChunkSize) const override;
  bool getCurrentChunk(string& outChunkPath, size_t& outChunkIndex) const override;
 
  bool isRemoteFileSystem() const override;
 
  static int writeZstdFile(const string& path, const void* data, size_t dataSize);
  static int writeZstdFile(const string& path, const string& string);
  template <typename T, std::enable_if_t<std::is_trivially_copyable<T>::value, int> = 0>
  int writeZstdFile(const string& path, const T& object) {
    return writeZstdFile(path, &object, sizeof(T));
  }
  template <typename T, std::enable_if_t<std::is_trivially_copyable<T>::value, int> = 0>
  int writeZstdFile(const string& path, const vector<T>& v) {
    return writeZstdFile(path, v.data(), v.size() * sizeof(T));
  }
  static int readZstdFile(const string& path, vector<char>& outContent);
  static int readZstdFile(const string& path, string& outString);
  template <typename T, std::enable_if_t<std::is_trivially_copyable<T>::value, int> = 0>
  int readZstdFile(const string& path, T& object) {
    return readZstdFile(path, &object, sizeof(T));
  }
  static int readZstdFile(const string& path, void* data, size_t dataSize);
 
  static string readTextFile(const string& path);
  static int writeTextFile(const string& path, const string& text);
 
  int parseUri(FileSpec& inOutFileSpec, size_t colonIndex) const override;
 
 protected:
  int checkChunks(const vector<string>& chunks);
  int openChunk(FileChunk* chunk);
  int closeChunk(FileChunk* chunk);
  int addChunk(const string& chunkFilePath);
  bool isLastChunk() const;
  bool trySetPosInCurrentChunk(int64_t offset);
 
  map<string, string> options_; // optional options provided in openSpec or createFile
  std::unique_ptr<vector<FileChunk>> chunks_; // all the chunks, when a VRS file is opened.
  FileChunk* currentChunk_{}; // always points to the current chunk within chunks_.
  int filesOpenCount_{};
 
  size_t lastRWSize_{};
  int lastError_{};
  bool readOnly_{true};
};
 
using DiskFile = DiskFileT<DiskFileChunk>;
 
#if (IS_LINUX_PLATFORM() && IS_X86_PLATFORM()) || (IS_WINDOWS_PLATFORM() && IS_VRS_FB_INTERNAL())
#define VRS_ASYNC_DISKFILE_SUPPORTED() true
 
class AsyncDiskFileChunk;
using AsyncDiskFile = DiskFileT<AsyncDiskFileChunk>;
 
#else
#define VRS_ASYNC_DISKFILE_SUPPORTED() false
 
#endif
 
class AtomicDiskFile : public DiskFile {
 public:
  ~AtomicDiskFile() override;
 
  int create(const string& newFilePath, const map<string, string>& options = {}) override;
  int close() override;
 
  void abort();
 
 private:
  string finalName_;
};
 
} // namespace vrs