MAuth() : PaxosServiceMessage{CEPH_MSG_AUTH, 0}, protocol(0), monmap_epoch(0) { }
private:
- ~MAuth() override {}
+ ~MAuth() final {}
public:
std::string_view get_type_name() const override { return "auth"; }
result_bl = *bl;
}
private:
- ~MAuthReply() override {}
+ ~MAuthReply() final {}
public:
std::string_view get_type_name() const override { return "auth_reply"; }
MCacheExpire(int f) :
MMDSOp{MSG_MDS_CACHEEXPIRE},
from(f) { }
- ~MCacheExpire() override {}
+ ~MCacheExpire() final {}
public:
std::string_view get_type_name() const override { return "cache_expire";}
{
memset(&head, 0, sizeof(head));
}
- ~MClientCapRelease() override {}
+ ~MClientCapRelease() final {}
};
#endif
head.migrate_seq = mseq;
memset(&peer, 0, sizeof(peer));
}
- ~MClientCaps() override {}
+ ~MClientCaps() final {}
private:
file_layout_t layout;
h.last = sl;
h.duration_ms = 0;
}
- ~MClientLease() override {}
+ ~MClientLease() final {}
public:
std::string_view get_type_name() const override { return "client_lease"; }
MClientMetrics(std::vector<ClientMetricMessage> updates)
: SafeMessage(CEPH_MSG_CLIENT_METRICS, HEAD_VERSION, COMPAT_VERSION), updates(updates) {
}
- ~MClientMetrics() { }
+ ~MClientMetrics() final {}
public:
std::string_view get_type_name() const override {
SafeMessage{CEPH_MSG_CLIENT_QUOTA},
ino(0)
{}
- ~MClientQuota() override {}
+ ~MClientQuota() final {}
public:
std::string_view get_type_name() const override { return "client_quota"; }
SafeMessage{CEPH_MSG_CLIENT_RECLAIM, HEAD_VERSION, COMPAT_VERSION},
uuid(_uuid), flags(_flags) {}
private:
- ~MClientReclaim() override {}
+ ~MClientReclaim() final {}
std::string uuid;
uint32_t flags = 0;
result(r), epoch(e) {}
private:
- ~MClientReclaimReply() override {}
+ ~MClientReclaimReply() final {}
int32_t result;
epoch_t epoch;
private:
MClientReconnect() :
SafeMessage{CEPH_MSG_CLIENT_RECONNECT, HEAD_VERSION, COMPAT_VERSION} {}
- ~MClientReconnect() override {}
+ ~MClientReconnect() final {}
size_t cap_size = 0;
size_t realm_size = 0;
head.result = result;
head.safe = 1;
}
- ~MClientReply() override {}
+ ~MClientReply() final {}
public:
std::string_view get_type_name() const override { return "creply"; }
memset(&head, 0, sizeof(head));
head.op = op;
}
- ~MClientRequest() override {}
+ ~MClientRequest() final {}
public:
void set_mdsmap_epoch(epoch_t e) { head.mdsmap_epoch = e; }
ceph_assert(client_must_resend);
header.tid = t;
}
- ~MClientRequestForward() override {}
+ ~MClientRequestForward() final {}
public:
int get_dest_mds() const { return dest_mds; }
head.seq = 0;
st.encode_timeval(&head.stamp);
}
- ~MClientSession() override {}
+ ~MClientSession() final {}
public:
std::string_view get_type_name() const override { return "client_session"; }
memset(&head, 0, sizeof(head));
head.op = o;
}
- ~MClientSnap() override {}
+ ~MClientSnap() final {}
public:
std::string_view get_type_name() const override { return "client_snap"; }
fsid(f) { }
private:
- ~MCommand() override {}
+ ~MCommand() final {}
public:
std::string_view get_type_name() const override { return "command"; }
: Message{MSG_COMMAND_REPLY},
r(_r), rs(s) { }
private:
- ~MCommandReply() override {}
+ ~MCommandReply() final {}
public:
std::string_view get_type_name() const override { return "command_reply"; }
dirfrag(df),
dn(n),
is_primary(p) {}
- ~MDentryLink() override {}
+ ~MDentryLink() final {}
public:
std::string_view get_type_name() const override { return "dentry_link";}
MMDSOp(MSG_MDS_DENTRYUNLINK, HEAD_VERSION, COMPAT_VERSION),
dirfrag(df),
dn(n) {}
- ~MDentryUnlink() override {}
+ ~MDentryUnlink() final {}
public:
std::string_view get_type_name() const override { return "dentry_unlink";}
}
protected:
- ~MDirUpdate() {}
+ ~MDirUpdate() final {}
MDirUpdate() : MMDSOp(MSG_MDS_DIRUPDATE, HEAD_VERSION, COMPAT_VERSION) {}
MDirUpdate(mds_rank_t f,
dirfrag_t dirfrag,
want(want_path_),
want_base_dir(want_base_dir_),
path_locked(path_locked_) { }
- ~MDiscover() override {}
+ ~MDiscover() final {}
public:
std::string_view get_type_name() const override { return "Dis"; }
{
header.tid = 0;
}
- ~MDiscoverReply() override {}
+ ~MDiscoverReply() final {}
public:
std::string_view get_type_name() const override { return "discover_reply"; }
protected:
MExportCaps() :
MMDSOp{MSG_MDS_EXPORTCAPS, HEAD_VERSION, COMPAT_VERSION} {}
- ~MExportCaps() override {}
+ ~MExportCaps() final {}
public:
std::string_view get_type_name() const override { return "export_caps"; }
MMDSOp{MSG_MDS_EXPORTCAPSACK, HEAD_VERSION, COMPAT_VERSION} {}
MExportCapsAck(inodeno_t i) :
MMDSOp{MSG_MDS_EXPORTCAPSACK, HEAD_VERSION, COMPAT_VERSION}, ino(i) {}
- ~MExportCapsAck() override {}
+ ~MExportCapsAck() final {}
public:
std::string_view get_type_name() const override { return "export_caps_ack"; }
MMDSOp{MSG_MDS_EXPORTDIR}, dirfrag(df) {
set_tid(tid);
}
- ~MExportDir() override {}
+ ~MExportDir() final {}
public:
std::string_view get_type_name() const override { return "Ex"; }
MMDSOp{MSG_MDS_EXPORTDIRACK}, dirfrag(df) {
set_tid(tid);
}
- ~MExportDirAck() override {}
+ ~MExportDirAck() final {}
public:
std::string_view get_type_name() const override { return "ExAck"; }
MMDSOp{MSG_MDS_EXPORTDIRCANCEL, HEAD_VERSION, COMPAT_VERSION}, dirfrag(df) {
set_tid(tid);
}
- ~MExportDirCancel() override {}
+ ~MExportDirCancel() final {}
public:
std::string_view get_type_name() const override { return "ExCancel"; }
from(f), dirfrag(df), path(p), started(false) {
set_tid(tid);
}
- ~MExportDirDiscover() override {}
+ ~MExportDirDiscover() final {}
public:
std::string_view get_type_name() const override { return "ExDis"; }
dirfrag(df), success(s) {
set_tid(tid);
}
- ~MExportDirDiscoverAck() override {}
+ ~MExportDirDiscoverAck() final {}
public:
std::string_view get_type_name() const override { return "ExDisA"; }
MMDSOp{MSG_MDS_EXPORTDIRFINISH, HEAD_VERSION, COMPAT_VERSION}, dirfrag(df), last(l) {
set_tid(tid);
}
- ~MExportDirFinish() override {}
+ ~MExportDirFinish() final {}
public:
std::string_view get_type_name() const override { return "ExFin"; }
base(i), ack(a), old_auth(oa), new_auth(na) {
set_tid(tid);
}
- ~MExportDirNotify() override {}
+ ~MExportDirNotify() final {}
public:
std::string_view get_type_name() const override { return "ExNot"; }
MMDSOp{MSG_MDS_EXPORTDIRNOTIFYACK, HEAD_VERSION, COMPAT_VERSION}, dirfrag(df), new_auth(na) {
set_tid(tid);
}
- ~MExportDirNotifyAck() override {}
+ ~MExportDirNotifyAck() final {}
public:
std::string_view get_type_name() const override { return "ExNotA"; }
{
set_tid(tid);
}
- ~MExportDirPrep() override {}
+ ~MExportDirPrep() final {}
public:
std::string_view get_type_name() const override { return "ExP"; }
MMDSOp{MSG_MDS_EXPORTDIRPREPACK, HEAD_VERSION, COMPAT_VERSION}, dirfrag(df), success(s) {
set_tid(tid);
}
- ~MExportDirPrepAck() override {}
+ ~MExportDirPrepAck() final {}
public:
bool is_success() const { return success; }
private:
FSMap fsmap;
- ~MFSMap() override {}
+ ~MFSMap() final {}
public:
std::string_view get_type_name() const override { return "fsmap"; }
private:
FSMapUser fsmap;
- ~MFSMapUser() override {}
+ ~MFSMapUser() final {}
public:
std::string_view get_type_name() const override { return "fsmap.user"; }
msg = (PaxosServiceMessage*)m->get();
}
private:
- ~MForward() override {
+ ~MForward() final {
if (msg) {
// message was unclaimed
msg->put();
protected:
MGatherCaps() :
MMDSOp{MSG_MDS_GATHERCAPS, HEAD_VERSION, COMPAT_VERSION} {}
- ~MGatherCaps() override {}
+ ~MGatherCaps() final {}
public:
std::string_view get_type_name() const override { return "gather_caps"; }
}
private:
- ~MGetPoolStats() override {}
+ ~MGetPoolStats() final {}
public:
std::string_view get_type_name() const override { return "getpoolstats"; }
}
private:
- ~MGetPoolStatsReply() override {}
+ ~MGetPoolStatsReply() final {}
public:
std::string_view get_type_name() const override { return "getpoolstats"; }
load(load),
beat(beat)
{}
- ~MHeartbeat() override {}
+ ~MHeartbeat() final {}
public:
std::string_view get_type_name() const override { return "HB"; }
this->ino = ino;
this->caps = caps;
}
- ~MInodeFileCaps() override {}
+ ~MInodeFileCaps() final {}
public:
std::string_view get_type_name() const override { return "inode_file_caps";}
lock->get_parent()->set_object_info(object_info);
lockdata = std::move(bl);
}
- ~MLock() override {}
+ ~MLock() final {}
public:
std::string_view get_type_name() const override { return "ILock"; }
: PaxosServiceMessage{MSG_LOG, 0}, fsid(f), entries{std::move(e)} { }
MLog(const uuid_d& f) : PaxosServiceMessage(MSG_LOG, 0), fsid(f) { }
private:
- ~MLog() override {}
+ ~MLog() final {}
public:
std::string_view get_type_name() const override { return "log"; }
MLogAck() : Message{MSG_LOGACK} {}
MLogAck(uuid_d& f, version_t l) : Message{MSG_LOGACK}, fsid(f), last(l) {}
private:
- ~MLogAck() override {}
+ ~MLogAck() final {}
public:
std::string_view get_type_name() const override { return "log_ack"; }
mds_features(feat) {
set_priority(CEPH_MSG_PRIO_HIGH);
}
- ~MMDSBeacon() override {}
+ ~MMDSBeacon() final {}
public:
const uuid_d& get_fsid() const { return fsid; }
MMDSCacheRejoin(int o) : MMDSCacheRejoin() { op = o; }
MMDSCacheRejoin() : MMDSOp{MSG_MDS_CACHEREJOIN, HEAD_VERSION, COMPAT_VERSION} {}
- ~MMDSCacheRejoin() override {}
+ ~MMDSCacheRejoin() final {}
};
WRITE_CLASS_ENCODER(MMDSCacheRejoin::inode_strong)
protected:
MMDSFindIno() : MMDSOp{MSG_MDS_FINDINO, HEAD_VERSION, COMPAT_VERSION} {}
MMDSFindIno(ceph_tid_t t, inodeno_t i) : MMDSOp{MSG_MDS_FINDINO, HEAD_VERSION, COMPAT_VERSION}, tid(t), ino(i) {}
- ~MMDSFindIno() override {}
+ ~MMDSFindIno() final {}
public:
std::string_view get_type_name() const override { return "findino"; }
protected:
MMDSFindInoReply() : MMDSOp{MSG_MDS_FINDINOREPLY, HEAD_VERSION, COMPAT_VERSION} {}
MMDSFindInoReply(ceph_tid_t t) : MMDSOp{MSG_MDS_FINDINOREPLY, HEAD_VERSION, COMPAT_VERSION}, tid(t) {}
- ~MMDSFindInoReply() override {}
+ ~MMDSFindInoReply() final {}
public:
std::string_view get_type_name() const override { return "findinoreply"; }
base_dirfrag(df), bits(b) {
set_tid(tid);
}
- ~MMDSFragmentNotify() override {}
+ ~MMDSFragmentNotify() final {}
public:
std::string_view get_type_name() const override { return "fragment_notify"; }
base_dirfrag(df), bits(b) {
set_tid(tid);
}
- ~MMDSFragmentNotifyAck() override {}
+ ~MMDSFragmentNotifyAck() final {}
public:
std::string_view get_type_name() const override { return "fragment_notify_ack"; }
MMDSLoadTargets(mds_gid_t g, std::set<mds_rank_t>& mds_targets) :
PaxosServiceMessage(MSG_MDS_OFFLOAD_TARGETS, 0),
global_id(g), targets(mds_targets) {}
- ~MMDSLoadTargets() override {}
+ ~MMDSLoadTargets() final {}
public:
std::string_view get_type_name() const override { return "mds_load_targets"; }
mm.encode(encoded, -1); // we will reencode with fewer features as necessary
}
- ~MMDSMap() override {}
+ ~MMDSMap() final {}
public:
std::string_view get_type_name() const override { return "mdsmap"; }
: MMDSOp(MSG_MDS_METRICS, HEAD_VERSION, COMPAT_VERSION),
metrics_message(metrics_message) {
}
- ~MMDSMetrics() { }
+ ~MMDSMetrics() final {}
public:
std::string_view get_type_name() const override {
if (pa)
ancestors = *pa;
}
- ~MMDSOpenIno() override {}
+ ~MMDSOpenIno() final {}
public:
std::string_view get_type_name() const override { return "openino"; }
MMDSOp{MSG_MDS_PEER_REQUEST, HEAD_VERSION, COMPAT_VERSION},
reqid(ri), attempt(att), op(o), flags(0), lock_type(0),
inode_export_v(0), srcdn_auth(MDS_RANK_NONE) { }
- ~MMDSPeerRequest() override {}
+ ~MMDSPeerRequest() final {}
public:
void encode_payload(uint64_t features) override {
MMDSPing(version_t seq)
: MMDSOp(MSG_MDS_PING, HEAD_VERSION, COMPAT_VERSION), seq(seq) {
}
- ~MMDSPing() { }
+ ~MMDSPing() final {}
public:
std::string_view get_type_name() const override {
protected:
MMDSResolve() : MMDSOp{MSG_MDS_RESOLVE, HEAD_VERSION, COMPAT_VERSION}
{}
- ~MMDSResolve() override {}
+ ~MMDSResolve() final {}
public:
std::string_view get_type_name() const override { return "mds_resolve"; }
protected:
MMDSResolveAck() : MMDSOp{MSG_MDS_RESOLVEACK, HEAD_VERSION, COMPAT_VERSION} {}
- ~MMDSResolveAck() override {}
+ ~MMDSResolveAck() final {}
public:
std::string_view get_type_name() const override { return "resolve_ack"; }
MMDSOp{MSG_MDS_SNAPUPDATE}, ino(i), snap_op(op) {
set_tid(tid);
}
- ~MMDSSnapUpdate() override {}
+ ~MMDSSnapUpdate() final {}
public:
std::string_view get_type_name() const override { return "snap_update"; }
table(tab), op(o), reqid(r) {
set_tid(v);
}
- ~MMDSTableRequest() override {}
+ ~MMDSTableRequest() final {}
public:
std::string_view get_type_name() const override { return "mds_table_request"; }
}
private:
- ~MMgrBeacon() override {}
+ ~MMgrBeacon() final {}
public:
fsid(f) { }
private:
- ~MMgrCommand() override {}
+ ~MMgrCommand() final {}
public:
std::string_view get_type_name() const override { return "mgr_command"; }
: Message{MSG_MGR_COMMAND_REPLY},
r(_r), rs(s) { }
private:
- ~MMgrCommandReply() override {}
+ ~MMgrCommandReply() final {}
public:
std::string_view get_type_name() const override { return "mgr_command_reply"; }
private:
MMgrDigest() :
Message{MSG_MGR_DIGEST} {}
- ~MMgrDigest() override {}
+ ~MMgrDigest() final {}
using RefCountedObject::put;
using RefCountedObject::get;
MMgrMap(const MgrMap &map_) :
Message{MSG_MGR_MAP}, map(map_)
{}
- ~MMgrMap() override {}
+ ~MMgrMap() final {}
public:
std::string_view get_type_name() const override { return "mgrmap"; }
{ }
private:
- ~MMonCommand() override {}
+ ~MMonCommand() final {}
public:
std::string_view get_type_name() const override { return "mon_command"; }
PaxosServiceMessage{MSG_MON_COMMAND_ACK, v},
cmd(c), r(_r), rs(s) { }
private:
- ~MMonCommandAck() override {}
+ ~MMonCommandAck() final {}
public:
std::string_view get_type_name() const override { return "mon_command"; }
m->encode(monmap_bl, CEPH_FEATURES_ALL);
}
private:
- ~MMonElection() override {}
+ ~MMonElection() final {}
public:
std::string_view get_type_name() const override { return "election"; }
public:
MMonGetMap() : Message{CEPH_MSG_MON_GET_MAP} { }
private:
- ~MMonGetMap() override {}
+ ~MMonGetMap() final {}
public:
std::string_view get_type_name() const override { return "mon_getmap"; }
inc_first(0),
inc_last(0) { }
private:
- ~MMonGetOSDMap() override {}
+ ~MMonGetOSDMap() final {}
public:
void request_full(epoch_t first, epoch_t last) {
start(s),
last(l) {}
private:
- ~MMonGetPurgedSnaps() override {}
+ ~MMonGetPurgedSnaps() final {}
public:
std::string_view get_type_name() const override {
start(s),
last(l) {}
private:
- ~MMonGetPurgedSnapsReply() override {}
+ ~MMonGetPurgedSnapsReply() final {}
public:
std::string_view get_type_name() const override {
std::string what;
private:
- ~MMonGetVersion() override {}
+ ~MMonGetVersion() final {}
};
#endif
version_t oldest_version = 0;
private:
- ~MMonGetVersionReply() override {}
+ ~MMonGetVersionReply() final {}
};
#endif
MMonGlobalID() : PaxosServiceMessage{MSG_MON_GLOBAL_ID, 0}
{}
private:
- ~MMonGlobalID() override {}
+ ~MMonGlobalID() final {}
public:
std::string_view get_type_name() const override { return "global_id"; }
MMonHealth() : MMonQuorumService{MSG_MON_HEALTH, HEAD_VERSION} { }
private:
- ~MMonHealth() override { }
+ ~MMonHealth() final { }
public:
std::string_view get_type_name() const override { return "mon_health"; }
{}
private:
- ~MMonHealthChecks() override { }
+ ~MMonHealthChecks() final { }
public:
std::string_view get_type_name() const override { return "mon_health_checks"; }
{ }
private:
- ~MMonJoin() override {}
+ ~MMonJoin() final {}
public:
std::string_view get_type_name() const override { return "mon_join"; }
monmapbl = std::move(bl);
}
private:
- ~MMonMap() override {}
+ ~MMonMap() final {}
public:
std::string_view get_type_name() const override { return "mon_map"; }
: PaxosServiceMessage{MSG_MON_MGR_REPORT, 0, HEAD_VERSION, COMPAT_VERSION}
{}
private:
- ~MMonMgrReport() override {}
+ ~MMonMgrReport() final {}
public:
std::string_view get_type_name() const override { return "monmgrreport"; }
}
private:
- ~MMonPaxos() override {}
+ ~MMonPaxos() final {}
public:
std::string_view get_type_name() const override { return "paxos"; }
: Message{MSG_MON_PING, HEAD_VERSION, COMPAT_VERSION}
{}
private:
- ~MMonPing() override {}
+ ~MMonPing() final {}
public:
void decode_payload() override {
required_features(0),
mon_release{mr} {}
private:
- ~MMonProbe() override {}
+ ~MMonProbe() final {}
public:
std::string_view get_type_name() const override { return "mon_probe"; }
MMonQuorumService(int type, int head)
: Message{type, head, 1}
{}
- ~MMonQuorumService() override { }
+ ~MMonQuorumService() override {}
public:
void set_epoch(epoch_t e) {
MMonSubscribe() : Message{CEPH_MSG_MON_SUBSCRIBE, HEAD_VERSION, COMPAT_VERSION} { }
private:
- ~MMonSubscribe() override {}
+ ~MMonSubscribe() final {}
public:
void sub_want(const char *w, version_t start, unsigned flags) {
MMonSubscribeAck(uuid_d& f, int i) : Message{CEPH_MSG_MON_SUBSCRIBE_ACK},
interval(i), fsid(f) { }
private:
- ~MMonSubscribeAck() override {}
+ ~MMonSubscribeAck() final {}
public:
std::string_view get_type_name() const override { return "mon_subscribe_ack"; }
MOSDAlive(epoch_t h, epoch_t w) : PaxosServiceMessage{MSG_OSD_ALIVE, h}, want(w) {}
MOSDAlive() : MOSDAlive{0, 0} {}
private:
- ~MOSDAlive() override {}
+ ~MOSDAlive() final {}
public:
void encode_payload(uint64_t features) override {
{ }
private:
- ~MOSDBoot() override { }
+ ~MOSDBoot() final { }
public:
std::string_view get_type_name() const override { return "osd_boot"; }
flags(extra_flags),
epoch(e), failed_for(duration) { }
private:
- ~MOSDFailure() override {}
+ ~MOSDFailure() final {}
public:
int get_target_osd() { return target_osd; }
Message{MSG_OSD_FORCE_RECOVERY, HEAD_VERSION, COMPAT_VERSION},
fsid(f), forced_pgs(pgs), options(opts) {}
private:
- ~MOSDForceRecovery() {}
+ ~MOSDForceRecovery() final {}
public:
std::string_view get_type_name() const { return "force_recovery"; }
uint32_t state = 0;
private:
- ~MOSDFull() {}
+ ~MOSDFull() final {}
public:
MOSDFull(epoch_t e, unsigned s)
fsid(f), encode_features(features),
oldest_map(0), newest_map(0) { }
private:
- ~MOSDMap() override {}
+ ~MOSDMap() final {}
public:
// marshalling
void decode_payload() override {
fsid(fs), target_osd(osd),
epoch(e) {}
private:
- ~MOSDMarkMeDead() override {}
+ ~MOSDMarkMeDead() final {}
public:
epoch_t get_epoch() const { return epoch; }
fsid(fs), target_osd(osd), target_addrs(av),
epoch(e), request_ack(request_ack) {}
private:
- ~MOSDMarkMeDown() override {}
+ ~MOSDMarkMeDown() final {}
public:
epoch_t get_epoch() const { return epoch; }
reqid.inc = inc;
}
private:
- ~MOSDOp() override {}
+ ~MOSDOp() final {}
public:
void set_mtime(utime_t mt) { mtime = mt; }
}
}
private:
- ~MOSDOpReply() override {}
+ ~MOSDOpReply() final {}
public:
void encode_payload(uint64_t features) override {
map_epoch(e), query_epoch(e),
pgid(p) {}
private:
- ~MOSDPGBackfill() override {}
+ ~MOSDPGBackfill() final {}
public:
std::string_view get_type_name() const override { return "pg_backfill"; }
map_epoch(map_epoch) {}
private:
- ~MOSDPGBackfillRemove() {}
+ ~MOSDPGBackfillRemove() final {}
public:
std::string_view get_type_name() const override { return "backfill_remove"; }
epoch(e)
{}
private:
- ~MOSDPGCreate() override {}
+ ~MOSDPGCreate() final {}
public:
std::string_view get_type_name() const override { return "pg_create"; }
: Message{MSG_OSD_PG_CREATE2, HEAD_VERSION, COMPAT_VERSION},
epoch(e) { }
private:
- ~MOSDPGCreate2() override {}
+ ~MOSDPGCreate2() final {}
public:
std::string_view get_type_name() const override {
set_priority(CEPH_MSG_PRIO_HIGH);
}
private:
- ~MOSDPGInfo() override {}
+ ~MOSDPGInfo() final {}
public:
std::string_view get_type_name() const override { return "pg_info"; }
}
private:
- ~MOSDPGInfo2() override {}
+ ~MOSDPGInfo2() final {}
public:
std::string_view get_type_name() const override {
spgid(p),
lease(lease) { }
private:
- ~MOSDPGLease() override {}
+ ~MOSDPGLease() final {}
public:
std::string_view get_type_name() const override { return "pg_lease"; }
spgid(p),
lease_ack(lease_ack) { }
private:
- ~MOSDPGLeaseAck() override {}
+ ~MOSDPGLeaseAck() final {}
public:
std::string_view get_type_name() const override { return "pg_lease_ack"; }
}
private:
- ~MOSDPGLog() override {}
+ ~MOSDPGLog() final {}
public:
std::string_view get_type_name() const override { return "PGlog"; }
set_priority(CEPH_MSG_PRIO_HIGH);
}
private:
- ~MOSDPGNotify() override {}
+ ~MOSDPGNotify() final {}
public:
std::string_view get_type_name() const override { return "PGnot"; }
}
private:
- ~MOSDPGNotify2() override {}
+ ~MOSDPGNotify2() final {}
public:
std::string_view get_type_name() const override {
set_priority(CEPH_MSG_PRIO_HIGH);
}
private:
- ~MOSDPGQuery() override {}
+ ~MOSDPGQuery() final {}
public:
std::string_view get_type_name() const override { return "pg_query"; }
}
private:
- ~MOSDPGQuery2() override {}
+ ~MOSDPGQuery2() final {}
public:
std::string_view get_type_name() const override {
{}
private:
- ~MOSDPGRecoveryDelete() {}
+ ~MOSDPGRecoveryDelete() final {}
public:
std::string_view get_type_name() const { return "recovery_delete"; }
pg_list.swap(l);
}
private:
- ~MOSDPGRemove() override {}
+ ~MOSDPGRemove() final {}
public:
std::string_view get_type_name() const override { return "PGrm"; }
begin(be), end(en) {
}
private:
- ~MOSDPGScan() override {}
+ ~MOSDPGScan() final {}
public:
std::string_view get_type_name() const override { return "pg_scan"; }
: MOSDPGTemp(0)
{}
private:
- ~MOSDPGTemp() override {}
+ ~MOSDPGTemp() final {}
public:
void encode_payload(uint64_t features) override {
MOSDPeeringOp{MSG_OSD_PG_TRIM, HEAD_VERSION, COMPAT_VERSION},
epoch(mv), pgid(p), trim_to(tt) { }
private:
- ~MOSDPGTrim() override {}
+ ~MOSDPGTrim() final {}
public:
std::string_view get_type_name() const override { return "pg_trim"; }
{}
private:
- ~MOSDPGUpdateLogMissing() override {}
+ ~MOSDPGUpdateLogMissing() final {}
public:
std::string_view get_type_name() const override { return "PGUpdateLogMissing"; }
{}
private:
- ~MOSDPGUpdateLogMissingReply() override {}
+ ~MOSDPGUpdateLogMissingReply() final {}
public:
std::string_view get_type_name() const override { return "PGUpdateLogMissingReply"; }
: Message{MSG_OSD_PING, HEAD_VERSION, COMPAT_VERSION}
{}
private:
- ~MOSDPing() override {}
+ ~MOSDPing() final {}
public:
void decode_payload() override {
min_last_complete_ondisk = rollback_to;
}
private:
- ~MOSDRepOp() override {}
+ ~MOSDRepOp() final {}
public:
std::string_view get_type_name() const override { return "osd_repop"; }
ack_type(0), result(0),
final_decode_needed(true) {}
private:
- ~MOSDRepOpReply() override {}
+ ~MOSDRepOpReply() final {}
public:
std::string_view get_type_name() const override { return "osd_repop_reply"; }
private:
- ~MOSDRepScrub() override {}
+ ~MOSDRepScrub() final {}
public:
std::string_view get_type_name() const override { return "replica scrub"; }
from(from) {}
private:
- ~MOSDRepScrubMap() {}
+ ~MOSDRepScrubMap() final {}
public:
std::string_view get_type_name() const override { return "rep_scrubmap"; }
Message{MSG_OSD_SCRUB, HEAD_VERSION, COMPAT_VERSION},
fsid(f), scrub_pgs(pgs), repair(r), deep(d) {}
private:
- ~MOSDScrub() override {}
+ ~MOSDScrub() final {}
public:
std::string_view get_type_name() const override { return "scrub"; }
Message{MSG_OSD_SCRUB2, HEAD_VERSION, COMPAT_VERSION},
fsid(f), epoch(e), scrub_pgs(pgs), repair(r), deep(d) {}
private:
- ~MOSDScrub2() override {}
+ ~MOSDScrub2() final {}
public:
std::string_view get_type_name() const override { return "scrub2"; }
{}
private:
- ~MPGStats() override {}
+ ~MPGStats() final {}
public:
std::string_view get_type_name() const override { return "pg_stats"; }
MPGStatsAck() : Message{MSG_PGSTATSACK} {}
private:
- ~MPGStatsAck() override {}
+ ~MPGStatsAck() final {}
public:
std::string_view get_type_name() const override { return "pg_stats_ack"; }
public:
MPing() : Message{CEPH_MSG_PING} {}
private:
- ~MPing() override {}
+ ~MPing() final {}
public:
void decode_payload() override { }
}
private:
- ~MPoolOp() override {}
+ ~MPoolOp() final {}
public:
std::string_view get_type_name() const override { return "poolop"; }
PaxosServiceMessage{MSG_REMOVE_SNAPS, 0} {
snaps.swap(s);
}
- ~MRemoveSnaps() override {}
+ ~MRemoveSnaps() final {}
public:
std::string_view get_type_name() const override { return "remove_snaps"; }
msg(m),
send_osdmap_first(0) {}
private:
- ~MRoute() override {
+ ~MRoute() final {
if (msg)
msg->put();
}
service_map(sm) {
}
private:
- ~MServiceMap() override {}
+ ~MServiceMap() final {}
public:
std::string_view get_type_name() const override { return "service_map"; }
}
private:
- ~MStatfs() override {}
+ ~MStatfs() final {}
public:
std::string_view get_type_name() const override { return "statfs"; }
{}
private:
- ~MTimeCheck() override {}
+ ~MTimeCheck() final {}
public:
std::string_view get_type_name() const override { return "time_check"; }
{ }
private:
- ~MTimeCheck2() override { }
+ ~MTimeCheck2() final { }
public:
std::string_view get_type_name() const override { return "time_check2"; }
return_code(0),
notifier_gid(n) { }
private:
- ~MWatchNotify() override {}
+ ~MWatchNotify() final {}
public:
void decode_payload() override {
version(v), deprecated_session_mon(-1), deprecated_session_mon_tid(0),
rx_election_epoch(0) { }
protected:
- virtual ~PaxosServiceMessage() override {}
+ ~PaxosServiceMessage() override {}
public:
void paxos_encode() {
projects / ceph.git / commitdiff