ceph/src/rgw/driver/immutable_config/store.h

   1 // vim: ts=8 sw=2 smarttab ft=cpp
   2
   3 /*
   4  * Ceph - scalable distributed file system
   5  *
   6  * Copyright (C) 2022 Red Hat, Inc.
   7  *
   8  * This is free software; you can redistribute it and/or
   9  * modify it under the terms of the GNU Lesser General Public
  10  * License version 2.1, as published by the Free Software
  11  * Foundation. See file COPYING.
  12  *
  13  */
  14
  15 #pragma once
  16
  17 #include "rgw_sal_config.h"
  18
  19 namespace rgw::sal {
  20
  21 /// A read-only ConfigStore that serves the given default zonegroup and zone.
  22 class ImmutableConfigStore : public ConfigStore {
  23  public:
  24   explicit ImmutableConfigStore(const RGWZoneGroup& zonegroup,
  25                                 const RGWZoneParams& zone,
  26                                 const RGWPeriodConfig& period_config);
  27
  28   // Realm
  29   virtual int write_default_realm_id(const DoutPrefixProvider* dpp,
  30                                      optional_yield y, bool exclusive,
  31                                      std::string_view realm_id) override;
  32   virtual int read_default_realm_id(const DoutPrefixProvider* dpp,
  33                                     optional_yield y,
  34                                     std::string& realm_id) override;
  35   virtual int delete_default_realm_id(const DoutPrefixProvider* dpp,
  36                                       optional_yield y) override;
  37
  38   virtual int create_realm(const DoutPrefixProvider* dpp,
  39                            optional_yield y, bool exclusive,
  40                            const RGWRealm& info,
  41                            std::unique_ptr<RealmWriter>* writer) override;
  42   virtual int read_realm_by_id(const DoutPrefixProvider* dpp,
  43                                optional_yield y,
  44                                std::string_view realm_id,
  45                                RGWRealm& info,
  46                                std::unique_ptr<RealmWriter>* writer) override;
  47   virtual int read_realm_by_name(const DoutPrefixProvider* dpp,
  48                                  optional_yield y,
  49                                  std::string_view realm_name,
  50                                  RGWRealm& info,
  51                                  std::unique_ptr<RealmWriter>* writer) override;
  52   virtual int read_default_realm(const DoutPrefixProvider* dpp,
  53                                  optional_yield y,
  54                                  RGWRealm& info,
  55                                  std::unique_ptr<RealmWriter>* writer) override;
  56   virtual int read_realm_id(const DoutPrefixProvider* dpp,
  57                             optional_yield y, std::string_view realm_name,
  58                             std::string& realm_id) override;
  59   virtual int realm_notify_new_period(const DoutPrefixProvider* dpp,
  60                                       optional_yield y,
  61                                       const RGWPeriod& period) override;
  62   virtual int list_realm_names(const DoutPrefixProvider* dpp,
  63                                optional_yield y, const std::string& marker,
  64                                std::span<std::string> entries,
  65                                ListResult<std::string>& result) override;
  66
  67   // Period
  68   virtual int create_period(const DoutPrefixProvider* dpp,
  69                             optional_yield y, bool exclusive,
  70                             const RGWPeriod& info) override;
  71   virtual int read_period(const DoutPrefixProvider* dpp,
  72                           optional_yield y, std::string_view period_id,
  73                           std::optional<uint32_t> epoch, RGWPeriod& info) override;
  74   virtual int delete_period(const DoutPrefixProvider* dpp,
  75                             optional_yield y,
  76                             std::string_view period_id) override;
  77   virtual int list_period_ids(const DoutPrefixProvider* dpp,
  78                               optional_yield y, const std::string& marker,
  79                               std::span<std::string> entries,
  80                               ListResult<std::string>& result) override;
  81
  82   // ZoneGroup
  83   virtual int write_default_zonegroup_id(const DoutPrefixProvider* dpp,
  84                                          optional_yield y, bool exclusive,
  85                                          std::string_view realm_id,
  86                                          std::string_view zonegroup_id) override;
  87   virtual int read_default_zonegroup_id(const DoutPrefixProvider* dpp,
  88                                         optional_yield y,
  89                                         std::string_view realm_id,
  90                                         std::string& zonegroup_id) override;
  91   virtual int delete_default_zonegroup_id(const DoutPrefixProvider* dpp,
  92                                           optional_yield y,
  93                                           std::string_view realm_id) override;
  94
  95   virtual int create_zonegroup(const DoutPrefixProvider* dpp,
  96                                optional_yield y, bool exclusive,
  97                                const RGWZoneGroup& info,
  98                                std::unique_ptr<ZoneGroupWriter>* writer) override;
  99   virtual int read_zonegroup_by_id(const DoutPrefixProvider* dpp,
 100                                    optional_yield y,
 101                                    std::string_view zonegroup_id,
 102                                    RGWZoneGroup& info,
 103                                    std::unique_ptr<ZoneGroupWriter>* writer) override;
 104   virtual int read_zonegroup_by_name(const DoutPrefixProvider* dpp,
 105                                      optional_yield y,
 106                                      std::string_view zonegroup_name,
 107                                      RGWZoneGroup& info,
 108                                      std::unique_ptr<ZoneGroupWriter>* writer) override;
 109   virtual int read_default_zonegroup(const DoutPrefixProvider* dpp,
 110                                      optional_yield y,
 111                                      std::string_view realm_id,
 112                                      RGWZoneGroup& info,
 113                                      std::unique_ptr<ZoneGroupWriter>* writer) override;
 114   virtual int list_zonegroup_names(const DoutPrefixProvider* dpp,
 115                                    optional_yield y, const std::string& marker,
 116                                    std::span<std::string> entries,
 117                                    ListResult<std::string>& result) override;
 118
 119   // Zone
 120   virtual int write_default_zone_id(const DoutPrefixProvider* dpp,
 121                                     optional_yield y, bool exclusive,
 122                                     std::string_view realm_id,
 123                                     std::string_view zone_id) override;
 124   virtual int read_default_zone_id(const DoutPrefixProvider* dpp,
 125                                    optional_yield y,
 126                                    std::string_view realm_id,
 127                                    std::string& zone_id) override;
 128   virtual int delete_default_zone_id(const DoutPrefixProvider* dpp,
 129                                      optional_yield y,
 130                                      std::string_view realm_id) override;
 131
 132   virtual int create_zone(const DoutPrefixProvider* dpp,
 133                           optional_yield y, bool exclusive,
 134                           const RGWZoneParams& info,
 135                           std::unique_ptr<ZoneWriter>* writer) override;
 136   virtual int read_zone_by_id(const DoutPrefixProvider* dpp,
 137                               optional_yield y,
 138                               std::string_view zone_id,
 139                               RGWZoneParams& info,
 140                               std::unique_ptr<ZoneWriter>* writer) override;
 141   virtual int read_zone_by_name(const DoutPrefixProvider* dpp,
 142                                 optional_yield y,
 143                                 std::string_view zone_name,
 144                                 RGWZoneParams& info,
 145                                 std::unique_ptr<ZoneWriter>* writer) override;
 146   virtual int read_default_zone(const DoutPrefixProvider* dpp,
 147                                 optional_yield y,
 148                                 std::string_view realm_id,
 149                                 RGWZoneParams& info,
 150                                 std::unique_ptr<ZoneWriter>* writer) override;
 151   virtual int list_zone_names(const DoutPrefixProvider* dpp,
 152                               optional_yield y, const std::string& marker,
 153                               std::span<std::string> entries,
 154                               ListResult<std::string>& result) override;
 155
 156   // PeriodConfig
 157   virtual int read_period_config(const DoutPrefixProvider* dpp,
 158                                  optional_yield y,
 159                                  std::string_view realm_id,
 160                                  RGWPeriodConfig& info) override;
 161   virtual int write_period_config(const DoutPrefixProvider* dpp,
 162                                   optional_yield y, bool exclusive,
 163                                   std::string_view realm_id,
 164                                   const RGWPeriodConfig& info) override;
 165
 166  private:
 167   const RGWZoneGroup zonegroup;
 168   const RGWZoneParams zone;
 169   const RGWPeriodConfig period_config;
 170 }; // ImmutableConfigStore
 171
 172
 173 /// ImmutableConfigStore factory function
 174 auto create_immutable_config_store(const DoutPrefixProvider* dpp,
 175                                    const RGWZoneGroup& zonegroup,
 176                                    const RGWZoneParams& zone,
 177                                    const RGWPeriodConfig& period_config)
 178   -> std::unique_ptr<ConfigStore>;
 179
 180 } // namespace rgw::sal