RdbmsCatalogue.hpp 46.9 KB
Newer Older
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
/*
 * 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/>.
 */

#pragma once

#include "catalogue/Catalogue.hpp"
22
#include "catalogue/RequesterAndGroupMountPolicies.hpp"
Steven Murray's avatar
Steven Murray committed
23
#include "catalogue/TimeBasedCache.hpp"
24
#include "common/threading/Mutex.hpp"
25
#include "rdbms/ConnPool.hpp"
26
#include "rdbms/Login.hpp"
27

28
#include <memory>
29

30
31
32
33
34
35
36
namespace cta {
namespace common {
namespace dataStructures {

/**
 * Forward declaration.
 */
37
class TapeFile;
38
39
40
41
42

} // namespace dataStructures
} // namespace catalogue
} // namespace cta

43
44
45
namespace cta {
namespace catalogue {

46
47
48
49
50
/**
 * Forward declaration.
 */
class ArchiveFileRow;

51
52
53
/**
 * Forward declaration.
 */
54
class RdbmsCatalogueGetArchiveFilesItor;
55

56
/**
Steven Murray's avatar
Steven Murray committed
57
 * CTA catalogue implemented using a relational database backend.
58
 */
59
class RdbmsCatalogue: public Catalogue {
60
protected:
61

62
63
64
  /**
   * Protected constructor only to be called by sub-classes.
   *
65
   * @param log Object representing the API to the CTA logging system.
66
67
   * @param login The database login details to be used to create new
   * connections.
68
69
70
71
72
73
   * @param nbConns The maximum number of concurrent connections to the
   * underlying relational database for all operations accept listing archive
   * files which can be relatively long operations.
   * @param nbArchiveFileListingConns The maximum number of concurrent
   * connections to the underlying relational database for the sole purpose of
   * listing archive files.
74
   */
75
76
  RdbmsCatalogue(
    log::Logger &log,
77
    const rdbms::Login &login,
78
    const uint64_t nbConns,
79
    const uint64_t nbArchiveFileListingConns);
80

81
82
public:

83
84
85
  /**
   * Destructor.
   */
86
  ~RdbmsCatalogue() override;
87

88
89
90
  /////////////////////////////////////////////////////////////////////
  // START OF METHODS DIRECTLY INVOLVED IN DATA TRANSFER AND SCHEDULING
  /////////////////////////////////////////////////////////////////////
91
92
93
94
95
96
97
98

  /**
   * Notifies the catalogue that the specified tape was labelled.
   *
   * @param vid The volume identifier of the tape.
   * @param drive The name of tape drive that was used to label the tape.
   * @param lbpIsOn Set to true if Logical Block Protection (LBP) was enabled.
   */
99
  void tapeLabelled(const std::string &vid, const std::string &drive, const bool lbpIsOn) override;
100

101
  /**
102
103
104
   * Checks the specified archival could take place and returns a new and
   * unique archive file identifier that can be used by a new archive file
   * within the catalogue.
105
106
107
108
109
110
111
112
113
114
   *
   * @param diskInstanceName The name of the disk instance to which the
   * storage class belongs.
   * @param storageClassName The name of the storage class of the file to be
   * archived.  The storage class name is only guaranteed to be unique within
   * its disk instance.  The storage class name will be used by the Catalogue
   * to determine the destination tape pool for each tape copy.
   * @param user The user for whom the file is to be archived.  This will be
   * used by the Catalogue to determine the mount policy to be used when
   * archiving the file.
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
   * @return The new archive file identifier.
   */
  uint64_t checkAndGetNextArchiveFileId(
    const std::string &diskInstanceName,
    const std::string &storageClassName,
    const common::dataStructures::UserIdentity &user) override;

  /**
   * Returns the information required to queue an archive request.
   *
   * @param diskInstanceName The name of the disk instance to which the
   * storage class belongs.
   * @param storageClassName The name of the storage class of the file to be
   * archived.  The storage class name is only guaranteed to be unique within
   * its disk instance.  The storage class name will be used by the Catalogue
   * to determine the destination tape pool for each tape copy.
   * @param user The user for whom the file is to be archived.  This will be
   * used by the Catalogue to determine the mount policy to be used when
   * archiving the file.
   * @return The information required to queue an archive request.
135
136
137
138
139
140
   */
  common::dataStructures::ArchiveFileQueueCriteria getArchiveFileQueueCriteria(
    const std::string &diskInstanceName,
    const std::string &storageClassName,
    const common::dataStructures::UserIdentity &user) override;

141
142
143
144
145
146
  /**
   * Returns the list of tapes that can be written to by a tape drive in the
   * specified logical library, in other words tapes that are labelled, not
   * disabled, not full and are in the specified logical library.
   *
   * @param logicalLibraryName The name of the logical library.
147
   * @return The list of tapes for writing.
148
   */
149
  std::list<TapeForWriting> getTapesForWriting(const std::string &logicalLibraryName) const override;
150
151

