Kinetic C/C++ Client
 All Classes Functions Variables Pages
threadsafe_blocking_kinetic_connection.cc
1 /*
2  * kinetic-cpp-client
3  * Copyright (C) 2014 Seagate Technology.
4  *
5  * This program is free software; you can redistribute it and/or
6  * modify it under the terms of the GNU General Public License
7  * as published by the Free Software Foundation; either version 2
8  * of the License, or (at your option) any later version.
9  *
10  * This program is distributed in the hope that it will be useful,
11  * but WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13  * GNU General Public License for more details.
14  *
15  * You should have received a copy of the GNU General Public License
16  * along with this program; if not, write to the Free Software
17  * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA.
18  *
19  */
20 
21 #include <memory>
22 #include <stdexcept>
23 #include "kinetic/threadsafe_blocking_kinetic_connection.h"
24 
25 namespace kinetic {
26 
27 using std::shared_ptr;
28 using std::unique_ptr;
29 using std::string;
30 using std::make_shared;
31 using std::move;
32 
33 ThreadsafeBlockingKineticConnection::ThreadsafeBlockingKineticConnection(
34  unique_ptr<BlockingKineticConnection> connection) : connection_(std::move(connection)){
35 }
36 
37 ThreadsafeBlockingKineticConnection::~ThreadsafeBlockingKineticConnection() {}
38 
39 KineticStatus ThreadsafeBlockingKineticConnection::NoOp() {
40  std::lock_guard<std::recursive_mutex> guard(mutex_);
41  return connection_->NoOp();
42 }
43 
44 void ThreadsafeBlockingKineticConnection::SetClientClusterVersion(int64_t cluster_version) {
45  std::lock_guard<std::recursive_mutex> guard(mutex_);
46  return connection_->SetClientClusterVersion(cluster_version);
47 }
48 
49 KineticStatus ThreadsafeBlockingKineticConnection::Get(const shared_ptr<const string> key,
50  unique_ptr<KineticRecord>& record) {
51  std::lock_guard<std::recursive_mutex> guard(mutex_);
52  return connection_->Get(key, record);
53 }
54 
55 KineticStatus ThreadsafeBlockingKineticConnection::Get(const string& key, unique_ptr<KineticRecord>& record) {
56  std::lock_guard<std::recursive_mutex> guard(mutex_);
57  return connection_->Get(key, record);
58 }
59 
60 KineticStatus ThreadsafeBlockingKineticConnection::Put(const shared_ptr<const string> key,
61  const shared_ptr<const string> current_version, WriteMode mode,
62  const shared_ptr<const KineticRecord> record,
63  PersistMode persistMode) {
64  std::lock_guard<std::recursive_mutex> guard(mutex_);
65  return connection_->Put(key, current_version, mode, record, persistMode);
66 }
67 
68 KineticStatus ThreadsafeBlockingKineticConnection::Put(const string& key,
69  const string& current_version, WriteMode mode,
70  const KineticRecord& record,
71  PersistMode persistMode) {
72  std::lock_guard<std::recursive_mutex> guard(mutex_);
73  return connection_->Put(key, current_version, mode, record, persistMode);
74 }
75 
76 KineticStatus ThreadsafeBlockingKineticConnection::Put(const shared_ptr<const string> key,
77  const shared_ptr<const string> current_version, WriteMode mode,
78  const shared_ptr<const KineticRecord> record) {
79  std::lock_guard<std::recursive_mutex> guard(mutex_);
80  return connection_->Put(key, current_version, mode, record);
81 }
82 
83 KineticStatus ThreadsafeBlockingKineticConnection::Put(const string& key,
84  const string& current_version, WriteMode mode,
85  const KineticRecord& record) {
86  std::lock_guard<std::recursive_mutex> guard(mutex_);
87  return connection_->Put(key, current_version, mode, record);
88 }
89 
90 KineticStatus ThreadsafeBlockingKineticConnection::Delete(const shared_ptr<const string> key,
91  const shared_ptr<const string> version, WriteMode mode, PersistMode persistMode) {
92  std::lock_guard<std::recursive_mutex> guard(mutex_);
93  return connection_->Delete(key, version, mode, persistMode);
94 }
95 
96 KineticStatus ThreadsafeBlockingKineticConnection::Delete(const string& key, const string& version,
97  WriteMode mode, PersistMode persistMode) {
98  std::lock_guard<std::recursive_mutex> guard(mutex_);
99  return connection_->Delete(key, version, mode, persistMode);
100 }
101 
102 KineticStatus ThreadsafeBlockingKineticConnection::Delete(const shared_ptr<const string> key,
103  const shared_ptr<const string> version, WriteMode mode) {
104  std::lock_guard<std::recursive_mutex> guard(mutex_);
105  return connection_->Delete(key, version, mode);
106 }
107 
108 KineticStatus ThreadsafeBlockingKineticConnection::Delete(const string& key, const string& version, WriteMode mode) {
109  std::lock_guard<std::recursive_mutex> guard(mutex_);
110  return connection_->Delete(key, version, mode);
111 }
112 
113 KineticStatus ThreadsafeBlockingKineticConnection::InstantErase(const shared_ptr<string> pin) {
114  std::lock_guard<std::recursive_mutex> guard(mutex_);
115  return connection_->InstantErase(pin);
116 }
117 
118 KineticStatus ThreadsafeBlockingKineticConnection::InstantErase(const string& pin) {
119  std::lock_guard<std::recursive_mutex> guard(mutex_);
120  return connection_->InstantErase(pin);
121 }
122 
123 KineticStatus ThreadsafeBlockingKineticConnection::SecureErase(const shared_ptr<string> pin) {
124  std::lock_guard<std::recursive_mutex> guard(mutex_);
125  return connection_->InstantErase(pin);
126 }
127 
128 KineticStatus ThreadsafeBlockingKineticConnection::SecureErase(const string& pin) {
129  std::lock_guard<std::recursive_mutex> guard(mutex_);
130  return connection_->InstantErase(pin);
131 }
132 
133 KineticStatus ThreadsafeBlockingKineticConnection::SetClusterVersion(int64_t new_cluster_version) {
134  std::lock_guard<std::recursive_mutex> guard(mutex_);
135  return connection_->SetClusterVersion(new_cluster_version);
136 }
137 
138 KineticStatus ThreadsafeBlockingKineticConnection::GetLog(unique_ptr<DriveLog>& drive_log) {
139  std::lock_guard<std::recursive_mutex> guard(mutex_);
140  return connection_->GetLog(drive_log);
141 }
142 
143 KineticStatus ThreadsafeBlockingKineticConnection::GetLog(const vector<Command_GetLog_Type>& types, unique_ptr<DriveLog>& drive_log) {
144  std::lock_guard<std::recursive_mutex> guard(mutex_);
145  return connection_->GetLog(types, drive_log);
146 }
147 
148 
149 KineticStatus ThreadsafeBlockingKineticConnection::UpdateFirmware(const shared_ptr<const string>
150  new_firmware) {
151  std::lock_guard<std::recursive_mutex> guard(mutex_);
152  return connection_->UpdateFirmware(new_firmware);
153 }
154 
155 KineticStatus ThreadsafeBlockingKineticConnection::SetACLs(const shared_ptr<const list<ACL>> acls) {
156  std::lock_guard<std::recursive_mutex> guard(mutex_);
157  return connection_->SetACLs(acls);
158 }
159 
160 KineticStatus ThreadsafeBlockingKineticConnection::SetErasePIN(const shared_ptr<const string> new_pin,
161  const shared_ptr<const string> current_pin) {
162  std::lock_guard<std::recursive_mutex> guard(mutex_);
163  return connection_->SetErasePIN(new_pin, current_pin);
164 }
165 
166 KineticStatus ThreadsafeBlockingKineticConnection::SetErasePIN(const string& new_pin, const string& current_pin) {
167  std::lock_guard<std::recursive_mutex> guard(mutex_);
168  return connection_->SetErasePIN(new_pin, current_pin);
169 }
170 
171 KineticStatus ThreadsafeBlockingKineticConnection::SetLockPIN(const shared_ptr<const string> new_pin,
172  const shared_ptr<const string> current_pin) {
173  std::lock_guard<std::recursive_mutex> guard(mutex_);
174  return connection_->SetLockPIN(new_pin, current_pin);
175 }
176 
177 KineticStatus ThreadsafeBlockingKineticConnection::SetLockPIN(const string& new_pin, const string& current_pin) {
178  std::lock_guard<std::recursive_mutex> guard(mutex_);
179  return connection_->SetLockPIN(new_pin, current_pin);
180 }
181 
182 KineticStatus ThreadsafeBlockingKineticConnection::LockDevice(const shared_ptr<string> pin){
183  std::lock_guard<std::recursive_mutex> guard(mutex_);
184  return connection_->LockDevice(pin);
185 }
186 
187 KineticStatus ThreadsafeBlockingKineticConnection::LockDevice(const string& pin){
188  std::lock_guard<std::recursive_mutex> guard(mutex_);
189  return connection_->LockDevice(pin);
190 }
191 
192 KineticStatus ThreadsafeBlockingKineticConnection::UnlockDevice(const shared_ptr<string> pin){
193  std::lock_guard<std::recursive_mutex> guard(mutex_);
194  return connection_->UnlockDevice(pin);
195 }
196 
197 KineticStatus ThreadsafeBlockingKineticConnection::UnlockDevice(const string& pin){
198  std::lock_guard<std::recursive_mutex> guard(mutex_);
199  return connection_->UnlockDevice(pin);
200 }
201 
202 KineticStatus ThreadsafeBlockingKineticConnection::GetNext(const shared_ptr<const string> key,
203  unique_ptr<string>& actual_key, unique_ptr<KineticRecord>& record) {
204  std::lock_guard<std::recursive_mutex> guard(mutex_);
205  return connection_->GetNext(key, actual_key, record);
206 }
207 
208 KineticStatus ThreadsafeBlockingKineticConnection::GetNext( const string& key, unique_ptr<string>& actual_key, unique_ptr<KineticRecord>& record) {
209  std::lock_guard<std::recursive_mutex> guard(mutex_);
210  return connection_->GetNext(key, actual_key, record);
211 }
212 
213 KineticStatus ThreadsafeBlockingKineticConnection::GetPrevious(const shared_ptr<const string> key,
214  unique_ptr<string>& actual_key, unique_ptr<KineticRecord>& record) {
215  std::lock_guard<std::recursive_mutex> guard(mutex_);
216  return connection_->GetNext(key, actual_key, record);
217 }
218 
219 KineticStatus ThreadsafeBlockingKineticConnection::GetPrevious(const string& key,
220  unique_ptr<string>& actual_key,
221  unique_ptr<KineticRecord>& record) {
222  std::lock_guard<std::recursive_mutex> guard(mutex_);
223  return connection_->GetNext(key, actual_key, record);
224 }
225 
226 KineticStatus ThreadsafeBlockingKineticConnection::GetVersion(const shared_ptr<const string> key,
227  unique_ptr<string>& version) {
228  std::lock_guard<std::recursive_mutex> guard(mutex_);
229  return connection_->GetVersion(key, version);
230 }
231 
232 KineticStatus ThreadsafeBlockingKineticConnection::GetVersion(const string& key, unique_ptr<string>& version){
233  std::lock_guard<std::recursive_mutex> guard(mutex_);
234  return connection_->GetVersion(key, version);
235 }
236 
237 KineticStatus ThreadsafeBlockingKineticConnection::GetKeyRange(const shared_ptr<const string> start_key,
238  bool start_key_inclusive,
239  const shared_ptr<const string> end_key,
240  bool end_key_inclusive,
241  bool reverse_results,
242  int32_t max_results,
243  unique_ptr<vector<string>>& keys) {
244  std::lock_guard<std::recursive_mutex> guard(mutex_);
245  return connection_->GetKeyRange(start_key,
246  start_key_inclusive,
247  end_key,
248  end_key_inclusive,
249  reverse_results,
250  max_results,
251  keys);
252 }
253 
254 KineticStatus ThreadsafeBlockingKineticConnection::GetKeyRange(const string& start_key,
255  bool start_key_inclusive,
256  const string& end_key,
257  bool end_key_inclusive,
258  bool reverse_results,
259  int32_t max_results,
260  unique_ptr<vector<string>>& keys) {
261  std::lock_guard<std::recursive_mutex> guard(mutex_);
262  return connection_->GetKeyRange(start_key,
263  start_key_inclusive,
264  end_key,
265  end_key_inclusive,
266  reverse_results,
267  max_results,
268  keys);
269 }
270 
271 KeyRangeIterator ThreadsafeBlockingKineticConnection::IterateKeyRange(
272  const shared_ptr<const string> start_key,
273  bool start_key_inclusive,
274  const shared_ptr<const string> end_key,
275  bool end_key_inclusive,
276  unsigned int frame_size) {
277  std::lock_guard<std::recursive_mutex> guard(mutex_);
278  return connection_->IterateKeyRange(start_key,
279  start_key_inclusive,
280  end_key,
281  end_key_inclusive,
282  frame_size);
283 }
284 
285 KeyRangeIterator ThreadsafeBlockingKineticConnection::IterateKeyRange(const string& start_key,
286  bool start_key_inclusive,
287  const string& end_key,
288  bool end_key_inclusive,
289  unsigned int frame_size){
290  std::lock_guard<std::recursive_mutex> guard(mutex_);
291  return connection_->IterateKeyRange(start_key,
292  start_key_inclusive,
293  end_key,
294  end_key_inclusive,
295  frame_size);
296 }
297 
298 KineticStatus ThreadsafeBlockingKineticConnection::P2PPush(
299  const shared_ptr<const P2PPushRequest> push_request,
300  unique_ptr<vector<KineticStatus>>& operation_statuses) {
301  std::lock_guard<std::recursive_mutex> guard(mutex_);
302  return connection_->P2PPush(push_request, operation_statuses);
303 }
304 
305 KineticStatus ThreadsafeBlockingKineticConnection::P2PPush(const P2PPushRequest& push_request,
306  unique_ptr<vector<KineticStatus>>& operation_statuses) {
307  std::lock_guard<std::recursive_mutex> guard(mutex_);
308  return connection_->P2PPush(push_request, operation_statuses);
309 }
310 
311 } // namespace kinetic