ClickHouse · alesapin · Jul 31, 2020 · May 24, 2020 · May 24, 2020 · May 25, 2020
diff --git a/programs/copier/ClusterCopierApp.cpp b/programs/copier/ClusterCopierApp.cpp
@@ -106,7 +106,7 @@ void ClusterCopierApp::mainImpl()
 
     context->setConfig(loaded_config.configuration);
     context->setApplicationType(Context::ApplicationType::LOCAL);
-    context->setPath(process_path);
+    context->setPath(process_path + "/");
 
     registerFunctions();
     registerAggregateFunctions();

diff --git a/src/Common/ErrorCodes.cpp b/src/Common/ErrorCodes.cpp
@@ -497,6 +497,9 @@ namespace ErrorCodes
     extern const int CANNOT_CONNECT_RABBITMQ = 530;
     extern const int CANNOT_FSTAT = 531;
     extern const int LDAP_ERROR = 532;
+    extern const int INCONSISTENT_RESERVATIONS = 533;
+    extern const int NO_RESERVATIONS_PROVIDED = 534;
+    extern const int UNKNOWN_RAID_TYPE = 535;
 
     extern const int KEEPER_EXCEPTION = 999;
     extern const int POCO_EXCEPTION = 1000;

diff --git a/src/Disks/IDisk.h b/src/Disks/IDisk.h
@@ -25,6 +25,7 @@ using DiskDirectoryIteratorPtr = std::unique_ptr<IDiskDirectoryIterator>;
 
 class IReservation;
 using ReservationPtr = std::unique_ptr<IReservation>;
+using Reservations = std::vector<ReservationPtr>;
 
 class ReadBufferFromFileBase;
 class WriteBufferFromFileBase;

diff --git a/src/Disks/IVolume.cpp b/src/Disks/IVolume.cpp
@@ -10,10 +10,32 @@ namespace DB
 namespace ErrorCodes
 {
     extern const int EXCESSIVE_ELEMENT_IN_CONFIG;
+    extern const int INCONSISTENT_RESERVATIONS;
+    extern const int NO_RESERVATIONS_PROVIDED;
+    extern const int UNKNOWN_VOLUME_TYPE;
+}
+
+String volumeTypeToString(VolumeType type)
+{
+    switch (type)
+    {
+        case VolumeType::JBOD:
+            return "JBOD";
+        case VolumeType::RAID1:
+            return "RAID1";
+        case VolumeType::SINGLE_DISK:
+            return "SINGLE_DISK";
+        case VolumeType::UNKNOWN:
+            return "UNKNOWN";
+    }
+    throw Exception("Unknown volume type, please add it to DB::volumeTypeToString", ErrorCodes::UNKNOWN_VOLUME_TYPE);
 }
 
 IVolume::IVolume(
-    String name_, const Poco::Util::AbstractConfiguration & config, const String & config_prefix, DiskSelectorPtr disk_selector)
+    String name_,
+    const Poco::Util::AbstractConfiguration & config,
+    const String & config_prefix,
+    DiskSelectorPtr disk_selector)
     : name(std::move(name_))
 {
     Poco::Util::AbstractConfiguration::Keys keys;
@@ -40,4 +62,43 @@ UInt64 IVolume::getMaxUnreservedFreeSpace() const
     return res;
 }
 
+MultiDiskReservation::MultiDiskReservation(Reservations & reservations_, UInt64 size_)
+    : reservations(std::move(reservations_))
+    , size(size_)
+{
+    if (reservations.empty())
+    {
+        throw Exception("At least one reservation must be provided to MultiDiskReservation", ErrorCodes::NO_RESERVATIONS_PROVIDED);
+    }
+
+    for (auto & reservation : reservations)
+    {
+        if (reservation->getSize() != size_)
+        {
+            throw Exception("Reservations must have same size", ErrorCodes::INCONSISTENT_RESERVATIONS);
+        }
+    }
+}
+
+Disks MultiDiskReservation::getDisks() const
+{
+    Disks res;
+    res.reserve(reservations.size());
+    for (const auto & reservation : reservations)
+    {
+        res.push_back(reservation->getDisk());
+    }
+    return res;
+}
+
+void MultiDiskReservation::update(UInt64 new_size)
+{
+    for (auto & reservation : reservations)
+    {
+        reservation->update(new_size);
+    }
+    size = new_size;
+}
+
+
 }