  /**
152
153
154
155
156
   * Notifies the CTA catalogue that the specified tape has been mounted in
   * order to archive files.
   *
   * The purpose of this method is to keep track of which drive mounted a given
   * tape for archiving files last.
157
158
   *
   * @param vid The volume identifier of the tape.
159
   * @param drive The name of the drive where the tape was mounted.
160
   */
161
  void tapeMountedForArchive(const std::string &vid, const std::string &drive) override;
162

163
  /**
164
165
   * Prepares for a file retrieval by returning the information required to
   * queue the associated retrieve request(s).
166
   *
167
168
   * @param diskInstanceName The name of the instance from where the retrieval
   * request originated
169
170
171
172
173
   * @param archiveFileId The unique identifier of the archived file that is
   * to be retrieved.
   * @param user The user for whom the file is to be retrieved.  This will be
   * used by the Catalogue to determine the mount policy to be used when
   * retrieving the file.
174
   * @param lc The log context.
175
176
   *
   * @return The information required to queue the associated retrieve request(s).
177
   */
178
  common::dataStructures::RetrieveFileQueueCriteria prepareToRetrieveFile(
179
    const std::string &diskInstanceName,
180
    const uint64_t archiveFileId,
181
182
    const common::dataStructures::UserIdentity &user,
    log::LogContext &lc) override;
183
184
185
186
187

  /**
   * Notifies the CTA catalogue that the specified tape has been mounted in
   * order to retrieve files.
   *
188
189
190
   * The purpose of this method is to keep track of which drive mounted a given
   * tape for retrieving files last.
   *
191
192
193
   * @param vid The volume identifier of the tape.
   * @param drive The name of the drive where the tape was mounted.
   */
194
  void tapeMountedForRetrieve(const std::string &vid, const std::string &drive) override;
195

196
197
198
199
200
201
  /**
   * This method notifies the CTA catalogue that there is no more free space on
   * the specified tape.
   *
   * @param vid The volume identifier of the tape.
   */
202
  void noSpaceLeftOnTape(const std::string &vid) override;
203
204
205
206

  ///////////////////////////////////////////////////////////////////
  // END OF METHODS DIRECTLY INVOLVED IN DATA TRANSFER AND SCHEDULING
  ///////////////////////////////////////////////////////////////////
207

Steven Murray's avatar
Steven Murray committed
208
  void createAdminUser(const common::dataStructures::SecurityIdentity &admin, const std::string &username, const std::string &comment) override;
209
210
  void deleteAdminUser(const std::string &username) override;
  std::list<common::dataStructures::AdminUser> getAdminUsers() const override;
Steven Murray's avatar
Steven Murray committed
211
  void modifyAdminUserComment(const common::dataStructures::SecurityIdentity &admin, const std::string &username, const std::string &comment) override;
212

213
214
215
  /**
   * Creates the specified storage class.
   *
Steven Murray's avatar
Steven Murray committed
216
   * @param admin The administrator.
217
218
   * @param storageClass The storage class.
   */
219
  void createStorageClass(
Steven Murray's avatar
Steven Murray committed
220
    const common::dataStructures::SecurityIdentity &admin,
221
    const common::dataStructures::StorageClass &storageClass) override;
222
223
224
225
226
227
228
229
230

  /**
   * Deletes the specified storage class.
   *
   * @param diskInstanceName The name of the disk instance to which the
   * storage class belongs.
   * @param stoargeClassName The name of the storage class which is only
   * guaranteed to be unique within its disk isntance.
   */
231
  void deleteStorageClass(const std::string &diskInstanceName, const std::string &storageClassName) override;
232

233
  std::list<common::dataStructures::StorageClass> getStorageClasses() const override;
Steven Murray's avatar
Steven Murray committed
234
235
  void modifyStorageClassNbCopies(const common::dataStructures::SecurityIdentity &admin, const std::string &instanceName, const std::string &name, const uint64_t nbCopies) override;
  void modifyStorageClassComment(const common::dataStructures::SecurityIdentity &admin, const std::string &instanceName, const std::string &name, const std::string &comment) override;
236

237
  void createTapePool(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const std::string &vo, const uint64_t nbPartialTapes, const bool encryptionValue, const std::string &comment) override;
238
  void deleteTapePool(const std::string &name) override;
239
  std::list<TapePool> getTapePools() const override;
240
  void modifyTapePoolVo(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const std::string &vo) override;
Steven Murray's avatar
Steven Murray committed
241
242
243
  void modifyTapePoolNbPartialTapes(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const uint64_t nbPartialTapes) override;
  void modifyTapePoolComment(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const std::string &comment) override;
  void setTapePoolEncryption(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const bool encryptionValue) override;
244

245
  void createArchiveRoute(
Steven Murray's avatar
Steven Murray committed
246
    const common::dataStructures::SecurityIdentity &admin,
247
248
249
250
    const std::string &diskInstanceName,
    const std::string &storageClassName,
    const uint64_t copyNb,
    const std::string &tapePoolName,
251
    const std::string &comment) override;
252
253
254
255
256
257
258
259
260
261
262


