/
rgw_process.h
180 lines (145 loc) · 4.35 KB
/
rgw_process.h
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
174
175
176
177
178
179
180
// -*- mode:C++; tab-width:8; c-basic-offset:2; indent-tabs-mode:t -*-
// vim: ts=8 sw=2 smarttab
#ifndef RGW_PROCESS_H
#define RGW_PROCESS_H
#include "rgw_common.h"
#include "rgw_rados.h"
#include "rgw_acl.h"
#include "rgw_user.h"
#include "rgw_op.h"
#include "rgw_rest.h"
#include "include/assert.h"
#include "common/WorkQueue.h"
#include "common/Throttle.h"
#if !defined(dout_subsys)
#define dout_subsys ceph_subsys_rgw
#define def_dout_subsys
#endif
extern void signal_shutdown();
struct RGWProcessEnv {
RGWRados *store;
RGWREST *rest;
OpsLogSocket *olog;
int port;
};
class RGWFrontendConfig;
class RGWProcess {
deque<RGWRequest*> m_req_queue;
protected:
CephContext *cct;
RGWRados* store;
OpsLogSocket* olog;
ThreadPool m_tp;
Throttle req_throttle;
RGWREST* rest;
RGWFrontendConfig* conf;
int sock_fd;
struct RGWWQ : public ThreadPool::WorkQueue<RGWRequest> {
RGWProcess* process;
RGWWQ(RGWProcess* p, time_t timeout, time_t suicide_timeout, ThreadPool* tp)
: ThreadPool::WorkQueue<RGWRequest>("RGWWQ", timeout, suicide_timeout,
tp), process(p) {}
bool _enqueue(RGWRequest* req) {
process->m_req_queue.push_back(req);
perfcounter->inc(l_rgw_qlen);
dout(20) << "enqueued request req=" << hex << req << dec << dendl;
_dump_queue();
return true;
}
void _dequeue(RGWRequest* req) {
assert(0);
}
bool _empty() {
return process->m_req_queue.empty();
}
RGWRequest* _dequeue() {
if (process->m_req_queue.empty())
return NULL;
RGWRequest *req = process->m_req_queue.front();
process->m_req_queue.pop_front();
dout(20) << "dequeued request req=" << hex << req << dec << dendl;
_dump_queue();
perfcounter->inc(l_rgw_qlen, -1);
return req;
}
using ThreadPool::WorkQueue<RGWRequest>::_process;
void _process(RGWRequest *req, ThreadPool::TPHandle &) override {
perfcounter->inc(l_rgw_qactive);
process->handle_request(req);
process->req_throttle.put(1);
perfcounter->inc(l_rgw_qactive, -1);
}
void _dump_queue();
void _clear() {
assert(process->m_req_queue.empty());
}
} req_wq;
public:
RGWProcess(CephContext* cct, RGWProcessEnv* pe, int num_threads,
RGWFrontendConfig* _conf)
: cct(cct), store(pe->store), olog(pe->olog),
m_tp(cct, "RGWProcess::m_tp", "tp_rgw_process", num_threads),
req_throttle(cct, "rgw_ops", num_threads * 2),
rest(pe->rest), conf(_conf), sock_fd(-1),
req_wq(this, g_conf->rgw_op_thread_timeout,
g_conf->rgw_op_thread_suicide_timeout, &m_tp) {}
virtual ~RGWProcess() {}
virtual void run() = 0;
virtual void handle_request(RGWRequest *req) = 0;
void pause() {
m_tp.pause();
}
void unpause_with_new_config(RGWRados *store) {
this->store = store;
m_tp.unpause();
}
void close_fd() {
if (sock_fd >= 0) {
::close(sock_fd);
sock_fd = -1;
}
}
}; /* RGWProcess */
class RGWFCGXProcess : public RGWProcess {
int max_connections;
public:
/* have a bit more connections than threads so that requests are
* still accepted even if we're still processing older requests */
RGWFCGXProcess(CephContext* cct, RGWProcessEnv* pe, int num_threads,
RGWFrontendConfig* _conf)
: RGWProcess(cct, pe, num_threads, _conf),
max_connections(num_threads + (num_threads >> 3))
{}
void run();
void handle_request(RGWRequest* req);
};
class RGWProcessControlThread : public Thread {
RGWProcess *pprocess;
public:
RGWProcessControlThread(RGWProcess *_pprocess) : pprocess(_pprocess) {}
void *entry() {
pprocess->run();
return NULL;
}
};
class RGWLoadGenProcess : public RGWProcess {
RGWAccessKey access_key;
public:
RGWLoadGenProcess(CephContext* cct, RGWProcessEnv* pe, int num_threads,
RGWFrontendConfig* _conf) :
RGWProcess(cct, pe, num_threads, _conf) {}
void run();
void checkpoint();
void handle_request(RGWRequest* req);
void gen_request(const string& method, const string& resource,
int content_length, atomic_t* fail_flag);
void set_access_key(RGWAccessKey& key) { access_key = key; }
};
/* process stream request */
int process_request(RGWRados* store, RGWREST* rest, RGWRequest* req,
RGWStreamIO* client_io, OpsLogSocket* olog);
#if defined(def_dout_subsys)
#undef def_dout_subsys
#undef dout_subsys
#endif
#endif /* RGW_PROCESS_H */