GenericObject.cpp 3.16 KB
Newer Older
1
/*
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
 * The CERN Tape Archive (CTA) project
 * Copyright (C) 2015  CERN
 *
 * This program is free software: you can redistribute it and/or modify
 * it under the terms of the GNU General Public License as published by
 * the Free Software Foundation, either version 3 of the License, or
 * (at your option) any later version.
 *
 * 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 General Public License for more details.
 *
 * You should have received a copy of the GNU General Public License
 * along with this program.  If not, see <http://www.gnu.org/licenses/>.
 */

19
#include "GenericObject.hpp"
20
#include "AgentRegister.hpp"
21
#include "TapePool.hpp"
22
#include "DriveRegister.hpp"
23
24
25
26
27
28
29
30
31

namespace cta {  namespace objectstore {

void GenericObject::fetch() {
  // Check that the object is locked, one way or another
  if(!m_locksCount)
    throw NotLocked("In ObjectOps::fetch(): object not locked");
  m_existingObject = true;
  // Get the header from the object store. We don't care for the type
32
  m_header.ParseFromString(m_objectStore.read(getAddressIfSet()));
33
34
35
36
37
38
39
40
41
42
  m_headerInterpreted = true;
}

serializers::ObjectType GenericObject::type() {
  checkHeaderReadable();
  return m_header.type();
}

void GenericObject::commit() {
  checkHeaderWritable();
43
  m_objectStore.atomicOverwrite(getAddressIfSet(), m_header.SerializeAsString());
44
45
46
47
48
49
50
51
52
53
}

void GenericObject::insert() {
  throw ForbiddenOperation("In GenericObject::insert: this operation is not possible");
}

void GenericObject::initialize() {
  throw ForbiddenOperation("In GenericObject::initialize: this operation is not possible");
}

54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
void GenericObject::transplantHeader(ObjectOpsBase& destination) {
  destination.m_header = m_header;
  destination.m_existingObject = m_existingObject;
  destination.m_headerInterpreted = m_headerInterpreted;
  destination.m_name = m_name;
  destination.m_nameSet = m_nameSet;
  destination.m_payloadInterpreted = false;
    }

Backend& GenericObject::objectStore() {
  return m_objectStore;
}


void GenericObject::garbageCollect(ScopedExclusiveLock& lock) {
  checkHeaderWritable();
  switch(m_header.type()) {
    case serializers::AgentRegister_t: {
      AgentRegister ar(*this);
      lock.transfer(ar);
      ar.garbageCollect();
75
76
77
      // Release the lock now as if we let the caller do, it will point
      // to the then-removed ar.
      lock.release();
78
79
80
81
82
    } break;
    case serializers::TapePool_t: {
      TapePool tp(*this);
      lock.transfer(tp);
      tp.garbageCollect();
83
84
85
      // Release the lock now as if we let the caller do, it will point
      // to the then-removed tp.
      lock.release();
86
    } break;
87
88
89
90
    case serializers::DriveRegister_t: {
      DriveRegister dr(*this);
      lock.transfer(dr);
      dr.garbageCollect();
91
92
93
      // Release the lock now as if we let the caller do, it will point
      // to the then-removed dr.
      lock.release();
94
    } break;
95
96
97
98
99
100
101
102
103
104
    default: {
      std::stringstream err;
      err << "In GenericObject::garbageCollect, unsupported type: "
          << m_header.type();
      throw UnsupportedType(err.str());
    }
  }
}


105
}}