  /**
   * Deletes the specified archive route.
   *
   * @param diskInstanceName The name of the disk instance to which the storage
   * class belongs.
   * @param storageClassName The name of the storage class which is only
   * guaranteed to be unique within its disk instance.
   * @param copyNb The copy number of the tape file.
   */
263
  void deleteArchiveRoute(
264
265
    const std::string &diskInstanceName,
    const std::string &storageClassName, 
266
    const uint64_t copyNb) override;
267

268
  std::list<common::dataStructures::ArchiveRoute> getArchiveRoutes() const override;
Steven Murray's avatar
Steven Murray committed
269
270
  void modifyArchiveRouteTapePoolName(const common::dataStructures::SecurityIdentity &admin, const std::string &instanceName, const std::string &storageClassName, const uint64_t copyNb, const std::string &tapePoolName) override;
  void modifyArchiveRouteComment(const common::dataStructures::SecurityIdentity &admin, const std::string &instanceName, const std::string &storageClassName, const uint64_t copyNb, const std::string &comment) override;
271

Steven Murray's avatar
Steven Murray committed
272
  void createLogicalLibrary(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const std::string &comment) override;
273
274
  void deleteLogicalLibrary(const std::string &name) override;
  std::list<common::dataStructures::LogicalLibrary> getLogicalLibraries() const override;
Steven Murray's avatar
Steven Murray committed
275
  void modifyLogicalLibraryComment(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const std::string &comment) override;
276

277
  /**
278
   * Creates a tape.
279
   */
280
  void createTape(
Steven Murray's avatar
Steven Murray committed
281
    const common::dataStructures::SecurityIdentity &admin,
282
    const std::string &vid,
283
284
    const std::string &mediaType,
    const std::string &vendor,
285
286
287
288
289
    const std::string &logicalLibraryName,
    const std::string &tapePoolName,
    const uint64_t capacityInBytes,
    const bool disabled,
    const bool full,
290
    const std::string &comment) override;
291

292
  void deleteTape(const std::string &vid) override;
293
294
295
296
297
298
299

  /**
   * Returns the list of tapes that meet the specified search criteria.
   *
   * @param searchCriteria The search criteria.
   * @return The list of tapes.
   */
300
  std::list<common::dataStructures::Tape> getTapes(const TapeSearchCriteria &searchCriteria) const override;
301

302
303
304
305
306
307
308
309
310
  /**
   * Returns the tapes with the specified volume identifiers.
   *
   * This method will throw an exception if it cannot find ALL of the specified
   * tapes.
   *
   * @param vids The tape volume identifiers (VIDs).
   * @return Map from tape volume identifier to tape.
   */
311
  common::dataStructures::VidToTapeMap getTapesByVid(const std::set<std::string> &vids) const override;
312

Steven Murray's avatar
Steven Murray committed
313
314
315
316
317
318
319
  /**
   * Returns all the tapes within the CTA catalogue.
   *
   * @return Map from tape volume identifier to tape.
   */
  common::dataStructures::VidToTapeMap getAllTapes() const override;

320
321
322
323
324
325
326
327
328
329
  /**
   * Reclaims the specified tape.
   *
   * This method will throw an exception if the specified tape does not exist.
   *
   * This method will throw an exception if the specified tape is not FULL.
   *
   * This method will throw an exception if there is still at least one tape
   * file recorded in the cataligue as being on the specified tape.
   *
Steven Murray's avatar
Steven Murray committed
330
   * @param admin The administrator.
331
332
   * @param vid The volume identifier of the tape to be reclaimed.
   */
Steven Murray's avatar
Steven Murray committed
333
  void reclaimTape(const common::dataStructures::SecurityIdentity &admin, const std::string &vid) override;
334

335
336
  void modifyTapeMediaType(const common::dataStructures::SecurityIdentity &admin, const std::string &vid, const std::string &mediaType) override;
  void modifyTapeVendor(const common::dataStructures::SecurityIdentity &admin, const std::string &vid, const std::string &vendor) override;
Steven Murray's avatar
Steven Murray committed
337
338
339
340
  void modifyTapeLogicalLibraryName(const common::dataStructures::SecurityIdentity &admin, const std::string &vid, const std::string &logicalLibraryName) override;
  void modifyTapeTapePoolName(const common::dataStructures::SecurityIdentity &admin, const std::string &vid, const std::string &tapePoolName) override;
  void modifyTapeCapacityInBytes(const common::dataStructures::SecurityIdentity &admin, const std::string &vid, const uint64_t capacityInBytes) override;
  void modifyTapeEncryptionKey(const common::dataStructures::SecurityIdentity &admin, const std::string &vid, const std::string &encryptionKey) override;
341
342
343
344
345
346
347

