m_mirror_watcher->is_failed();
}
- utime_t get_failed_ts() {
+ monotime get_failed_ts() {
std::scoped_lock locker(m_lock);
if (m_instance_watcher) {
return m_instance_watcher->get_failed_ts();
return m_mirror_watcher->get_failed_ts();
}
- return utime_t();
+ return clock::now();
}
bool is_blocklisted() {
return is_blocklisted(locker);
}
- utime_t get_blocklisted_ts() {
+ monotime get_blocklisted_ts() {
std::scoped_lock locker(m_lock);
if (m_instance_watcher) {
return m_instance_watcher->get_blocklisted_ts();
return m_mirror_watcher->get_blocklisted_ts();
}
- return utime_t();
+ return clock::now();
}
Peers get_peers() {
dout(0) << ": client blocklisted" <<dendl;
std::scoped_lock locker(m_lock);
m_blocklisted = true;
- m_blocklisted_ts = ceph_clock_now();
+ m_blocklisted_ts = clock::now();
} else if (r == -ENOENT) {
derr << ": mirroring object deleted" << dendl;
m_failed = true;
- m_failed_ts = ceph_clock_now();
+ m_failed_ts = clock::now();
} else if (r < 0) {
derr << ": rewatch error: " << cpp_strerror(r) << dendl;
m_failed = true;
- m_failed_ts = ceph_clock_now();
+ m_failed_ts = clock::now();
}
}
#include "include/Context.h"
#include "include/rados/librados.hpp"
#include "Watcher.h"
+#include "Types.h"
class ContextWQ;
return m_blocklisted;
}
- utime_t get_blocklisted_ts() {
+ monotime get_blocklisted_ts() {
std::scoped_lock locker(m_lock);
return m_blocklisted_ts;
}
return m_failed;
}
- utime_t get_failed_ts() {
+ monotime get_failed_ts() {
std::scoped_lock locker(m_lock);
return m_failed_ts;
}
bool m_blocklisted = false;
bool m_failed = false;
- utime_t m_blocklisted_ts;
- utime_t m_failed_ts;
+ monotime m_blocklisted_ts;
+ monotime m_failed_ts;
void create_instance();
void handle_create_instance(int r);
#undef dout_prefix
#define dout_prefix *_dout << "cephfs::mirror::Mirror " << __func__
+using namespace std::chrono;
+
// Performance Counters
enum {
l_cephfs_mirror_first = 4000,
return r;
}
- r = m_monc->authenticate(std::chrono::duration<double>(m_cct->_conf.get_val<std::chrono::seconds>("client_mount_timeout")).count());
+ r = m_monc->authenticate(duration<double>(m_cct->_conf.get_val<seconds>("client_mount_timeout")).count());
if (r < 0) {
derr << ": failed to authenticate to monitor: " << cpp_strerror(r) << dendl;
return r;
void Mirror::update_fs_mirrors() {
dout(20) << dendl;
- auto now = ceph_clock_now();
- double blocklist_interval = g_ceph_context->_conf.get_val<std::chrono::seconds>
- ("cephfs_mirror_restart_mirror_on_blocklist_interval").count();
- double failed_interval = g_ceph_context->_conf.get_val<std::chrono::seconds>
- ("cephfs_mirror_restart_mirror_on_failure_interval").count();
+ seconds blocklist_interval = g_ceph_context->_conf.get_val<seconds>
+ ("cephfs_mirror_restart_mirror_on_blocklist_interval");
+ seconds failed_interval = g_ceph_context->_conf.get_val<seconds>
+ ("cephfs_mirror_restart_mirror_on_failure_interval");
{
std::scoped_lock locker(m_lock);
for (auto &[filesystem, mirror_action] : m_mirror_actions) {
auto failed_restart = mirror_action.fs_mirror && mirror_action.fs_mirror->is_failed() &&
- (failed_interval > 0 && (mirror_action.fs_mirror->get_failed_ts() - now) > failed_interval);
+ (failed_interval.count() > 0 && duration_cast<seconds>(mirror_action.fs_mirror->get_failed_ts() - clock::now()) > failed_interval);
auto blocklisted_restart = mirror_action.fs_mirror && mirror_action.fs_mirror->is_blocklisted() &&
- (blocklist_interval > 0 && (mirror_action.fs_mirror->get_blocklisted_ts() - now) > blocklist_interval);
+ (blocklist_interval.count() > 0 && duration_cast<seconds>(mirror_action.fs_mirror->get_blocklisted_ts() - clock::now()) > blocklist_interval);
if (!mirror_action.action_in_progress && !_is_restarting(filesystem)) {
if (failed_restart || blocklisted_restart) {
m_timer_task = nullptr;
update_fs_mirrors();
});
- double after = g_ceph_context->_conf.get_val<std::chrono::seconds>
+ double after = g_ceph_context->_conf.get_val<seconds>
("cephfs_mirror_action_update_interval").count();
dout(20) << ": scheduling fs mirror update (" << m_timer_task << ") after "
<< after << " seconds" << dendl;
#include "aio_utils.h"
#include "MirrorWatcher.h"
#include "FSMirror.h"
-#include "Types.h"
#define dout_context g_ceph_context
#define dout_subsys ceph_subsys_cephfs_mirror
dout(0) << ": client blocklisted" <<dendl;
std::scoped_lock locker(m_lock);
m_blocklisted = true;
- m_blocklisted_ts = ceph_clock_now();
+ m_blocklisted_ts = clock::now();
} else if (r == -ENOENT) {
derr << ": mirroring object deleted" << dendl;
m_failed = true;
- m_failed_ts = ceph_clock_now();
+ m_failed_ts = clock::now();
} else if (r < 0) {
derr << ": rewatch error: " << cpp_strerror(r) << dendl;
m_failed = true;
- m_failed_ts = ceph_clock_now();
+ m_failed_ts = clock::now();
}
}
#include "include/Context.h"
#include "include/rados/librados.hpp"
#include "Watcher.h"
+#include "Types.h"
class ContextWQ;
class Messenger;
return m_blocklisted;
}
- utime_t get_blocklisted_ts() {
+ monotime get_blocklisted_ts() {
std::scoped_lock locker(m_lock);
return m_blocklisted_ts;
}
return m_failed;
}
- utime_t get_failed_ts() {
+ monotime get_failed_ts() {
std::scoped_lock locker(m_lock);
return m_failed_ts;
}
bool m_blocklisted = false;
bool m_failed = false;
- utime_t m_blocklisted_ts;
- utime_t m_failed_ts;
+ monotime m_blocklisted_ts;
+ monotime m_failed_ts;
void register_watcher();
void handle_register_watcher(int r);
void PeerReplayer::run(SnapshotReplayerThread *replayer) {
dout(10) << ": snapshot replayer=" << replayer << dendl;
- time last_directory_scan = clock::zero();
+ monotime last_directory_scan = clock::zero();
auto scan_interval = g_ceph_context->_conf.get_val<uint64_t>(
"cephfs_mirror_directory_scan_interval");
}
};
- using clock = ceph::coarse_mono_clock;
- using time = ceph::coarse_mono_time;
-
// stats sent to service daemon
struct ServiceDaemonStats {
uint64_t failed_dir_count = 0;
struct SnapSyncStat {
uint64_t nr_failures = 0; // number of consecutive failures
- boost::optional<time> last_failed; // lat failed timestamp
+ boost::optional<monotime> last_failed; // lat failed timestamp
bool failed = false; // hit upper cap for consecutive failures
boost::optional<std::pair<uint64_t, std::string>> last_synced_snap;
boost::optional<std::pair<uint64_t, std::string>> current_syncing_snap;
uint64_t synced_snap_count = 0;
uint64_t deleted_snap_count = 0;
uint64_t renamed_snap_count = 0;
- time last_synced = clock::zero();
+ monotime last_synced = clock::zero();
boost::optional<double> last_sync_duration;
};
// not a shared_ptr since the type is incomplete
typedef ceph_mount_info *MountRef;
+using clock = ceph::coarse_mono_clock;
+using monotime = ceph::coarse_mono_time;
} // namespace mirror
} // namespace cephfs