git.sur5r.net Git - bacula/bacula/blob - bacula/src/cats/bdb_create.c

   1 /*
   2  * Bacula Catalog Database Create record routines
   3  *
   4  * Bacula Catalog Database routines written specifically
   5  *  for Bacula.  Note, these routines are VERY dumb and
   6  *  do not provide all the functionality of an SQL database.
   7  *  The purpose of these routines is to ensure that Bacula
   8  *  can limp along if no real database is loaded on the
   9  *  system.
  10  *
  11  *    Kern Sibbald, January MMI
  12  *
  13  *    Version $Id$
  14  */
  15
  16 /*
  17    Copyright (C) 2001-2003 Kern Sibbald and John Walker
  18
  19    This program is free software; you can redistribute it and/or
  20    modify it under the terms of the GNU General Public License as
  21    published by the Free Software Foundation; either version 2 of
  22    the License, or (at your option) any later version.
  23
  24    This program is distributed in the hope that it will be useful,
  25    but WITHOUT ANY WARRANTY; without even the implied warranty of
  26    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
  27    General Public License for more details.
  28
  29    You should have received a copy of the GNU General Public
  30    License along with this program; if not, write to the Free
  31    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
  32    MA 02111-1307, USA.
  33
  34  */
  35
  36
  37 /* The following is necessary so that we do not include
  38  * the dummy external definition of DB.
  39  */
  40 #define __SQL_C                       /* indicate that this is sql.c */
  41
  42 #include "bacula.h"
  43 #include "cats.h"
  44 #include "bdb.h"
  45
  46 #ifdef HAVE_BACULA_DB
  47
  48 /* Forward referenced functions */
  49 int db_create_pool_record(B_DB *mdb, POOL_DBR *pr);
  50
  51 /* -----------------------------------------------------------------------
  52  *
  53  *   Bacula specific defines and subroutines
  54  *
  55  * -----------------------------------------------------------------------
  56  */
  57
  58 int db_create_file_attributes_record(void *jcr, B_DB *mdb, ATTR_DBR *ar)
  59 {
  60    /* *****FIXME***** implement this */
  61    return 1;
  62 }
  63
  64 int db_create_file_item(void *jcr, B_DB *mdb, ATTR_DBR *ar)
  65 {
  66    /****FIXME***** not implemented */
  67    return 1;
  68 }
  69
  70
  71 /*
  72  * Create a new record for the Job
  73  *   This record is created at the start of the Job,
  74  *   it is updated in bdb_update.c when the Job terminates.
  75  *
  76  * Returns: 0 on failure
  77  *          1 on success
  78  */
  79 int db_create_job_record(void *jcr, B_DB *mdb, JOB_DBR *jr)
  80 {
  81    int len;
  82
  83    db_lock(mdb);
  84    if (!bdb_open_jobs_file(mdb)) {
  85       db_unlock(mdb);
  86       return 0;
  87    }
  88    mdb->control.JobId++;
  89    bdb_write_control_file(mdb);
  90
  91    len = sizeof(JOB_DBR);
  92    jr->JobId = mdb->control.JobId;
  93    fseek(mdb->jobfd, 0L, SEEK_END);
  94    if (fwrite(jr, len, 1, mdb->jobfd) != 1) {
  95       Mmsg1(&mdb->errmsg, "Error writing DB Jobs file. ERR=%s\n", strerror(errno));
  96       db_unlock(mdb);
  97       return 0;
  98    }
  99    fflush(mdb->jobfd);
 100    db_unlock(mdb);
 101    return 1;
 102 }
 103
 104 /* Create a JobMedia record for Volume used this job
 105  * Returns: 0 on failure
 106  *          record-id on success
 107  */
 108 int db_create_jobmedia_record(void *jcr, B_DB *mdb, JOBMEDIA_DBR *jm)
 109 {
 110    int len;
 111
 112    db_lock(mdb);
 113    if (!bdb_open_jobmedia_file(mdb)) {
 114       db_unlock(mdb);
 115       return 0;
 116    }
 117    mdb->control.JobMediaId++;
 118    jm->JobMediaId = mdb->control.JobMediaId;
 119    bdb_write_control_file(mdb);
 120
 121    len = sizeof(JOBMEDIA_DBR);
 122
 123    fseek(mdb->jobmediafd, 0L, SEEK_END);
 124    if (fwrite(jm, len, 1, mdb->jobmediafd) != 1) {
 125       Mmsg1(&mdb->errmsg, "Error writing DB JobMedia file. ERR=%s\n", strerror(errno));
 126       db_unlock(mdb);
 127       return 0;
 128    }
 129    fflush(mdb->jobmediafd);
 130    db_unlock(mdb);
 131    return jm->JobMediaId;
 132 }
 133
 134
 135 /*
 136  *  Create a unique Pool record
 137  * Returns: 0 on failure
 138  *          1 on success
 139  */
 140 int db_create_pool_record(void *jcr, B_DB *mdb, POOL_DBR *pr)
 141 {
 142    int len;
 143    POOL_DBR mpr;
 144
 145    memset(&mpr, 0, sizeof(mpr));
 146    strcpy(mpr.Name, pr->Name);
 147    if (db_get_pool_record(jcr, mdb, &mpr)) {
 148       Mmsg1(&mdb->errmsg, "Pool record %s already exists\n", mpr.Name);
 149       return 0;
 150    }
 151
 152    db_lock(mdb);
 153    if (!bdb_open_pools_file(mdb)) {
 154       db_unlock(mdb);
 155       return 0;
 156    }
 157
 158    mdb->control.PoolId++;
 159    pr->PoolId = mdb->control.PoolId;
 160    bdb_write_control_file(mdb);
 161
 162    len = sizeof(mpr);
 163    fseek(mdb->poolfd, 0L, SEEK_END);
 164    if (fwrite(pr, len, 1, mdb->poolfd) != 1) {
 165       Mmsg1(&mdb->errmsg, "Error writing DB Pools file. ERR=%s\n", strerror(errno));
 166       db_unlock(mdb);
 167       return 0;
 168    }
 169    fflush(mdb->poolfd);
 170    db_unlock(mdb);
 171    return 1;
 172 }
 173
 174
 175 /*
 176  * Create Unique Media record.  This record
 177  *   contains all the data pertaining to a specific
 178  *   Volume.
 179  *
 180  * Returns: 0 on failure
 181  *          1 on success
 182  */
 183 int db_create_media_record(void *jcr, B_DB *mdb, MEDIA_DBR *mr)
 184 {
 185    int len;
 186    MEDIA_DBR mmr;
 187
 188    memset(&mmr, 0, sizeof(mmr));
 189    strcpy(mmr.VolumeName, mr->VolumeName);
 190    if (db_get_media_record(jcr, mdb, &mmr)) {
 191       Mmsg1(&mdb->errmsg, "Media record %s already exists\n", mmr.VolumeName);
 192       return 0;
 193    }
 194
 195    db_lock(mdb);
 196
 197    mdb->control.MediaId++;
 198    mr->MediaId = mdb->control.MediaId;
 199    bdb_write_control_file(mdb);
 200
 201    len = sizeof(mmr);
 202    fseek(mdb->mediafd, 0L, SEEK_END);
 203    if (fwrite(mr, len, 1, mdb->mediafd) != 1) {
 204       Mmsg1(&mdb->errmsg, "Error writing DB Media file. ERR=%s\n", strerror(errno));
 205       db_unlock(mdb);
 206       return 0;
 207    }
 208    fflush(mdb->mediafd);
 209    db_unlock(mdb);
 210    return 1;
 211 }
 212
 213
 214 /*
 215  *  Create a unique Client record or return existing record
 216  * Returns: 0 on failure
 217  *          1 on success
 218  */
 219 int db_create_client_record(void *jcr, B_DB *mdb, CLIENT_DBR *cr)
 220 {
 221    int len;
 222    CLIENT_DBR lcr;
 223
 224    cr->ClientId = 0;
 225    if (db_get_client_record(jcr, mdb, cr)) {
 226       Mmsg1(&mdb->errmsg, "Client record %s already exists\n", cr->Name);
 227       return 1;
 228    }
 229
 230    db_lock(mdb);
 231    if (!bdb_open_client_file(mdb)) {
 232       db_unlock(mdb);
 233       return 0;
 234    }
 235
 236    mdb->control.ClientId++;
 237    cr->ClientId = mdb->control.ClientId;
 238    bdb_write_control_file(mdb);
 239
 240    fseek(mdb->clientfd, 0L, SEEK_END);
 241    len = sizeof(lcr);
 242    if (fwrite(cr, len, 1, mdb->clientfd) != 1) {
 243       Mmsg1(&mdb->errmsg, "Error writing DB Client file. ERR=%s\n", strerror(errno));
 244       db_unlock(mdb);
 245       return 0;
 246    }
 247    fflush(mdb->clientfd);
 248    db_unlock(mdb);
 249    return 1;
 250 }
 251
 252 /*
 253  *  Create a unique FileSet record or return existing record
 254  *
 255  *   Note, here we write the FILESET_DBR structure
 256  *
 257  * Returns: 0 on failure
 258  *          1 on success
 259  */
 260 int db_create_fileset_record(void *jcr, B_DB *mdb, FILESET_DBR *fsr)
 261 {
 262    int len;
 263    FILESET_DBR lfsr;
 264
 265    fsr->FileSetId = 0;
 266    if (db_get_fileset_record(jcr, mdb, fsr)) {
 267       Mmsg1(&mdb->errmsg, "FileSet record %s already exists\n", fsr->FileSet);
 268       return 1;
 269    }
 270
 271    db_lock(mdb);
 272    if (!bdb_open_fileset_file(mdb)) {
 273       db_unlock(mdb);
 274       return 0;
 275    }
 276
 277    mdb->control.FileSetId++;
 278    fsr->FileSetId = mdb->control.FileSetId;
 279    bdb_write_control_file(mdb);
 280
 281    fseek(mdb->clientfd, 0L, SEEK_END);
 282    len = sizeof(lfsr);
 283    if (fwrite(fsr,  len, 1, mdb->filesetfd) != 1) {
 284       Mmsg1(&mdb->errmsg, "Error writing DB FileSet file. ERR=%s\n", strerror(errno));
 285       db_unlock(mdb);
 286       return 0;
 287    }
 288    fflush(mdb->filesetfd);
 289    db_unlock(mdb);
 290    return 1;
 291 }
 292
 293 #endif /* HAVE_BACULA_DB */