  /**
   * Sets the full status of the specified tape.
   *
   * Please note that this method is to be called by the CTA front-end in
   * response to a command from the CTA command-line interface (CLI).
   *
Steven Murray's avatar
Steven Murray committed
348
   * @param admin The administrator.
349
350
351
   * @param vid The volume identifier of the tape to be marked as full.
   * @param fullValue Set to true if the tape is full.
   */
Steven Murray's avatar
Steven Murray committed
352
  void setTapeFull(const common::dataStructures::SecurityIdentity &admin, const std::string &vid, const bool fullValue) override;
353

Steven Murray's avatar
Steven Murray committed
354
355
  void setTapeDisabled(const common::dataStructures::SecurityIdentity &admin, const std::string &vid, const bool disabledValue) override;
  void modifyTapeComment(const common::dataStructures::SecurityIdentity &admin, const std::string &vid, const std::string &comment) override;
356

Steven Murray's avatar
Steven Murray committed
357
358
359
360
  void modifyRequesterMountRulePolicy(const common::dataStructures::SecurityIdentity &admin, const std::string &instanceName, const std::string &requesterName, const std::string &mountPolicy) override;
  void modifyRequesteMountRuleComment(const common::dataStructures::SecurityIdentity &admin, const std::string &instanceName, const std::string &requesterName, const std::string &comment) override;
  void modifyRequesterGroupMountRulePolicy(const common::dataStructures::SecurityIdentity &admin, const std::string &instanceName, const std::string &requesterGroupName, const std::string &mountPolicy) override;
  void modifyRequesterGroupMountRuleComment(const common::dataStructures::SecurityIdentity &admin, const std::string &instanceName, const std::string &requesterGroupName, const std::string &comment) override;
361

362
  void createMountPolicy(
Steven Murray's avatar
Steven Murray committed
363
    const common::dataStructures::SecurityIdentity &admin,
364
365
366
367
368
369
    const std::string &name,
    const uint64_t archivePriority,
    const uint64_t minArchiveRequestAge,
    const uint64_t retrievePriority,
    const uint64_t minRetrieveRequestAge,
    const uint64_t maxDrivesAllowed,
370
    const std::string &comment) override;
371

372
  /**
373
   * Returns the list of all existing mount policies.
374
   *
375
376
   * @return the list of all existing mount policies.
   */
377
  std::list<common::dataStructures::MountPolicy> getMountPolicies() const override;
378
379
380
381
382
383

  /**
   * Deletes the specified mount policy.
   *
   * @param name The name of the mount policy.
   */
384
  void deleteMountPolicy(const std::string &name) override;
385
386
387
388
389
390
391

  /**
   * Creates the rule that the specified mount policy will be used for the
   * specified requester.
   *
   * Please note that requester mount-rules overrule requester-group
   * mount-rules.
392
   *
Steven Murray's avatar
Steven Murray committed
393
   * @param admin The administrator.
394
   * @param mountPolicyName The name of the mount policy.
395
396
397
398
   * @param diskInstance The name of the disk instance to which the requester
   * belongs.
   * @param requesterName The name of the requester which is only guarantted to
   * be unique within its disk instance.
399
400
   * @param comment Comment.
   */
401
  void createRequesterMountRule(
Steven Murray's avatar
Steven Murray committed
402
    const common::dataStructures::SecurityIdentity &admin,
403
    const std::string &mountPolicyName,
404
    const std::string &diskInstance,
405
    const std::string &requesterName,
406
    const std::string &comment) override;
407
408

  /**
409
410
411
412
413
414
   * Returns the rules that specify which mount policy is be used for which
   * requester.
   *
   * @return the rules that specify which mount policy is be used for which
   * requester.
   */
415
  std::list<common::dataStructures::RequesterMountRule> getRequesterMountRules() const override;
416
417
418
419

  /**
   * Deletes the specified mount rule.
   *
420
421
422
423
   * @param diskInstanceName The name of the disk instance to which the
   * requester belongs.
   * @param requesterName The name of the requester which is only guaranteed to
   * be unique within its disk instance.
424
   */
425
  void deleteRequesterMountRule(const std::string &diskInstanceName, const std::string &requesterName) override;
426
427
428
429

  /**
   * Creates the rule that the specified mount policy will be used for the
   * specified requester group.
430
   *
431
432
   * Please note that requester mount-rules overrule requester-group
   * mount-rules.
433
   *
Steven Murray's avatar
Steven Murray committed
434
   * @param admin The administrator.
435
   * @param mountPolicyName The name of the mount policy.
436
437
438
439
   * @param diskInstanceName The name of the disk instance to which the
   * requester group belongs.
   * @param requesterGroupName The name of the requester group which is only
   * guarantted to be unique within its disk instance.
440
441
   * @param comment Comment.
   */
442
  void createRequesterGroupMountRule(
Steven Murray's avatar
Steven Murray committed
443
    const common::dataStructures::SecurityIdentity &admin,
444
    const std::string &mountPolicyName,
445
    const std::string &diskInstanceName,
446
    const std::string &requesterGroupName,
447
    const std::string &comment) override;
448
449
450
451
452
453
454

  /**
   * Returns the rules that specify which mount policy is be used for which
   * requester group.
   *
   * @return the rules that specify which mount policy is be used for which
   * requester group.
455
   */
456
  std::list<common::dataStructures::RequesterGroupMountRule> getRequesterGroupMountRules() const override;
457
458
459
460

