← Back to branch summary

~ubuntu-branches/debian/sid/nordugrid-arc/sid

« back to all changes in this revision

Viewing changes to src/services/a-rex/delegation/FileRecord.cpp

  • Committer: Package Import Robot
  • Author(s): Mattias Ellert
  • Date: 2012-12-13 16:41:31 UTC
  • mfrom: (1.1.5)
  • Revision ID: package-import@ubuntu.com-20121213164131-0fumka0jar8mxm07
Tags: 2.0.1-1
* 2.0.1 Release
* Drop patches accepted upstream

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/services/a-rex/delegation/FileRecord.cpp
2
2
#include <config.h>
3
3
#endif
4
4
 
 
5
#include <iostream>
5
6
#include <stdlib.h>
6
7
#include <fcntl.h>
7
8
#include <unistd.h>
8
9
#include <string.h>
9
 
#include <iostream>
 
10
#include <errno.h>
10
11
 
11
12
#include <glibmm.h>
12
13
 
16
17
 
17
18
namespace ARex {
18
19
 
19
 
  static int dberr(const char* s, int err) {
20
 
    //if(err != 0) std::cerr<<"DB ERROR("<<s<<"): "<<err<<std::endl;
21
 
    return err;
 
20
  bool FileRecord::dberr(const char* s, int err) {
 
21
    if(err == 0) return true;
 
22
    error_num_ = err;
 
23
    error_str_ = std::string(s)+": "+DbEnv::strerror(err);
 
24
    return false;
22
25
  }
23
26
 
24
 
  FileRecord::FileRecord(const std::string& base):
 
27
  FileRecord::FileRecord(const std::string& base, recovery recover):
25
28
      basepath_(base),
26
29
      db_rec_(NULL,DB_CXX_NO_EXCEPTIONS),
27
30
      db_lock_(NULL,DB_CXX_NO_EXCEPTIONS),
28
31
      db_locked_(NULL,DB_CXX_NO_EXCEPTIONS),
29
32
      db_link_(NULL,DB_CXX_NO_EXCEPTIONS),
 
33
      error_num_(0),
30
34
      valid_(false) {
31
 
    if(dberr("set 1",db_lock_.set_flags(DB_DUPSORT)) != 0) return;
32
 
    if(dberr("set 2",db_locked_.set_flags(DB_DUPSORT)) != 0) return;
33
 
    if(dberr("assoc1",db_link_.associate(NULL,&db_lock_,&locked_callback,0)) != 0) return;
34
 
    if(dberr("assoc2",db_link_.associate(NULL,&db_locked_,&lock_callback,0)) != 0) return;
35
 
    if(dberr("open 1",db_rec_.open(NULL,(basepath_+"/list").c_str(), "meta", DB_BTREE, DB_CREATE, S_IRUSR | S_IWUSR)) != 0) return;
36
 
    if(dberr("open 2",db_link_.open(NULL,(basepath_+"/list").c_str(), "link", DB_RECNO, DB_CREATE, S_IRUSR | S_IWUSR)) != 0) return;
37
 
    if(dberr("open 2",db_lock_.open(NULL,(basepath_+"/list").c_str(), "lock", DB_BTREE, DB_CREATE, S_IRUSR | S_IWUSR)) != 0) return;
38
 
    if(dberr("open 3",db_locked_.open(NULL,(basepath_+"/list").c_str(), "locked", DB_BTREE, DB_CREATE, S_IRUSR | S_IWUSR)) != 0) return;
39
 
    //if(db_rec_.associate(NULL,&db_uid_,&uid_callback,0) != 0) return;
40
 
    //if(db_rec_.associate(NULL,&db_id_,&id_callback,0) != 0) return;
 
35
    // db_link
 
36
    //    |---db_lock
 
37
    //    \---db_locked
 
38
    if(!dberr("Error setting flag DB_DUPSORT",db_lock_.set_flags(DB_DUPSORT))) return;
 
39
    if(!dberr("Error setting flag DB_DUPSORT",db_locked_.set_flags(DB_DUPSORT))) return;
 
40
    if(!dberr("Error associating databases",db_link_.associate(NULL,&db_lock_,&locked_callback,0))) return;
 
41
    if(!dberr("Error associating databases",db_link_.associate(NULL,&db_locked_,&lock_callback,0))) return;
 
42
    int oflags = DB_CREATE;
 
43
    std::string dbpath = basepath_+"/list";
 
44
    if(recover == ordinary_recovery) {
 
45
      oflags |= DB_RECOVER;
 
46
    } else if(recover == catastrophic_recovery) {
 
47
      oflags |= DB_RECOVER_FATAL;
 
48
    } else if(recover == full_recovery) {
 
49
      // Recreating all databases
 
50
      if(::unlink(dbpath.c_str()) != 0) {
 
51
        if(errno != ENOENT) {
 
52
          dberr("Error wiping database",errno);
 
53
          return;
 
54
        };
 
55
      };
 
56
    };
 
57
    if(!dberr("Error opening database 'meta'",db_rec_.open(NULL,dbpath.c_str(),   "meta",  DB_BTREE,oflags,S_IRUSR|S_IWUSR))) return;
 
58
    if(!dberr("Error opening database 'link'",db_link_.open(NULL,dbpath.c_str(),  "link",  DB_RECNO,oflags,S_IRUSR|S_IWUSR))) return;
 
59
    if(!dberr("Error opening database 'lock'",db_lock_.open(NULL,dbpath.c_str(),  "lock",  DB_BTREE,oflags,S_IRUSR|S_IWUSR))) return;
 
60
    if(!dberr("Error opening database 'locked'",db_locked_.open(NULL,dbpath.c_str(),"locked",DB_BTREE,oflags,S_IRUSR|S_IWUSR))) return;
41
61
    valid_ = true;
42
62
  }
43
63
 
 
64
  FileRecord::~FileRecord(void) {
 
65
    db_locked_.close(0);
 
66
    db_lock_.close(0);
 
67
    db_link_.close(0);
 
68
    db_rec_.close(0);
 
69
  }
 
70
 
44
71
  static void* store_string(const std::string& str, void* buf) {
45
72
    uint32_t l = str.length();
46
73
    unsigned char* p = (unsigned char*)buf;
195
222
    Dbt data;
196
223
    make_key(id,owner,key);
197
224
    void* pkey = key.get_data();
198
 
    if(dberr("find:get",db_rec_.get(NULL,&key,&data,0)) != 0) {
 
225
    if(!dberr("find:get",db_rec_.get(NULL,&key,&data,0))) {
199
226
      ::free(pkey);
200
227
      return "";
201
228
    };
214
241
    Dbt data;
215
242
    make_key(id,owner,key);
216
243
    void* pkey = key.get_data();
217
 
    if(dberr("modify:get",db_rec_.get(NULL,&key,&data,0)) != 0) {
 
244
    if(!dberr("modify:get",db_rec_.get(NULL,&key,&data,0))) {
218
245
      ::free(pkey);
219
246
      return false;
220
247
    };
225
252
    parse_record(uid,id_tmp,owner_tmp,meta_tmp,key,data);
226
253
    ::free(pkey);
227
254
    make_record(uid,id,owner,meta,key,data);
228
 
    if(dberr("modify.put",db_rec_.put(NULL,&key,&data,0)) != 0) {
 
255
    if(!dberr("modify.put",db_rec_.put(NULL,&key,&data,0))) {
229
256
      ::free(key.get_data());
230
257
      ::free(data.get_data());
231
258
      return false;
243
270
    Dbt data;
244
271
    make_key(id,owner,key);
245
272
    void* pkey = key.get_data();
246
 
    if(dberr("remove:get1",db_locked_.get(NULL,&key,&data,0)) == 0) {
 
273
    if(dberr("remove:get1",db_locked_.get(NULL,&key,&data,0))) {
247
274
      ::free(pkey);
248
275
      return false; // have locks
249
276
    };
250
 
    if(dberr("remove:get2",db_rec_.get(NULL,&key,&data,0)) != 0) {
 
277
    if(!dberr("remove:get2",db_rec_.get(NULL,&key,&data,0))) {
251
278
      ::free(pkey);
252
279
      return ""; // No such record?
253
280
    };
277
304
    for(std::list<std::string>::const_iterator id = ids.begin(); id != ids.end(); ++id) {
278
305
      make_link(lock_id,*id,owner,data);
279
306
      void* pdata = data.get_data();
280
 
      if(dberr("addlock:put",db_link_.put(NULL,&key,&data,DB_APPEND)) != 0) {
 
307
      if(!dberr("addlock:put",db_link_.put(NULL,&key,&data,DB_APPEND))) {
281
308
        ::free(pdata);
282
309
        return false;
283
310
      };
296
323
    if(!valid_) return false;
297
324
    Glib::Mutex::Lock lock(lock_);
298
325
    Dbc* cur = NULL;
299
 
    if(dberr("removelock:cursor",db_lock_.cursor(NULL,&cur,0)) != 0) return false;
 
326
    if(!dberr("removelock:cursor",db_lock_.cursor(NULL,&cur,0))) return false;
300
327
    Dbt key;
301
328
    Dbt data;
302
329
    make_string(lock_id,key);
303
330
    void* pkey = key.get_data();
304
 
    if(dberr("removelock:get1",cur->get(&key,&data,DB_SET)) != 0) { // TODO: handle errors
 
331
    if(!dberr("removelock:get1",cur->get(&key,&data,DB_SET))) { // TODO: handle errors
305
332
      ::free(pkey);
306
333
      cur->close(); return false;
307
334
    };
313
340
      buf = parse_string(id,buf,size);
314
341
      buf = parse_string(owner,buf,size);
315
342
      ids.push_back(std::pair<std::string,std::string>(id,owner));
316
 
      if(dberr("removelock:del",cur->del(0)) != 0) {
 
343
      if(!dberr("removelock:del",cur->del(0))) {
317
344
        ::free(pkey);
318
345
        cur->close(); return false;
319
346
      };
320
347
      db_lock_.sync(0);
321
 
      if(dberr("removelock:get2",cur->get(&key,&data,DB_NEXT_DUP)) != 0) break;
 
348
      if(!dberr("removelock:get2",cur->get(&key,&data,DB_NEXT_DUP))) break;
322
349
    };
323
350
    ::free(pkey);
324
351
    cur->close();
344
371
  }
345
372
 
346
373
  FileRecord::Iterator::Iterator(FileRecord& frec):frec_(frec),cur_(NULL) {
347
 
    if(dberr("Iterator:cursor",frec_.db_rec_.cursor(NULL,&cur_,0)) != 0) {
 
374
    if(!frec_.dberr("Iterator:cursor",frec_.db_rec_.cursor(NULL,&cur_,0))) {
348
375
      if(cur_) {
349
376
        cur_->close(); cur_=NULL;
350
377
      };
352
379
    };
353
380
    Dbt key;
354
381
    Dbt data;
355
 
    if(dberr("Iterator:first",cur_->get(&key,&data,DB_FIRST)) != 0) {
 
382
    if(!frec_.dberr("Iterator:first",cur_->get(&key,&data,DB_FIRST))) {
356
383
      cur_->close(); cur_=NULL;
357
384
      return;
358
385
    };
369
396
    if(!cur_) return *this;
370
397
    Dbt key;
371
398
    Dbt data;
372
 
    if(dberr("Iterator:first",cur_->get(&key,&data,DB_NEXT)) != 0) {
 
399
    if(!frec_.dberr("Iterator:first",cur_->get(&key,&data,DB_NEXT))) {
373
400
      cur_->close(); cur_=NULL;
374
401
      return *this;
375
402
    };
381
408
    if(!cur_) return *this;
382
409
    Dbt key;
383
410
    Dbt data;
384
 
    if(dberr("Iterator:first",cur_->get(&key,&data,DB_PREV)) != 0) {
 
411
    if(!frec_.dberr("Iterator:first",cur_->get(&key,&data,DB_PREV))) {
385
412
      cur_->close(); cur_=NULL;
386
413
      return *this;
387
414
    };