ob_manifest.h

/* Copyright (c) 2021 OceanBase and/or its affiliates. All rights reserved.
   miniob is licensed under Mulan PSL v2.
   You can use this software according to the terms and conditions of the Mulan PSL v2.
   You may obtain a copy of Mulan PSL v2 at:
            http://license.coscl.org.cn/MulanPSL2
   THIS SOFTWARE IS PROVIDED ON AN "AS IS" BASIS, WITHOUT WARRANTIES OF ANY KIND,
   EITHER EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO NON-INFRINGEMENT,
   MERCHANTABILITY OR FIT FOR A PARTICULAR PURPOSE.
   See the Mulan PSL v2 for more details. */
//
// Created by Ping Xu(haibarapink@gmail.com) on 2025/1/24.
//
#pragma once
 
#include "json/json.h"
#include "common/lang/filesystem.h"
#include "common/lang/string_view.h"
#include "common/log/log.h"
#include "common/sys/rc.h"
#include "oblsm/ob_lsm_define.h"
#include "oblsm/util/ob_file_writer.h"
#include "oblsm/util/ob_file_reader.h"
 
namespace oceanbase {
 
class JsonConverter
{
public:
  template <typename T>
  static Json::Value to_json(const T &t)
  {
    return t.to_json();
  }
 
  template <typename T>
  static RC from_json(const Json::Value &v, T &t)
  {
    RC rc = t.from_json(v);
    return rc;
  }
};
 
template <>
inline Json::Value JsonConverter::to_json<CompactionType>(const CompactionType &type)
{
  int         type_as_int = static_cast<int>(type);
  Json::Value res{type_as_int};
  return res;
}
 
template <>
inline RC JsonConverter::from_json<CompactionType>(const Json::Value &v, CompactionType &type)
{
  int type_as_int = -1;
  if (v.isInt()) {
    type_as_int = v.asInt();
  } else {
    return RC::INVALID_ARGUMENT;
  }
 
  type = static_cast<CompactionType>(type_as_int);
  return RC::SUCCESS;
}
 
struct ObManifestSSTableInfo
{
  int sstable_id;  
  int level;       
 
  ObManifestSSTableInfo(int sstable_id_, int level_) : sstable_id(sstable_id_), level(level_) {}
 
  ObManifestSSTableInfo() : sstable_id(0), level(0) {}
 
  bool operator==(const ObManifestSSTableInfo &rhs) const { return sstable_id == rhs.sstable_id && level == rhs.level; }
 
  Json::Value to_json() const
  {
    Json::Value v;
    v["sstable_id"] = sstable_id;
    v["level"]      = level;
    return v;
  }
 
  RC from_json(const Json::Value &v);
};
 
class ObManifestCompaction
{
public:
  CompactionType                     compaction_type;      
  std::vector<ObManifestSSTableInfo> deleted_tables;       
  std::vector<ObManifestSSTableInfo> added_tables;         
  uint64_t                           sstable_sequence_id;  
  uint64_t                           seq_id;               
 
  static string record_type() { return "ObManifestCompaction"; }
 
  bool operator==(const ObManifestCompaction &rhs) const
  {
    return compaction_type == rhs.compaction_type && deleted_tables == rhs.deleted_tables &&
           added_tables == rhs.added_tables && sstable_sequence_id == rhs.sstable_sequence_id && seq_id == rhs.seq_id;
  }
 
  Json::Value to_json() const;
 
  RC from_json(const Json::Value &v);
};
 
class ObManifestSnapshot
{
public:
  std::vector<std::vector<uint64_t>> sstables;         
  uint64_t                           seq;              
  uint64_t                           sstable_id;       
  CompactionType                     compaction_type;  
 
  static string record_type() { return "ObManifestSnapshot"; }
 
  bool operator==(const ObManifestSnapshot &rhs) const
  {
    return sstables == rhs.sstables && seq == rhs.seq && sstable_id == rhs.sstable_id &&
           compaction_type == rhs.compaction_type;
  }
 
  Json::Value to_json() const;
 
  RC from_json(const Json::Value &v);
};
 
class ObManifestNewMemtable
{
public:
  uint64_t memtable_id;  
 
  static string record_type() { return "ObManifestNewMemtable"; }
 
  bool operator==(const ObManifestNewMemtable &rhs) const { return memtable_id == rhs.memtable_id; }
 
  Json::Value to_json() const;
 
  RC from_json(const Json::Value &v);
};
 
class ObManifest
{
public:
  ObManifest(const std::string &path) : path_(filesystem::path(path)) { current_path_ = path_ / "CURRENT"; }
 
  RC open();
 
  template <typename T>
  RC push(const T &data)
  {
    static_assert(std::is_same<T, ObManifestCompaction>::value || std::is_same<T, ObManifestSnapshot>::value ||
                      std::is_same<T, ObManifestNewMemtable>::value,
        "push() only supports ObManifestCompaction ,ObManifestNewMemtable and ObManifestSnapshot types.");
    Json::Value json = JsonConverter::to_json(data);
    string      str  = json.toStyledString();
    size_t      len  = str.size();
    RC          rc   = writer_->write(string_view{reinterpret_cast<char *>(&len), sizeof(len)});
    if (OB_FAIL(rc)) {
      LOG_WARN("Failed to push record into manifest file %s, rc %s", writer_->file_name().c_str(), strrc(rc));
      return rc;
    }
    rc = writer_->write(str);
    if (OB_FAIL(rc)) {
      LOG_WARN("Failed to push record into manifest file %s,  rc %s", writer_->file_name().c_str(), strrc(rc));
      return rc;
    }
    rc = writer_->flush();
    if (OB_FAIL(rc)) {
      LOG_WARN("Failed to flush data of manifest file %s, rc %s", writer_->file_name().c_str(), strrc(rc));
      return rc;
    }
    return rc;
  }
 
  RC redirect(const ObManifestSnapshot &snapshot, const ObManifestNewMemtable &memtable);
 
  RC recover(std::unique_ptr<ObManifestSnapshot> &snapshot_record,
      std::unique_ptr<ObManifestNewMemtable> &memtbale_record, std::vector<ObManifestCompaction> &compactions);
 
  uint64_t latest_seq{0};  
 
  friend class ObManifestTester;
 
private:
  string get_manifest_file_path(string path, uint64_t mf_seq)
  {
    return filesystem::path(path) / (std::to_string(mf_seq) + MANIFEST_SUFFIX);
  }
 
private:
  filesystem::path path_;          
  filesystem::path current_path_;  
  uint64_t         mf_seq_;        
 
  std::unique_ptr<ObFileWriter> writer_;  
  std::unique_ptr<ObFileReader> reader_;  
};
 
}  // namespace oceanbase