  /**
   * Deletes the specified mount rule.
   *
461
462
463
464
   * @param diskInstanceName The name of the disk instance to which the
   * requester group belongs.
   * @param requesterGroupName The name of the requester group which is only
   * guaranteed to be unique within its disk instance.
465
   */
466
  void deleteRequesterGroupMountRule(
467
    const std::string &diskInstanceName,
468
469
    const std::string &requesterGroupName) override;

Steven Murray's avatar
Steven Murray committed
470
471
472
473
474
475
  void modifyMountPolicyArchivePriority(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const uint64_t archivePriority) override;
  void modifyMountPolicyArchiveMinRequestAge(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const uint64_t minArchiveRequestAge) override;
  void modifyMountPolicyRetrievePriority(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const uint64_t retrievePriority) override;
  void modifyMountPolicyRetrieveMinRequestAge(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const uint64_t minRetrieveRequestAge) override;
  void modifyMountPolicyMaxDrivesAllowed(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const uint64_t maxDrivesAllowed) override;
  void modifyMountPolicyComment(const common::dataStructures::SecurityIdentity &admin, const std::string &name, const std::string &comment) override;
476

477
  /**
478
479
   * Throws a UserError exception if the specified searchCriteria is not valid
   * due to a user error.
480
481
482
   *
   * @param searchCriteria The search criteria.
   */
483
  void checkTapeFileSearchCriteria(const TapeFileSearchCriteria &searchCriteria) const;
484

485
  /**
486
487
   * Returns the specified archive files.  Please note that the list of files
   * is ordered by archive file ID.
488
489
   *
   * @param searchCriteria The search criteria.
490
   * @return The archive files.
491
   */
492
  ArchiveFileItor getArchiveFiles(const TapeFileSearchCriteria &searchCriteria) const override;
493

494
  /**
495
   * Returns the specified files in tape file sequence order.
496
497
498
499
500
   *
   * @param vid The volume identifier of the tape.
   * @param startFSeq The file sequence number of the first file.  Please note
   * that there might not be a file with this exact file sequence number.
   * @param maxNbFiles The maximum number of files to be returned.
501
   * @return The specified files in tape file sequence order.
502
   */
503
  std::list<common::dataStructures::ArchiveFile> getFilesForRepack(
504
505
506
507
    const std::string &vid,
    const uint64_t startFSeq,
    const uint64_t maxNbFiles) const override;

508
  /**
509
   * Returns a summary of the tape files that meet the specified search
510
511
512
513
514
   * criteria.
   *
   * @param searchCriteria The search criteria.
   * @return The summary.
   */
515
  common::dataStructures::ArchiveFileSummary getTapeFileSummary(
516
    const TapeFileSearchCriteria &searchCriteria) const override;
517
518
519
520
521
522
523
524
525
526

  /**
   * Returns the archive file with the specified unique identifier.
   *
   * This method assumes that the archive file being requested exists and will
   * therefore throw an exception if it does not.
   *
   * @param id The unique identifier of the archive file.
   * @return The archive file.
   */
527
  common::dataStructures::ArchiveFile getArchiveFileById(const uint64_t id) override;
528

529
  /**
530
   * Returns true if the specified user has administrator privileges.
531
   *
Steven Murray's avatar
Steven Murray committed
532
   * @param admin The administrator.
533
   * @return True if the specified user has administrator privileges.
534
   */
Steven Murray's avatar
Steven Murray committed
535
  bool isAdmin(const common::dataStructures::SecurityIdentity &admin) const override;
536

537
538
539
540
541
542
  /**
   * Checks that the most trivial query goes through. Returns true on success,
   * false on failure.
   * 
   * @return True if the query went through.
   */
543
  void ping() override;
544

545
546
547
548
549
550
551
552
553
  /**
   * Returns the names of all the tables in the database schema in alphabetical
   * order.
   *
   * @return The names of all the tables in the database schema in alphabetical
   * order.
   */
  std::list<std::string> getTableNames() const;

554
protected:
555

556
557
558
559
560
  /**
   * Object representing the API to the CTA logging system.
   */
  log::Logger &m_log;

561
562
563
  /**
   * Mutex to be used to a take a global lock on the database.
   */
564
  threading::Mutex m_mutex;
565
566

  /**
567
568
569
   * The pool of connections to the underlying relational database to be used
   * for all operations accept listing archive files which can be relatively
   * long operations.
570
   */
571
  mutable rdbms::ConnPool m_connPool;
572

573
574
575
576
577
578
  /**
   * The pool of connections to the underlying relational database to be used
   * for the sole purpose of listing archive files.
   */
  mutable rdbms::ConnPool m_archiveFileListingConnPool;

579
  /**
580
   * Returns true if the specified admin user exists.
581
   *
582
   * @param conn The database connection.
583
584
   * @param adminUsername The name of the admin user.
   * @return True if the admin user exists.
585
   */
586
  bool adminUserExists(rdbms::Conn &conn, const std::string adminUsername) const;
587
588
589
590

