Debian Codegraph @

src/file/davfile.cpp

raw
1 /*
2 * This File is part of Davix, The IO library for HTTP based protocols
3 * Copyright (C) CERN 2013
4 * Author: Adrien Devresse <[email protected]>
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA
19 *
20 */
21
22 #include <davix_internal.hpp>
23 #include <core/ContentProvider.hpp>
24 #include <file/davfile.hpp>
25 #include <fileops/chain_factory.hpp>
26
27 namespace Davix{
28
29
30 DavFile::Iterator createIterator(DavFile::DavFileInternal& f, const RequestParams * params);
31
32
33 struct DavFile::DavFileInternal{
34
35 DavFileInternal(Context & c, const Uri & u, const RequestParams & params = RequestParams()) :
36 _c(c), _u(u), _params(params) {}
37
38 DavFileInternal(const DavFileInternal & orig) : _c(orig._c), _u(orig._u), _params(orig._params) {}
39
40 Context & _c;
41 Uri _u;
42 RequestParams _params;
43
44 HttpIOChain & getIOChain(HttpIOChain & c){
45 return ChainFactory::instanceChain(CreationFlags(), c);
46 }
47
48 IOChainContext getIOContext(const RequestParams * params){
49 return IOChainContext(_c, _u, (params)?(params):(&_params));
50 }
51
52 DavFile::Iterator createIterator(const RequestParams * params);
53
54
55 static void check_iterator(DavFile::Iterator::Internal* ptr){
56 if(ptr == NULL)
57 throw DavixException(davix_scope_directory_listing_str(), StatusCode::InvalidArgument, "Usage of an invalid Iterator");
58 }
59
60
61 };
62
63
64 struct DavFile::Iterator::Internal{
65
66 Internal(DavFile::DavFileInternal & f, const RequestParams* p) :
67 io_chain(),
68 io_context(f.getIOContext(p))
69 {
70 f.getIOChain(io_chain);
71 io_chain.nextSubItem(io_context, name, info);
72 }
73
74 HttpIOChain io_chain;
75 IOChainContext io_context;
76 std::string name;
77 StatInfo info;
78 };
79
80
81
82
83 DavFile::Iterator DavFile::DavFileInternal::createIterator(const RequestParams * params){
84 DavFile::Iterator it;
85 it.d_ptr.reset(new DavFile::Iterator::Internal(*this, params));
86 return it;
87 }
88
89
90 bool DavFile::Iterator::next(){
91 return d_ptr->io_chain.nextSubItem(d_ptr->io_context, d_ptr->name, d_ptr->info);
92 }
93
94 const std::string & DavFile::Iterator::name(){
95 DavFileInternal::check_iterator(d_ptr.get());
96 return d_ptr->name;
97 }
98
99 const StatInfo & DavFile::Iterator::info(){
100 DavFileInternal::check_iterator(d_ptr.get());
101 return d_ptr->info;
102 }
103
104
105 DavFile::DavFile(Context &c, const Uri &u) :
106 d_ptr(new DavFileInternal(c,u))
107 {
108
109 }
110
111 DavFile::DavFile(Context &c, const RequestParams & params, const Uri &u) :
112 d_ptr(new DavFileInternal(c,u,params))
113 {
114
115 }
116
117
118
119 DavFile::DavFile(const DavFile & orig): d_ptr(new DavFileInternal(*orig.d_ptr)){
120
121 }
122
123 DavFile::~DavFile(){
124 delete d_ptr;
125 }
126
127
128 const Uri & DavFile::getUri() const{
129 return d_ptr->_u;
130 }
131
132
133 std::vector<DavFile> DavFile::getReplicas(const RequestParams *_params, DavixError **err) throw(){
134 std::vector<DavFile> res;
135 TRY_DAVIX{
136 HttpIOChain chain;
137 IOChainContext io_context = d_ptr->getIOContext(_params);
138 return d_ptr->getIOChain(chain).getReplicas(io_context, res);
139 }CATCH_DAVIX(err)
140 return res;
141 }
142
143
144 dav_ssize_t DavFile::getAllReplicas(const RequestParams* params, ReplicaVec & v, DavixError **err){
145 (void) params;
146 (void) v;
147 Davix::DavixError::setupError(err, davix_scope_http_request(), StatusCode::OperationNonSupported, " GetAllReplicas Function not supported, please use GetReplicas()");
148 return -1;
149 }
150
151 dav_ssize_t DavFile::readPartialBufferVec(const RequestParams *params, const DavIOVecInput * input_vec,
152 DavIOVecOuput * output_vec,
153 const dav_size_t count_vec, DavixError** err) throw(){
154 TRY_DAVIX{
155 HttpIOChain chain;
156 IOChainContext io_context = d_ptr->getIOContext(params);
157 return d_ptr->getIOChain(chain).preadVec(io_context, input_vec, output_vec, count_vec);
158 }CATCH_DAVIX(err)
159 return -1;
160 }
161
162
163 dav_ssize_t DavFile::readPartial(const RequestParams *params, void* buff, dav_size_t count, dav_off_t offset, DavixError** err) throw(){
164 TRY_DAVIX{
165 HttpIOChain chain;
166 IOChainContext io_context = d_ptr->getIOContext(params);
167 return d_ptr->getIOChain(chain).pread(io_context, buff, count, offset);
168 }CATCH_DAVIX(err)
169 return -1;
170 }
171
172 int DavFile::deletion(const RequestParams *params, DavixError **err) throw(){
173 TRY_DAVIX{
174 deletion(params);
175 return 0;
176 }CATCH_DAVIX(err)
177 return -1;
178 }
179
180 void DavFile::deletion(const RequestParams *params){
181 HttpIOChain chain;
182 IOChainContext io_context = d_ptr->getIOContext(params);
183 d_ptr->getIOChain(chain).deleteResource(io_context);
184 }
185
186 dav_ssize_t DavFile::getToFd(const RequestParams* params,
187 int fd,
188 DavixError** err) throw(){
189 TRY_DAVIX{
190 return DavFile::getToFd(params, fd, 0, err);
191 }CATCH_DAVIX(err)
192 return -1;
193 }
194
195 dav_ssize_t DavFile::getToFd(const RequestParams* params,
196 int fd,
197 dav_size_t size_read,
198 DavixError** err) throw(){
199 TRY_DAVIX{
200 HttpIOChain chain;
201 IOChainContext io_context = d_ptr->getIOContext(params);
202 return d_ptr->getIOChain(chain).readToFd(io_context, fd, size_read);
203 }CATCH_DAVIX(err)
204 return -1;
205 }
206
207
208
209 dav_ssize_t DavFile::getFull(const RequestParams* params,
210 std::vector<char> & buffer,
211 DavixError** err) throw(){
212 TRY_DAVIX{
213 return get(params, buffer);
214 }CATCH_DAVIX(err)
215 return -1;
216 }
217
218
219 dav_ssize_t DavFile::get(const RequestParams* params,
220 std::vector<char> & buffer){
221 HttpIOChain chain;
222 IOChainContext io_context = d_ptr->getIOContext(params);
223 return d_ptr->getIOChain(chain).readFull(io_context, buffer);
224 }
225
226
227 int DavFile::putFromFd(const RequestParams* params,
228 int fd,
229 dav_size_t size,
230 DavixError** err) throw(){
231 TRY_DAVIX{
232 put(params, fd, size);
233 return 0;
234 }CATCH_DAVIX(err)
235 return -1;
236 }
237
238 void DavFile::put(const RequestParams *params, int fd, dav_size_t size_write){
239 HttpIOChain chain;
240 IOChainContext io_context = d_ptr->getIOContext(params);
241
242 FdContentProvider provider(fd, 0, size_write);
243 d_ptr->getIOChain(chain).writeFromProvider(io_context, provider);
244 }
245
246 void DavFile::put(const RequestParams *params, const DataProviderFun &callback, dav_size_t size_write){
247 HttpIOChain chain;
248 IOChainContext io_context = d_ptr->getIOContext(params);
249
250 CallbackContentProvider provider(callback, size_write);
251 d_ptr->getIOChain(chain).writeFromProvider(io_context, provider);
252 }
253
254 void DavFile::put(const RequestParams *params, const char *buffer, dav_size_t size_write){
255 HttpIOChain chain;
256 IOChainContext io_context = d_ptr->getIOContext(params);
257
258 BufferContentProvider provider(buffer, size_write);
259 d_ptr->getIOChain(chain).writeFromProvider(io_context, provider);
260 }
261
262 void DavFile::move(const RequestParams *params, DavFile & destination){
263 HttpIOChain chain;
264 IOChainContext io_context = d_ptr->getIOContext(params);
265 d_ptr->getIOChain(chain).move(io_context, destination.getUri().getString());
266 }
267
268
269
270 int DavFile::makeCollection(const RequestParams *params, DavixError **err) throw(){
271 TRY_DAVIX{
272 makeCollection(params);
273 return 0;
274 }CATCH_DAVIX(err)
275 return -1;
276 }
277
278
279 void DavFile::makeCollection(const RequestParams *params){
280 RequestParams _params(params);
281 HttpIOChain chain;
282 IOChainContext io_context = d_ptr->getIOContext(params);
283 d_ptr->getIOChain(chain).makeCollection(io_context);
284 }
285
286 int DavFile::stat(const RequestParams* params, struct stat * st, DavixError** err) throw(){
287 TRY_DAVIX{
288 if(st == NULL)
289 throw DavixException(davix_scope_meta(), StatusCode::InvalidArgument, "Argument stat NULL");
290
291 StatInfo info;
292 statInfo(params, info).toPosixStat(*st);
293 return 0;
294 }CATCH_DAVIX(err)
295 return -1;
296 }
297
298 StatInfo& DavFile::statInfo(const RequestParams *params, StatInfo &info){
299 HttpIOChain chain;
300 IOChainContext io_context = d_ptr->getIOContext(params);
301 d_ptr->getIOChain(chain).statInfo(io_context, info);
302 return info;
303 }
304
305 QuotaInfo& DavFile::quotaInfo(const RequestParams *params, QuotaInfo &info) {
306 HttpIOChain chain;
307 IOChainContext io_context = d_ptr->getIOContext(params);
308 d_ptr->getIOChain(chain).quotaInfo(io_context, info);
309 return info;
310 }
311
312 DavFile::Iterator DavFile::listCollection(const RequestParams *params){
313 return d_ptr->createIterator(params);
314 }
315
316 int DavFile::checksum(const RequestParams *params, std::string & checksm, const std::string & chk_algo, DavixError **err) throw(){
317 TRY_DAVIX{
318 HttpIOChain chain;
319 IOChainContext io_context = d_ptr->getIOContext(params);
320 d_ptr->getIOChain(chain).checksum(io_context, checksm, chk_algo);
321 return 0;
322 }CATCH_DAVIX(err)
323 return -1;
324 }
325
326 void DavFile::prefetchInfo(off_t offset, dav_size_t size_read, advise_t adv){
327 HttpIOChain chain;
328 IOChainContext io_context = d_ptr->getIOContext(NULL);
329 d_ptr->getIOChain(chain).prefetchInfo(io_context, offset, size_read, adv);
330 }
331
332
333
334 } //Davix
335
336
337
338 std::ostream & operator<<(std::ostream & out, Davix::DavFile & file){
339 std::vector<char> buffer;
340
341 file.get(NULL, buffer);
342 out.write(&buffer[0], buffer.size());
343 return out;
344 }
345
346 std::istream & operator>>(std::istream & in, Davix::DavFile & file){
347 std::vector<char> buffer((std::istream_iterator<char>(in)), std::istream_iterator<char>());
348
349 file.put(NULL, &(buffer.at(0)), buffer.size());
350 return in;
351 }