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
181
182
183
184
185
186
187
188
189
190
191
192
193
|
// client.h
/**
* Copyright (C) 2008 10gen Inc.
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU Affero General Public License, version 3,
* as published by the Free Software Foundation.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU Affero General Public License for more details.
*
* You should have received a copy of the GNU Affero General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
/* Client represents a connection to the database (the server-side) and corresponds
to an open socket (or logical connection if pooling on sockets) from a client.
todo: switch to asio...this will fit nicely with that.
*/
#pragma once
#include "../stdafx.h"
#include "namespace.h"
#include "lasterror.h"
#include "../util/top.h"
namespace mongo {
class AuthenticationInfo;
class Database;
class CurOp;
class Command;
class Client;
extern boost::thread_specific_ptr<Client> currentClient;
bool setClient(const char *ns, const string& path=dbpath, mongolock *lock = 0);
class Client : boost::noncopyable {
public:
static boost::mutex clientsMutex;
static set<Client*> clients; // always be in clientsMutex when manipulating this
class GodScope {
bool _prev;
public:
GodScope();
~GodScope();
};
/* Set database we want to use, then, restores when we finish (are out of scope)
Note this is also helpful if an exception happens as the state if fixed up.
*/
class Context {
Client * _client;
Database * _olddb;
string _oldns;
public:
Context(const char *ns)
: _client( currentClient.get() ) {
_olddb = _client->_database;
_oldns = _client->_ns;
setClient(ns);
}
Context(string ns)
: _client( currentClient.get() ){
_olddb = _client->_database;
_oldns = _client->_ns;
setClient(ns.c_str());
}
/* this version saves the context but doesn't yet set the new one: */
Context()
: _client( currentClient.get() ) {
_olddb = _client->database();
_oldns = _client->ns();
}
/**
* if you are doing this after allowing a write there could be a race condition
* if someone closes that db. this checks that the DB is still valid
*/
Context( string ns , Database * db );
~Context() {
DEV assert( _client == currentClient.get() );
_client->setns( _oldns.c_str(), _olddb );
}
};
private:
CurOp * const _curOp;
Database *_database;
Namespace _ns;
//NamespaceString _nsstr;
bool _shutdown;
list<string> _tempCollections;
const char *_desc;
bool _god;
public:
AuthenticationInfo *ai;
Top top;
CurOp* curop() { return _curOp; }
Database* database() {
return _database;
}
const char *ns() { return _ns.buf; }
void setns(const char *ns, Database *db) {
_database = db;
_ns = ns;
//_nsstr = ns;
}
void clearns() { setns("", 0); }
Client(const char *desc);
~Client();
const char *desc() const { return _desc; }
void addTempCollection( const string& ns ){
_tempCollections.push_back( ns );
}
/* each thread which does db operations has a Client object in TLS.
call this when your thread starts.
*/
static void initThread(const char *desc);
/*
this has to be called as the client goes away, but before thread termination
@return true if anything was done
*/
bool shutdown();
bool isGod() const { return _god; }
};
inline Client& cc() {
return *currentClient.get();
}
/* each thread which does db operations has a Client object in TLS.
call this when your thread starts.
*/
inline void Client::initThread(const char *desc) {
assert( currentClient.get() == 0 );
currentClient.reset( new Client(desc) );
}
inline Client::GodScope::GodScope(){
_prev = cc()._god;
cc()._god = true;
}
inline Client::GodScope::~GodScope(){
cc()._god = _prev;
}
/* this unlocks, does NOT upgrade. that works for our current usage */
inline void mongolock::releaseAndWriteLock() {
if( !_writelock ) {
#if BOOST_VERSION >= 103500
int s = dbMutex.getState();
if( s != -1 ) {
log() << "error: releaseAndWriteLock() s == " << s << endl;
msgasserted( 12600, "releaseAndWriteLock: unlock_shared failed, probably recursive" );
}
#endif
_writelock = true;
dbMutex.unlock_shared();
dbMutex.lock();
/* this is defensive; as we were unlocked for a moment above,
the Database object we reference could have been deleted:
*/
cc().clearns();
}
}
};
|