  /**
   * Returns true if the specified storage class exists.
   *
591
   * @param conn The database connection.
592
   * @param diskInstanceName The name of the disk instance to which the storage
593
   * class belongs.
594
   * @param storageClassName The name of the storage class.
595
596
   * @return True if the storage class exists.
   */
597
  bool storageClassExists(rdbms::Conn &conn, const std::string &diskInstanceName, const std::string &storageClassName)
598
    const;
599

600
601
602
603
604
605
606
607
  /**
   * Returns true if the specified tape pool exists.
   *
   * @param tapePoolName The name of the tape pool.
   * @return True if the tape pool exists.
   */
  bool tapePoolExists(const std::string &tapePoolName) const override;

608
609
610
  /**
   * Returns true if the specified tape pool exists.
   *
611
   * @param conn The database connection.
612
613
614
   * @param tapePoolName The name of the tape pool.
   * @return True if the tape pool exists.
   */
615
  bool tapePoolExists(rdbms::Conn &conn, const std::string &tapePoolName) const;
616

617
618
619
620
621
622
623
  /**
   * Returns true if the specified archive file identifier exists.
   *
   * @param conn The database connection.
   * @param archiveFileId The archive file identifier.
   * @return True if the archive file identifier exists.
   */
624
  bool archiveFileIdExists(rdbms::Conn &conn, const uint64_t archiveFileId) const;
625

626
627
628
629
630
631
632
  /**
   * Returns true if the specified disk file identifier exists.
   *
   * @param conn The database connection.
   * @param diskInstanceName The name of the disk instance to which the disk
   * file identifier belongs.
   * @param diskFileId The disk file identifier.
633
   * @return True if the disk file identifier exists.
634
   */
635
  bool diskFileIdExists(rdbms::Conn &conn, const std::string &diskInstanceName, const std::string &diskFileId) const;
636

637
638
639
640
641
  /**
   * Returns true if the specified disk file path exists.
   *
   * @param conn The database connection.
   * @param diskInstanceName The name of the disk instance to which the disk
642
   * file path belongs.
643
644
645
   * @param diskFilePath The disk file path.
   * @return True if the disk file path exists.
   */
646
  bool diskFilePathExists(rdbms::Conn &conn, const std::string &diskInstanceName, const std::string &diskFilePath)
647
648
    const;

649
650
651
652
653
654
655
656
657
  /**
   * Returns true if the specified disk file user exists.
   *
   * @param conn The database connection.
   * @param diskInstanceName The name of the disk instance to which the disk
   * file user belongs.
   * @param diskFileUSer The name of the disk file user.
   * @return True if the disk file user exists.
   */
658
  bool diskFileUserExists(rdbms::Conn &conn, const std::string &diskInstanceName, const std::string &diskFileUser)
659
660
    const;

661
662
663
664
665
666
  /**
   * Returns true if the specified disk file group exists.
   *
   * @param conn The database connection.
   * @param diskInstanceName The name of the disk instance to which the disk
   * file group belongs.
667
   * @param diskFileGroup The name of the disk file group.
668
669
   * @return True if the disk file group exists.
   */
670
  bool diskFileGroupExists(rdbms::Conn &conn, const std::string &diskInstanceName, const std::string &diskFileGroup)
671
672
    const;

673
674
675
676
677
678
679
680
681
682
683
  /**
   * Returns true if the specified archive route exists.
   *
   * @param conn The database connection.
   * @param diskInstanceName The name of the disk instance to which the storage
   * class belongs.
   * @param storageClassName The name of the storage class which is only
   * guaranteed to be unique within its disk instance.
   * @param copyNb The copy number of the tape file.
   * @return True if the archive route exists.
   */
684
  bool archiveRouteExists(rdbms::Conn &conn, const std::string &diskInstanceName, const std::string &storageClassName,
685
686
    const uint64_t copyNb) const;

687
688
689
690
691
692
693
694
  /**
   * Returns true if the specified tape exists.
   *
   * @param vid The volume identifier of the tape.
   * @return True if the tape exists.
   */
  bool tapeExists(const std::string &vid) const override;

695
696
697
  /**
   * Returns true if the specified tape exists.
   *
698
   * @param conn The database connection.
699
700
701
   * @param vid The volume identifier of the tape.
   * @return True if the tape exists.
   */
702
  bool tapeExists(rdbms::Conn &conn, const std::string &vid) const;
703

704
705
706
707
708
709
710
  /**
   * Returns the list of tapes that meet the specified search criteria.
   *
   * @param conn The database connection.
   * @param searchCriteria The search criteria.
   * @return The list of tapes.
   */
711
  std::list<common::dataStructures::Tape> getTapes(rdbms::Conn &conn, const TapeSearchCriteria &searchCriteria) const;
712

713
714
715
  /**
   * Returns true if the specified logical library exists.
   *
716
   * @param conn The database connection.
717
718
719
   * @param logicalLibraryName The name of the logical library.
   * @return True if the logical library exists.
   */
720
  bool logicalLibraryExists(rdbms::Conn &conn, const std::string &logicalLibraryName) const;
721
722
723
724

