1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
/*
* Ceph - scalable distributed file system
*
* Copyright (C) 2004-2006 Sage Weil <sage@newdream.net>
*
* This is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License version 2.1, as published by the Free Software
* Foundation. See file COPYING.
*
*/
#ifndef CEPH_MDS_H
#define CEPH_MDS_H
#include <string_view>
#include "common/LogClient.h"
#include "common/Mutex.h"
#include "common/Timer.h"
#include "include/Context.h"
#include "include/types.h"
#include "mgr/MgrClient.h"
#include "msg/Dispatcher.h"
#include "Beacon.h"
#include "MDSMap.h"
#include "MDSRank.h"
#define CEPH_MDS_PROTOCOL 33 /* cluster internal */
class AuthAuthorizeHandlerRegistry;
class Message;
class Messenger;
class MonClient;
class MDSDaemon : public Dispatcher, public md_config_obs_t {
public:
/* Global MDS lock: every time someone takes this, they must
* also check the `stopping` flag. If stopping is true, you
* must either do nothing and immediately drop the lock, or
* never drop the lock again (i.e. call respawn()) */
Mutex mds_lock;
bool stopping;
SafeTimer timer;
mono_time get_starttime() const {
return starttime;
}
chrono::duration<double> get_uptime() const {
mono_time now = mono_clock::now();
return chrono::duration<double>(now-starttime);
}
protected:
Beacon beacon;
AuthAuthorizeHandlerRegistry *authorize_handler_cluster_registry;
AuthAuthorizeHandlerRegistry *authorize_handler_service_registry;
std::string name;
Messenger *messenger;
MonClient *monc;
MgrClient mgrc;
MDSMap *mdsmap;
LogClient log_client;
LogChannelRef clog;
MDSRankDispatcher *mds_rank;
public:
MDSDaemon(std::string_view n, Messenger *m, MonClient *mc);
~MDSDaemon() override;
int orig_argc;
const char **orig_argv;
// handle a signal (e.g., SIGTERM)
void handle_signal(int signum);
int init();
/**
* Hint at whether we were shutdown gracefully (i.e. we were only
* in standby, or our rank was stopped). Should be removed once
* we handle shutdown properly (e.g. clear out all message queues)
* such that deleting xlists doesn't assert.
*/
bool is_clean_shutdown();
// config observer bits
const char** get_tracked_conf_keys() const override;
void handle_conf_change(const ConfigProxy& conf,
const std::set <std::string> &changed) override;
protected:
// tick and other timer fun
Context *tick_event = nullptr;
void reset_tick();
void wait_for_omap_osds();
private:
bool ms_dispatch(Message *m) override;
bool ms_get_authorizer(int dest_type, AuthAuthorizer **authorizer, bool force_new) override;
bool ms_verify_authorizer(Connection *con, int peer_type,
int protocol, bufferlist& authorizer_data, bufferlist& authorizer_reply,
bool& isvalid, CryptoKey& session_key,
std::unique_ptr<AuthAuthorizerChallenge> *challenge) override;
void ms_handle_accept(Connection *con) override;
void ms_handle_connect(Connection *con) override;
bool ms_handle_reset(Connection *con) override;
void ms_handle_remote_reset(Connection *con) override;
bool ms_handle_refused(Connection *con) override;
protected:
// admin socket handling
friend class MDSSocketHook;
class MDSSocketHook *asok_hook;
void set_up_admin_socket();
void clean_up_admin_socket();
void check_ops_in_flight(); // send off any slow ops to monitor
bool asok_command(std::string_view command, const cmdmap_t& cmdmap,
std::string_view format, ostream& ss);
void dump_status(Formatter *f);
/**
* Terminate this daemon process.
*
* This function will return, but once it does so the calling thread
* must do no more work as all subsystems will have been shut down.
*/
void suicide();
/**
* Start a new daemon process with the same command line parameters that
* this process was run with, then terminate this process
*/
void respawn();
void tick();
// messages
bool _dispatch(Message *m, bool new_msg);
protected:
bool handle_core_message(Message *m);
// special message types
friend class C_MDS_Send_Command_Reply;
static void send_command_reply(MCommand *m, MDSRank* mds_rank, int r,
bufferlist outbl, std::string_view outs);
int _handle_command(
const cmdmap_t &cmdmap,
MCommand *m,
bufferlist *outbl,
std::string *outs,
Context **run_later,
bool *need_reply);
void handle_command(class MCommand *m);
void handle_mds_map(class MMDSMap *m);
void _handle_mds_map(MDSMap *oldmap);
private:
mono_time starttime = mono_clock::zero();
};
#endif
|