diff --git a/src/Disks/IVolume.h b/src/Disks/IVolume.h
@@ -11,10 +11,13 @@ namespace DB
 enum class VolumeType
 {
     JBOD,
+    RAID1,
     SINGLE_DISK,
     UNKNOWN
 };
 
+String volumeTypeToString(VolumeType t);
+
 class IVolume;
 using VolumePtr = std::shared_ptr<IVolume>;
 using Volumes = std::vector<VolumePtr>;
@@ -33,7 +36,10 @@ using Volumes = std::vector<VolumePtr>;
 class IVolume : public Space
 {
 public:
-    IVolume(String name_, Disks disks_): disks(std::move(disks_)), name(name_)
+    IVolume(String name_, Disks disks_, size_t max_data_part_size_ = 0)
+        : disks(std::move(disks_))
+        , name(name_)
+        , max_data_part_size(max_data_part_size_)
     {
     }
 
@@ -53,12 +59,35 @@ class IVolume : public Space
     /// Return biggest unreserved space across all disks
     UInt64 getMaxUnreservedFreeSpace() const;
 
-    DiskPtr getDisk(size_t i = 0) const { return disks[i]; }
+    DiskPtr getDisk() const { return getDisk(0); }
+    virtual DiskPtr getDisk(size_t i) const { return disks[i]; }
     const Disks & getDisks() const { return disks; }
 
 protected:
     Disks disks;
     const String name;
+
+public:
+    /// Max size of reservation, zero means unlimited size
+    UInt64 max_data_part_size = 0;
+};
+
+/// Reservation for multiple disks at once. Can be used in RAID1 implementation.
+class MultiDiskReservation : public IReservation
+{
+public:
+    MultiDiskReservation(Reservations & reservations, UInt64 size);
+
+    UInt64 getSize() const override { return size; }
+
+    DiskPtr getDisk(size_t i) const override { return reservations[i]->getDisk(); }
+
+    Disks getDisks() const override;
+
+    void update(UInt64 new_size) override;
+private:
+    Reservations reservations;
+    UInt64 size;
 };
 
 }
diff --git a/src/Disks/SingleDiskVolume.h b/src/Disks/SingleDiskVolume.h
@@ -22,5 +22,6 @@ class SingleDiskVolume : public IVolume
 };
 
 using VolumeSingleDiskPtr = std::shared_ptr<SingleDiskVolume>;
+using VolumesSingleDiskPtr = std::vector<VolumeSingleDiskPtr>;
 
 }
diff --git a/src/Disks/StoragePolicy.cpp b/src/Disks/StoragePolicy.cpp
@@ -71,7 +71,7 @@ StoragePolicy::StoragePolicy(
 }
 
 