  /**
   * Returns true if the specified mount policy exists.
   *
725
   * @param conn The database connection.
726
727
728
   * @param mountPolicyName The name of the mount policy
   * @return True if the mount policy exists.
   */
729
  bool mountPolicyExists(rdbms::Conn &conn, const std::string &mountPolicyName) const;
730

731
  /**
732
   * Returns true if the specified requester mount-rule exists.
733
   *
734
735
736
737
738
   * @param diskInstanceName The name of the disk instance to which the
   * requester belongs.
   * @param requesterName The username of the requester which is only guaranteed
   * to be unique within its disk instance.
   * @return True if the requester mount-rule exists.
739
   */
740
  bool requesterMountRuleExists(rdbms::Conn &conn, const std::string &diskInstanceName,
741
    const std::string &requesterName) const;
742
743

  /**
744
745
746
747
748
749
750
751
752
753
754
755
756
757
758
759
760
761
762
763
764
765
766
767
768
769
770
771
772
773
774
775
776
777
778
779
780
781
782
783
    * A fully qualified user, in other words the name of the disk instance and
    * the name of the group.
    */
  struct User {
    /**
     * The name of the disk instance to which the user name belongs.
     */
    std::string diskInstanceName;

    /**
     * The name of the user which is only guaranteed to be unique within its
     * disk instance.
     */
    std::string username;

    /**
     * Constructor.
     *
     * @param d The name of the disk instance to which the group name belongs.
     * @param u The name of the group which is only guaranteed to be unique
     * within its disk instance.
     */
    User(const std::string &d, const std::string &u): diskInstanceName(d), username(u) {
    }

    /**
     * Less than operator.
     *
     * @param rhs The argument on the right hand side of the operator.
     * @return True if this object is less than the argument on the right hand
     * side of the operator.
     */
    bool operator<(const User &rhs) const {
      return diskInstanceName < rhs.diskInstanceName || username < rhs.username;
    }
  }; // struct User

  /**
   * Returns a cached version of the specified requester mount-policy or nullopt
   * if one does not exist.
784
   *
785
786
   * @param user The fully qualified user, in other words the name of the disk
   * instance and the name of the group.
787
   * @return The mount policy or nullopt if one does not exists.
788
   */
789
  optional<common::dataStructures::MountPolicy> getCachedRequesterMountPolicy(const User &user) const;
790
791
792
793
794
795
796
797
798
799
800

  /**
   * Returns the specified requester mount-policy or nullopt if one does not
   * exist.
   *
   * @param conn The database connection.
   * @param user The fully qualified user, in other words the name of the disk
   * instance and the name of the group.
   * @return The mount policy or nullopt if one does not exists.
   */
  optional<common::dataStructures::MountPolicy> getRequesterMountPolicy(rdbms::Conn &conn, const User &user) const;
801
802

  /**
803
   * Returns true if the specified requester-group mount-rule exists.
804
   *
805
   * @param conn The database connection.
806
807
808
809
810
   * @param diskInstanceName The name of the disk instance to which the
   * requester group belongs.
   * @param requesterGroupName The name of the requester group which is only
   * guaranteed to be unique within its disk instance.
   * @return True if the requester-group mount-rule exists.
811
   */
812
  bool requesterGroupMountRuleExists(rdbms::Conn &conn, const std::string &diskInstanceName,
813
    const std::string &requesterGroupName) const;
814

815
  /**
816
817
818
819
820
821
822
823
824
825
826
827
828
829
830
831
832
833
834
835
836
837
838
839
840
841
842
843
844
845
846
847
848
849
850
851
852
853
854
855
856
857
    * A fully qualified user group, in other words the name of the disk instance
    * and the name of the group.
    */
  struct Group {
    /**
     * The name of the disk instance to which the group name belongs.
     */
    std::string diskInstanceName;

    /**
     * The name of the group which is only guaranteed to be unique within its
     * disk instance.
     */
    std::string groupName;

    /**
     * Constructor.
     *
     * @param d The name of the disk instance to which the group name belongs.
     * @param g The name of the group which is only guaranteed to be unique
     * within its disk instance.
     */
    Group(const std::string &d, const std::string &g): diskInstanceName(d), groupName(g) {
    }

    /**
     * Less than operator.
     *
     * @param rhs The argument on the right hand side of the operator.
     * @return True if this object is less than the argument on the right hand
     * side of the operator.
     */
    bool operator<(const Group &rhs) const {
      return diskInstanceName < rhs.diskInstanceName || groupName < rhs.groupName;
    }
  }; // struct Group

  /**
   * Returns a cached version of the specified requester-group mount-policy or
   * nullptr if one does not exist.
   *
   * This method updates the cache when necessary.
858
   *
859
860
   * @param group The fully qualified group, in other words the name of the disk
   * instance and the name of the group.
861
   * @return The cached mount policy or nullopt if one does not exists.
862
   */
863
  optional<common::dataStructures::MountPolicy> getCachedRequesterGroupMountPolicy(const Group &group) const;
864
865
866
867
868
869
870
871

