GenericObject.cpp 2.63 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
23
24
25
26
27
28
29
30

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
31
  m_header.ParseFromString(m_objectStore.read(getAddressIfSet()));
32
33
34
35
36
37
38
39
40
41
  m_headerInterpreted = true;
}

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

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

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");
}

53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
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();
74
75
76
77
78
79
    } break;
    case serializers::TapePool_t: {
      TapePool tp(*this);
      lock.transfer(tp);
      tp.garbageCollect();
    } break;
80
81
82
83
84
85
86
87
88
89
    default: {
      std::stringstream err;
      err << "In GenericObject::garbageCollect, unsupported type: "
          << m_header.type();
      throw UnsupportedType(err.str());
    }
  }
}


90
}}