To avoid including message headers in Client.h.
Signed-off-by: Patrick Donnelly <pdonnell@redhat.com>
#include "mon/MonClient.h"
+#include "messages/MClientCaps.h"
+#include "messages/MClientLease.h"
+#include "messages/MClientQuota.h"
#include "messages/MClientReclaim.h"
+#include "messages/MClientReclaimReply.h"
#include "messages/MClientReconnect.h"
+#include "messages/MClientReply.h"
+#include "messages/MClientRequest.h"
+#include "messages/MClientRequestForward.h"
+#include "messages/MClientSession.h"
+#include "messages/MClientSnap.h"
+#include "messages/MCommandReply.h"
+#include "messages/MFSMap.h"
+#include "messages/MFSMapUser.h"
+#include "messages/MMDSMap.h"
+#include "messages/MOSDMap.h"
#include "mds/flock.h"
#include "mds/cephfs_features.h"
}
int Client::verify_reply_trace(int r,
- MetaRequest *request, const MClientReply::const_ref& reply,
+ MetaRequest *request, const MConstRef<MClientReply>& reply,
InodeRef *ptarget, bool *pcreated,
const UserPerm& perms)
{
mds_sessions.erase(s->mds_num);
}
-void Client::handle_client_session(const MClientSession::const_ref& m)
+void Client::handle_client_session(const MConstRef<MClientSession>& m)
{
mds_rank_t from = mds_rank_t(m->get_source().num());
ldout(cct, 10) << __func__ << " " << *m << " from mds." << from << dendl;
-void Client::handle_client_request_forward(const MClientRequestForward::const_ref& fwd)
+void Client::handle_client_request_forward(const MConstRef<MClientRequestForward>& fwd)
{
mds_rank_t mds = mds_rank_t(fwd->get_source().num());
MetaSession *session = _get_mds_session(mds, fwd->get_connection().get());
return false;
}
-void Client::handle_client_reply(const MClientReply::const_ref& reply)
+void Client::handle_client_reply(const MConstRef<MClientReply>& reply)
{
mds_rank_t mds_num = mds_rank_t(reply->get_source().num());
MetaSession *session = _get_mds_session(mds_num, reply->get_connection().get());
}
}
-void Client::handle_osd_map(const MOSDMap::const_ref& m)
+void Client::handle_osd_map(const MConstRef<MOSDMap>& m)
{
std::set<entity_addr_t> new_blacklists;
objecter->consume_blacklist_events(&new_blacklists);
// incoming messages
-bool Client::ms_dispatch2(const Message::ref &m)
+bool Client::ms_dispatch2(const MessageRef &m)
{
std::lock_guard l(client_lock);
if (!initialized) {
return true;
}
-void Client::handle_fs_map(const MFSMap::const_ref& m)
+void Client::handle_fs_map(const MConstRef<MFSMap>& m)
{
fsmap.reset(new FSMap(m->get_fsmap()));
monclient->sub_got("fsmap", fsmap->get_epoch());
}
-void Client::handle_fs_map_user(const MFSMapUser::const_ref& m)
+void Client::handle_fs_map_user(const MConstRef<MFSMapUser>& m)
{
fsmap_user.reset(new FSMapUser);
*fsmap_user = m->get_fsmap();
signal_cond_list(waiting_for_fsmap);
}
-void Client::handle_mds_map(const MMDSMap::const_ref& m)
+void Client::handle_mds_map(const MConstRef<MMDSMap>& m)
{
mds_gid_t old_inc, new_inc;
if (m->get_epoch() <= mdsmap->get_epoch()) {
}
}
-void Client::handle_lease(const MClientLease::const_ref& m)
+void Client::handle_lease(const MConstRef<MClientLease>& m)
{
ldout(cct, 10) << __func__ << " " << *m << dendl;
put_snap_realm(first_realm);
}
-void Client::handle_snap(const MClientSnap::const_ref& m)
+void Client::handle_snap(const MConstRef<MClientSnap>& m)
{
ldout(cct, 10) << __func__ << " " << *m << dendl;
mds_rank_t mds = mds_rank_t(m->get_source().num());
}
}
-void Client::handle_quota(const MClientQuota::const_ref& m)
+void Client::handle_quota(const MConstRef<MClientQuota>& m)
{
mds_rank_t mds = mds_rank_t(m->get_source().num());
MetaSession *session = _get_mds_session(mds, m->get_connection().get());
}
}
-void Client::handle_caps(const MClientCaps::const_ref& m)
+void Client::handle_caps(const MConstRef<MClientCaps>& m)
{
mds_rank_t mds = mds_rank_t(m->get_source().num());
MetaSession *session = _get_mds_session(mds, m->get_connection().get());
}
}
-void Client::handle_cap_import(MetaSession *session, Inode *in, const MClientCaps::const_ref& m)
+void Client::handle_cap_import(MetaSession *session, Inode *in, const MConstRef<MClientCaps>& m)
{
mds_rank_t mds = session->mds_num;
}
}
-void Client::handle_cap_export(MetaSession *session, Inode *in, const MClientCaps::const_ref& m)
+void Client::handle_cap_export(MetaSession *session, Inode *in, const MConstRef<MClientCaps>& m)
{
mds_rank_t mds = session->mds_num;
}
}
-void Client::handle_cap_trunc(MetaSession *session, Inode *in, const MClientCaps::const_ref& m)
+void Client::handle_cap_trunc(MetaSession *session, Inode *in, const MConstRef<MClientCaps>& m)
{
mds_rank_t mds = session->mds_num;
ceph_assert(in->caps.count(mds));
m->get_truncate_seq(), m->get_truncate_size());
}
-void Client::handle_cap_flush_ack(MetaSession *session, Inode *in, Cap *cap, const MClientCaps::const_ref& m)
+void Client::handle_cap_flush_ack(MetaSession *session, Inode *in, Cap *cap, const MConstRef<MClientCaps>& m)
{
ceph_tid_t flush_ack_tid = m->get_client_tid();
int dirty = m->get_dirty();
}
-void Client::handle_cap_flushsnap_ack(MetaSession *session, Inode *in, const MClientCaps::const_ref& m)
+void Client::handle_cap_flushsnap_ack(MetaSession *session, Inode *in, const MConstRef<MClientCaps>& m)
{
mds_rank_t mds = session->mds_num;
ceph_assert(in->caps.count(mds));
}
}
-void Client::handle_cap_grant(MetaSession *session, Inode *in, Cap *cap, const MClientCaps::const_ref& m)
+void Client::handle_cap_grant(MetaSession *session, Inode *in, Cap *cap, const MConstRef<MClientCaps>& m)
{
mds_rank_t mds = session->mds_num;
int used = get_caps_used(in);
return 0;
}
-void Client::handle_command_reply(const MCommandReply::const_ref& m)
+void Client::handle_command_reply(const MConstRef<MCommandReply>& m)
{
ceph_tid_t const tid = m->get_tid();
metadata.erase(it);
}
-void Client::handle_client_reclaim_reply(const MClientReclaimReply::const_ref& reply)
+void Client::handle_client_reclaim_reply(const MConstRef<MClientReclaimReply>& reply)
{
mds_rank_t from = mds_rank_t(reply->get_source().num());
ldout(cct, 10) << __func__ << " " << *reply << " from mds." << from << dendl;
#include "include/unordered_set.h"
#include "mds/mdstypes.h"
#include "msg/Dispatcher.h"
+#include "msg/MessageRef.h"
#include "msg/Messenger.h"
#include "osdc/ObjectCacher.h"
-#include "messages/MClientCaps.h"
-#include "messages/MClientLease.h"
-#include "messages/MClientQuota.h"
-#include "messages/MClientReclaimReply.h"
-#include "messages/MClientReply.h"
-#include "messages/MClientRequest.h"
-#include "messages/MClientRequestForward.h"
-#include "messages/MClientSession.h"
-#include "messages/MClientSnap.h"
-#include "messages/MCommandReply.h"
-#include "messages/MFSMap.h"
-#include "messages/MFSMapUser.h"
-#include "messages/MMDSMap.h"
-#include "messages/MOSDMap.h"
-
#include "InodeRef.h"
#include "MetaSession.h"
#include "UserPerm.h"
virtual void shutdown();
// messaging
- void handle_mds_map(const MMDSMap::const_ref& m);
- void handle_fs_map(const MFSMap::const_ref& m);
- void handle_fs_map_user(const MFSMapUser::const_ref& m);
- void handle_osd_map(const MOSDMap::const_ref& m);
+ void handle_mds_map(const MConstRef<MMDSMap>& m);
+ void handle_fs_map(const MConstRef<MFSMap>& m);
+ void handle_fs_map_user(const MConstRef<MFSMapUser>& m);
+ void handle_osd_map(const MConstRef<MOSDMap>& m);
- void handle_lease(const MClientLease::const_ref& m);
+ void handle_lease(const MConstRef<MClientLease>& m);
// inline data
int uninline_data(Inode *in, Context *onfinish);
void maybe_update_snaprealm(SnapRealm *realm, snapid_t snap_created, snapid_t snap_highwater,
vector<snapid_t>& snaps);
- void handle_quota(const MClientQuota::const_ref& m);
- void handle_snap(const MClientSnap::const_ref& m);
- void handle_caps(const MClientCaps::const_ref& m);
- void handle_cap_import(MetaSession *session, Inode *in, const MClientCaps::const_ref& m);
- void handle_cap_export(MetaSession *session, Inode *in, const MClientCaps::const_ref& m);
- void handle_cap_trunc(MetaSession *session, Inode *in, const MClientCaps::const_ref& m);
- void handle_cap_flush_ack(MetaSession *session, Inode *in, Cap *cap, const MClientCaps::const_ref& m);
- void handle_cap_flushsnap_ack(MetaSession *session, Inode *in, const MClientCaps::const_ref& m);
- void handle_cap_grant(MetaSession *session, Inode *in, Cap *cap, const MClientCaps::const_ref& m);
+ void handle_quota(const MConstRef<MClientQuota>& m);
+ void handle_snap(const MConstRef<MClientSnap>& m);
+ void handle_caps(const MConstRef<MClientCaps>& m);
+ void handle_cap_import(MetaSession *session, Inode *in, const MConstRef<MClientCaps>& m);
+ void handle_cap_export(MetaSession *session, Inode *in, const MConstRef<MClientCaps>& m);
+ void handle_cap_trunc(MetaSession *session, Inode *in, const MConstRef<MClientCaps>& m);
+ void handle_cap_flush_ack(MetaSession *session, Inode *in, Cap *cap, const MConstRef<MClientCaps>& m);
+ void handle_cap_flushsnap_ack(MetaSession *session, Inode *in, const MConstRef<MClientCaps>& m);
+ void handle_cap_grant(MetaSession *session, Inode *in, Cap *cap, const MConstRef<MClientCaps>& m);
void cap_delay_requeue(Inode *in);
void send_cap(Inode *in, MetaSession *session, Cap *cap, bool sync,
int used, int want, int retain, int flush,
void set_cap_epoch_barrier(epoch_t e);
- void handle_command_reply(const MCommandReply::const_ref& m);
+ void handle_command_reply(const MConstRef<MCommandReply>& m);
int fetch_fsmap(bool user);
int resolve_mds(
const std::string &mds_spec,
void _closed_mds_session(MetaSession *s);
bool _any_stale_sessions() const;
void _kick_stale_sessions();
- void handle_client_session(const MClientSession::const_ref& m);
+ void handle_client_session(const MConstRef<MClientSession>& m);
void send_reconnect(MetaSession *s);
void resend_unsafe_requests(MetaSession *s);
void wait_unsafe_requests();
void put_request(MetaRequest *request);
void unregister_request(MetaRequest *request);
- int verify_reply_trace(int r, MetaRequest *request, const MClientReply::const_ref& reply,
+ int verify_reply_trace(int r, MetaRequest *request, const MConstRef<MClientReply>& reply,
InodeRef *ptarget, bool *pcreated,
const UserPerm& perms);
void encode_cap_releases(MetaRequest *request, mds_rank_t mds);
void connect_mds_targets(mds_rank_t mds);
void send_request(MetaRequest *request, MetaSession *session,
bool drop_cap_releases=false);
- MClientRequest::ref build_client_request(MetaRequest *request);
+ MRef<MClientRequest> build_client_request(MetaRequest *request);
void kick_requests(MetaSession *session);
void kick_requests_closed(MetaSession *session);
- void handle_client_request_forward(const MClientRequestForward::const_ref& reply);
- void handle_client_reply(const MClientReply::const_ref& reply);
+ void handle_client_request_forward(const MConstRef<MClientRequestForward>& reply);
+ void handle_client_reply(const MConstRef<MClientReply>& reply);
bool is_dir_operation(MetaRequest *request);
// fake inode number for 32-bits ino_t
void dump_status(Formatter *f); // debug
- bool ms_dispatch2(const Message::ref &m) override;
+ bool ms_dispatch2(const MessageRef& m) override;
void ms_handle_connect(Connection *con) override;
bool ms_handle_reset(Connection *con) override;
int check_pool_perm(Inode *in, int need);
- void handle_client_reclaim_reply(const MClientReclaimReply::const_ref& reply);
+ void handle_client_reclaim_reply(const MConstRef<MClientReclaimReply>& reply);
/**
* Call this when an OSDMap is seen with a full flag (global or per pool)
#define CEPH_MCLIENTCAPS_H
#include "msg/Message.h"
+#include "mds/mdstypes.h"
#include "include/ceph_features.h"
class MClientCaps : public MessageInstance<MClientCaps> {
#include <boost/intrusive_ptr.hpp>
-class Message;
+template<typename T>
+using MRef = boost::intrusive_ptr<T>;
+template<typename T>
+using MConstRef = boost::intrusive_ptr<T const>;
-typedef boost::intrusive_ptr<Message> MessageRef;
-typedef boost::intrusive_ptr<Message const> MessageConstRef;
+using MessageRef = MRef<class Message>;
+using MessageConstRef = MConstRef<class Message>;
+
+/* cd src/messages/ && for f in *; do printf 'class '; basename "$f" .h | tr -d '\n'; printf ';\n'; done >> ../msg/MessageRef.h */
+
+class MAuth;
+class MAuthReply;
+class MBackfillReserve;
+class MCacheExpire;
+class MClientCapRelease;
+class MClientCaps;
+class MClientLease;
+class MClientQuota;
+class MClientReclaim;
+class MClientReclaimReply;
+class MClientReconnect;
+class MClientReply;
+class MClientRequestForward;
+class MClientRequest;
+class MClientSession;
+class MClientSnap;
+class MCommand;
+class MCommandReply;
+class MConfig;
+class MDataPing;
+class MDentryLink;
+class MDentryUnlink;
+class MDirUpdate;
+class MDiscover;
+class MDiscoverReply;
+class MExportCapsAck;
+class MExportCaps;
+class MExportDirAck;
+class MExportDirCancel;
+class MExportDirDiscoverAck;
+class MExportDirDiscover;
+class MExportDirFinish;
+class MExportDir;
+class MExportDirNotifyAck;
+class MExportDirNotify;
+class MExportDirPrepAck;
+class MExportDirPrep;
+class MForward;
+class MFSMap;
+class MFSMapUser;
+class MGatherCaps;
+class MGenericMessage;
+class MGetConfig;
+class MGetPoolStats;
+class MGetPoolStatsReply;
+class MHeartbeat;
+class MInodeFileCaps;
+class MLock;
+class MLogAck;
+class MLog;
+class MMDSBeacon;
+class MMDSCacheRejoin;
+class MMDSFindIno;
+class MMDSFindInoReply;
+class MMDSFragmentNotifyAck;
+class MMDSFragmentNotify;
+class MMDSLoadTargets;
+class MMDSMap;
+class MMDSOpenIno;
+class MMDSOpenInoReply;
+class MMDSResolveAck;
+class MMDSResolve;
+class MMDSSlaveRequest;
+class MMDSSnapUpdate;
+class MMDSTableRequest;
+class MMgrBeacon;
+class MMgrClose;
+class MMgrConfigure;
+class MMgrDigest;
+class MMgrMap;
+class MMgrOpen;
+class MMgrReport;
+class MMonCommandAck;
+class MMonCommand;
+class MMonElection;
+class MMonGetMap;
+class MMonGetOSDMap;
+class MMonGetVersion;
+class MMonGetVersionReply;
+class MMonGlobalID;
+class MMonHealthChecks;
+class MMonHealth;
+class MMonJoin;
+class MMonMap;
+class MMonMetadata;
+class MMonMgrReport;
+class MMonPaxos;
+class MMonProbe;
+class MMonQuorumService;
+class MMonScrub;
+class MMonSubscribeAck;
+class MMonSubscribe;
+class MMonSync;
+class MNop;
+class MOSDAlive;
+class MOSDBackoff;
+class MOSDBeacon;
+class MOSDBoot;
+class MOSDECSubOpRead;
+class MOSDECSubOpReadReply;
+class MOSDECSubOpWrite;
+class MOSDECSubOpWriteReply;
+class MOSDFailure;
+class MOSDFastDispatchOp;
+class MOSDForceRecovery;
+class MOSDFull;
+class MOSDMap;
+class MOSDMarkMeDown;
+class MOSDOp;
+class MOSDOpReply;
+class MOSDPeeringOp;
+class MOSDPGBackfill;
+class MOSDPGBackfillRemove;
+class MOSDPGCreate2;
+class MOSDPGCreated;
+class MOSDPGCreate;
+class MOSDPGInfo;
+class MOSDPGLog;
+class MOSDPGNotify;
+class MOSDPGPull;
+class MOSDPGPush;
+class MOSDPGPushReply;
+class MOSDPGQuery;
+class MOSDPGReadyToMerge;
+class MOSDPGRecoveryDelete;
+class MOSDPGRecoveryDeleteReply;
+class MOSDPGRemove;
+class MOSDPGScan;
+class MOSDPGTemp;
+class MOSDPGTrim;
+class MOSDPGUpdateLogMissing;
+class MOSDPGUpdateLogMissingReply;
+class MOSDPing;
+class MOSDRepOp;
+class MOSDRepOpReply;
+class MOSDRepScrub;
+class MOSDRepScrubMap;
+class MOSDScrub2;
+class MOSDScrub;
+class MOSDScrubReserve;
+class MPGStatsAck;
+class MPGStats;
+class MPing;
+class MPoolOp;
+class MPoolOpReply;
+class MRecoveryReserve;
+class MRemoveSnaps;
+class MRoute;
+class MServiceMap;
+class MStatfs;
+class MStatfsReply;
+class MTimeCheck2;
+class MTimeCheck;
+class MWatchNotify;
+class PaxosServiceMessage;
#endif
projects / ceph.git / commitdiff