  /**
   * Returns the specified requester-group mount-policy or nullptr if one does
   * not exist.
   *
   * @param conn The database connection.
   * @param group The fully qualified group, in other words the name of the disk
   * instance and the name of the group.
872
   * @return The mount policy or nullopt if one does not exists.
873
   */
874
875
  optional<common::dataStructures::MountPolicy> getRequesterGroupMountPolicy(rdbms::Conn &conn, const Group &group)
    const;
876

877
878
879
880
881
  /**
   * Returns the specified tape log information from the specified database
   * result set.
   *
   * @param rset The result set.
882
   * @param driveColName The name of the database column that contains the name
883
884
885
886
   * of the tape drive.
   * @param timeColNAme The name of the database column that contains the time
   * stamp.
   */
887
  optional<common::dataStructures::TapeLog> getTapeLogFromRset(const rdbms::Rset &rset,
888
889
    const std::string &driveColName, const std::string &timeColName) const;

890
  /**
891
892
   * An RdbmsCatalogue specific method that inserts the specified row into the
   * ArchiveFile table.
893
   *
894
   * @param conn The database connection.
895
   * @param row The row to be inserted.
896
   */
897
  void insertArchiveFile(rdbms::Conn &conn, const ArchiveFileRow &row);
898

899
900
901
902
903
  /**
   * Creates the database schema.
   */
  void createDbSchema();

904
905
906
907
  /**
   * A fully qualified storage class, in other words the name of the disk
   * instance and the name of the storage class.
   */
908
  struct StorageClass {
909
910
911
912
913
914
915
916
917
918
919
920
921
922
923
924
925
926
927
    /**
     * The name of the disk instance to which the storage class belongs.
     */
    std::string diskInstanceName;

    /**
     * The name of the storage class which is only guaranteed to be unique
     * within its disk instance.
     */
    std::string storageClassName;

    /**
     * Constructor.
     *
     * @param dIN The name of the disk instance to which the storage class
     * belongs.
     * @param sN The name of the storage class which is only guaranteed to be
     * unique within its disk instance.
     */
928
    StorageClass(const std::string &d, const std::string &s): diskInstanceName(d), storageClassName(s) {
929
930
931
932
933
934
935
936
937
    }

    /**
     * Less than operator.
     *
     * @param rhs The argument on the right hand side of the operator.
     * @return True if this object is less than the argument on the right hand
     * side of the operator.
     */
938
    bool operator<(const StorageClass &rhs) const {
939
940
      return diskInstanceName < rhs.diskInstanceName || storageClassName < rhs.storageClassName;
    }
941
  }; // struct StorageClass
942

943
944
945
946
947
948
949
950
951
952
953
954
  /**
   * Returns a cached version of the expected number of archive routes for the
   * specified storage class as specified by the call to the
   * createStorageClass() method as opposed to the actual number entered so far
   * using the createArchiveRoute() method.
   *
   * This method updates the cache when necessary.
   *
   * @param storageClass The fully qualified storage class, in other words the
   * name of the disk instance and the name of the storage class.
   * @return The expected number of archive routes.
   */
955
  uint64_t getCachedExpectedNbArchiveRoutes(const StorageClass &storageClass) const;
956

957
958
959
960
961
962
  /**
   * Returns the expected number of archive routes for the specified storage
   * class as specified by the call to the createStorageClass() method as
   * opposed to the actual number entered so far using the createArchiveRoute()
   * method.
   *
963
   * @param conn The database connection.
964
965
   * @param storageClass The fully qualified storage class, in other words the
   * name of the disk instance and the name of the storage class.
966
967
   * @return The expected number of archive routes.
   */
968
  uint64_t getExpectedNbArchiveRoutes(rdbms::Conn &conn, const StorageClass &storageClass) const;
969

970
  /**
971
   * Inserts the specified tape file into the Tape table.
972
   *
973
   * @param conn The database connection.
974
975
976
977
   * @param tapeFile The tape file.
   * @param archiveFileId The identifier of the archive file of which the tape
   * file is a copy.
   */
978
  void insertTapeFile(
979
    rdbms::Conn &conn,
980
981
    const common::dataStructures::TapeFile &tapeFile,
    const uint64_t archiveFileId);
982

983
984
985
  /**
   * Sets the last FSeq of the specified tape to the specified value.
   *
986
   * @param conn The database connection.
987
988
989
   * @param vid The volume identifier of the tape.
   * @param lastFseq The new value of the last FSeq.
   */
990
  void setTapeLastFSeq(rdbms::Conn &conn, const std::string &vid, const uint64_t lastFSeq);
991
992

  /**
993
   * Returns the last FSeq of the specified tape.
994
   *
995
   * @param conn The database connection.
996
997
998
   * @param vid The volume identifier of the tape.
   * @return The last FSeq.
   */
999
  uint64_t getTapeLastFSeq(rdbms::Conn &conn, const std::string &vid) const;
1000

For faster browsing, not all history is shown. View entire blame