-StoragePolicy::StoragePolicy(String name_, VolumesJBOD volumes_, double move_factor_)
+StoragePolicy::StoragePolicy(String name_, Volumes volumes_, double move_factor_)
     : volumes(std::move(volumes_)), name(std::move(name_)), move_factor(move_factor_)
 {
     if (volumes.empty())
@@ -204,15 +204,15 @@ void StoragePolicy::checkCompatibleWith(const StoragePolicyPtr & new_storage_pol
     for (const auto & volume : getVolumes())
     {
         if (new_volume_names.count(volume->getName()) == 0)
-            throw Exception("New storage policy shall contain volumes of old one", ErrorCodes::LOGICAL_ERROR);
+            throw Exception("New storage policy shall contain volumes of old one", ErrorCodes::BAD_ARGUMENTS);
 
         std::unordered_set<String> new_disk_names;
         for (const auto & disk : new_storage_policy->getVolumeByName(volume->getName())->getDisks())
             new_disk_names.insert(disk->getName());
 
         for (const auto & disk : volume->getDisks())
             if (new_disk_names.count(disk->getName()) == 0)
-                throw Exception("New storage policy shall contain disks of old one", ErrorCodes::LOGICAL_ERROR);
+                throw Exception("New storage policy shall contain disks of old one", ErrorCodes::BAD_ARGUMENTS);
     }
 }
 
@@ -257,7 +257,7 @@ StoragePolicySelector::StoragePolicySelector(
     {
         auto default_volume = std::make_shared<VolumeJBOD>(default_volume_name, std::vector<DiskPtr>{disks->get(default_disk_name)}, 0);
 
-        auto default_policy = std::make_shared<StoragePolicy>(default_storage_policy_name, VolumesJBOD{default_volume}, 0.0);
+        auto default_policy = std::make_shared<StoragePolicy>(default_storage_policy_name, Volumes{default_volume}, 0.0);
         policies.emplace(default_storage_policy_name, default_policy);
     }
 }

diff --git a/src/Disks/StoragePolicy.h b/src/Disks/StoragePolicy.h
@@ -4,6 +4,7 @@
 #include <Disks/IDisk.h>
 #include <Disks/IVolume.h>
 #include <Disks/VolumeJBOD.h>
+#include <Disks/VolumeRAID1.h>
 #include <Disks/SingleDiskVolume.h>
 #include <IO/WriteHelpers.h>
 #include <Common/CurrentMetrics.h>
@@ -33,7 +34,7 @@ class StoragePolicy
 public:
     StoragePolicy(String name_, const Poco::Util::AbstractConfiguration & config, const String & config_prefix, DiskSelectorPtr disks);
 
-    StoragePolicy(String name_, VolumesJBOD volumes_, double move_factor_);
+    StoragePolicy(String name_, Volumes volumes_, double move_factor_);
 
     bool isDefaultPolicy() const;
 
@@ -65,16 +66,16 @@ class StoragePolicy
     /// Do not use this function when it is possible to predict size.
     ReservationPtr makeEmptyReservationOnLargestDisk() const;
 
-    const VolumesJBOD & getVolumes() const { return volumes; }
+    const Volumes & getVolumes() const { return volumes; }
 
     /// Returns number [0., 1.] -- fraction of free space on disk
     /// which should be kept with help of background moves
     double getMoveFactor() const { return move_factor; }
 
     /// Get volume by index from storage_policy
-    VolumeJBODPtr getVolume(size_t i) const { return (i < volumes_names.size() ? volumes[i] : VolumeJBODPtr()); }
+    VolumePtr getVolume(size_t i) const { return (i < volumes_names.size() ? volumes[i] : VolumePtr()); }
 
-    VolumeJBODPtr getVolumeByName(const String & volume_name) const
+    VolumePtr getVolumeByName(const String & volume_name) const
     {
         auto it = volumes_names.find(volume_name);
         if (it == volumes_names.end())
@@ -86,7 +87,7 @@ class StoragePolicy
     void checkCompatibleWith(const StoragePolicyPtr & new_storage_policy) const;
 
 private:
-    VolumesJBOD volumes;
+    Volumes volumes;
     const String name;
     std::map<String, size_t> volumes_names;
 

diff --git a/src/Disks/VolumeJBOD.cpp b/src/Disks/VolumeJBOD.cpp
@@ -17,8 +17,8 @@ VolumeJBOD::VolumeJBOD(
     String name_,
     const Poco::Util::AbstractConfiguration & config,
     const String & config_prefix,
-    DiskSelectorPtr disk_selector
-) : IVolume(name_, config, config_prefix, disk_selector)
+    DiskSelectorPtr disk_selector)
+    : IVolume(name_, config, config_prefix, disk_selector)
 {
     Poco::Logger * logger = &Poco::Logger::get("StorageConfiguration");
 
@@ -55,7 +55,7 @@ VolumeJBOD::VolumeJBOD(
         LOG_WARNING(logger, "Volume {} max_data_part_size is too low ({} < {})", backQuote(name), ReadableSize(max_data_part_size), ReadableSize(MIN_PART_SIZE));
 }
 
-DiskPtr VolumeJBOD::getNextDisk()
+DiskPtr VolumeJBOD::getDisk(size_t /* index */) const
 {
     size_t start_from = last_used.fetch_add(1u, std::memory_order_relaxed);
     size_t index = start_from % disks.size();
@@ -64,7 +64,8 @@ DiskPtr VolumeJBOD::getNextDisk()
 
 ReservationPtr VolumeJBOD::reserve(UInt64 bytes)
 {
-    /// This volume can not store files which size greater than max_data_part_size
+    /// This volume can not store data which size is greater than `max_data_part_size`
+    /// to ensure that parts of size greater than that go to another volume(s).
 
     if (max_data_part_size != 0 && bytes > max_data_part_size)
         return {};

diff --git a/src/Disks/VolumeJBOD.h b/src/Disks/VolumeJBOD.h
@@ -14,7 +14,7 @@ class VolumeJBOD : public IVolume
 {
 public:
     VolumeJBOD(String name_, Disks disks_, UInt64 max_data_part_size_)
-        : IVolume(name_, disks_), max_data_part_size(max_data_part_size_)
+        : IVolume(name_, disks_, max_data_part_size_)
     {
     }
 
@@ -27,19 +27,17 @@ class VolumeJBOD : public IVolume
 
     VolumeType getType() const override { return VolumeType::JBOD; }
 
-    /// Next disk (round-robin)
+    /// Always returns next disk (round-robin), ignores argument.
     ///
     /// - Used with policy for temporary data
     /// - Ignores all limitations
     /// - Shares last access with reserve()
-    DiskPtr getNextDisk();
+    DiskPtr getDisk(size_t index) const override;
 
     /// Uses Round-robin to choose disk for reservation.
     /// Returns valid reservation or nullptr if there is no space left on any disk.
     ReservationPtr reserve(UInt64 bytes) override;
 
-    /// Max size of reservation
-    UInt64 max_data_part_size = 0;
 private:
     mutable std::atomic<size_t> last_used = 0;
 };

diff --git a/src/Disks/VolumeRAID1.cpp b/src/Disks/VolumeRAID1.cpp
@@ -0,0 +1,29 @@
+#include "VolumeRAID1.h"
+
+#include <Common/StringUtils/StringUtils.h>
+#include <Common/quoteString.h>
+
+namespace DB
+{
+
+ReservationPtr VolumeRAID1::reserve(UInt64 bytes)
+{
+    /// This volume can not store data which size is greater than `max_data_part_size`
+    /// to ensure that parts of size greater than that go to another volume(s).
+
+    if (max_data_part_size != 0 && bytes > max_data_part_size)
+        return {};
+
+    Reservations res(disks.size());
+    for (size_t i = 0; i < disks.size(); ++i)
+    {
+        res[i] = disks[i]->reserve(bytes);
+
+        if (!res[i])
+            return {};
+    }
+
+    return std::make_unique<MultiDiskReservation>(res, bytes);
+}
+
+}
diff --git a/src/Disks/VolumeRAID1.h b/src/Disks/VolumeRAID1.h
@@ -0,0 +1,37 @@
+#pragma once
+
+#include <Disks/createVolume.h>
+#include <Disks/VolumeJBOD.h>
+
+namespace DB
+{
+
+/// Volume which reserserves space on each underlying disk.
+///
+/// NOTE: Just interface implementation, doesn't used in codebase,
+/// also not available for user.
+class VolumeRAID1 : public VolumeJBOD
+{
+public:
+    VolumeRAID1(String name_, Disks disks_, UInt64 max_data_part_size_)
+        : VolumeJBOD(name_, disks_, max_data_part_size_)
+    {
+    }
+
+    VolumeRAID1(
+        String name_,
+        const Poco::Util::AbstractConfiguration & config,
+        const String & config_prefix,
+        DiskSelectorPtr disk_selector)
+        : VolumeJBOD(name_, config, config_prefix, disk_selector)
+    {
+    }
+
+    VolumeType getType() const override { return VolumeType::RAID1; }
+
+    ReservationPtr reserve(UInt64 bytes) override;
+};
+
+using VolumeRAID1Ptr = std::shared_ptr<VolumeRAID1>;
+
+}
-Original file line number
+Diff line change
@@ Expand Up / @@ -22,5 +22,6 @@ class SingleDiskVolume : public IVolume @@
     };
     using VolumeSingleDiskPtr = std::shared_ptr<SingleDiskVolume>;
+    using VolumesSingleDiskPtr = std::vector<VolumeSingleDiskPtr>;
     }