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 bool 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(JCR *jcr, B_DB *mdb, ATTR_DBR *ar)
  59 {
  60    /* *****FIXME***** implement this */
  61    return 1;
  62 }
  63
  64 int db_create_file_item(JCR *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(JCR *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 bool db_create_jobmedia_record(JCR *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 bool db_create_pool_record(JCR *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 bool db_create_device_record(JCR *jcr, B_DB *mdb, DEVICE_DBR *dr)
 175 { return false; }
 176
 177 bool db_create_storage_record(JCR *jcr, B_DB *mdb, STORAGE_DBR *dr)
 178 { return false; }
 179
 180 bool db_create_mediatype_record(JCR *jcr, B_DB *mdb, MEDIATYPE_DBR *dr)
 181 { return false; }
 182
 183
 184 /*
 185  * Create Unique Media record.  This record
 186  *   contains all the data pertaining to a specific
 187  *   Volume.
 188  *
 189  * Returns: 0 on failure
 190  *          1 on success
 191  */
 192 int db_create_media_record(JCR *jcr, B_DB *mdb, MEDIA_DBR *mr)
 193 {
 194    int len;
 195    MEDIA_DBR mmr;
 196
 197    db_lock(mdb);
 198    memset(&mmr, 0, sizeof(mmr));
 199    strcpy(mmr.VolumeName, mr->VolumeName);
 200    if (db_get_media_record(jcr, mdb, &mmr)) {
 201       Mmsg1(&mdb->errmsg, "Media record %s already exists\n", mmr.VolumeName);
 202       db_unlock(mdb);
 203       return 0;
 204    }
 205
 206
 207    mdb->control.MediaId++;
 208    mr->MediaId = mdb->control.MediaId;
 209    bdb_write_control_file(mdb);
 210
 211    len = sizeof(mmr);
 212    fseek(mdb->mediafd, 0L, SEEK_END);
 213    if (fwrite(mr, len, 1, mdb->mediafd) != 1) {
 214       Mmsg1(&mdb->errmsg, "Error writing DB Media file. ERR=%s\n", strerror(errno));
 215       db_unlock(mdb);
 216       return 0;
 217    }
 218    fflush(mdb->mediafd);
 219    db_unlock(mdb);
 220    return 1;
 221 }
 222
 223
 224 /*
 225  *  Create a unique Client record or return existing record
 226  * Returns: 0 on failure
 227  *          1 on success
 228  */
 229 int db_create_client_record(JCR *jcr, B_DB *mdb, CLIENT_DBR *cr)
 230 {
 231    int len;
 232    CLIENT_DBR lcr;
 233
 234    db_lock(mdb);
 235    cr->ClientId = 0;
 236    if (db_get_client_record(jcr, mdb, cr)) {
 237       Mmsg1(&mdb->errmsg, "Client record %s already exists\n", cr->Name);
 238       db_unlock(mdb);
 239       return 1;
 240    }
 241
 242    if (!bdb_open_client_file(mdb)) {
 243       db_unlock(mdb);
 244       return 0;
 245    }
 246
 247    mdb->control.ClientId++;
 248    cr->ClientId = mdb->control.ClientId;
 249    bdb_write_control_file(mdb);
 250
 251    fseek(mdb->clientfd, 0L, SEEK_END);
 252    len = sizeof(lcr);
 253    if (fwrite(cr, len, 1, mdb->clientfd) != 1) {
 254       Mmsg1(&mdb->errmsg, "Error writing DB Client file. ERR=%s\n", strerror(errno));
 255       db_unlock(mdb);
 256       return 0;
 257    }
 258    fflush(mdb->clientfd);
 259    db_unlock(mdb);
 260    return 1;
 261 }
 262
 263 /*
 264  *  Create a unique FileSet record or return existing record
 265  *
 266  *   Note, here we write the FILESET_DBR structure
 267  *
 268  * Returns: 0 on failure
 269  *          1 on success
 270  */
 271 bool db_create_fileset_record(JCR *jcr, B_DB *mdb, FILESET_DBR *fsr)
 272 {
 273    int len;
 274    FILESET_DBR lfsr;
 275
 276    db_lock(mdb);
 277    fsr->FileSetId = 0;
 278    if (db_get_fileset_record(jcr, mdb, fsr)) {
 279       Mmsg1(&mdb->errmsg, "FileSet record %s already exists\n", fsr->FileSet);
 280       db_unlock(mdb);
 281       return 1;
 282    }
 283
 284    if (!bdb_open_fileset_file(mdb)) {
 285       db_unlock(mdb);
 286       return 0;
 287    }
 288
 289    mdb->control.FileSetId++;
 290    fsr->FileSetId = mdb->control.FileSetId;
 291    bdb_write_control_file(mdb);
 292
 293    fseek(mdb->clientfd, 0L, SEEK_END);
 294    len = sizeof(lfsr);
 295    if (fwrite(fsr,  len, 1, mdb->filesetfd) != 1) {
 296       Mmsg1(&mdb->errmsg, "Error writing DB FileSet file. ERR=%s\n", strerror(errno));
 297       db_unlock(mdb);
 298       return 0;
 299    }
 300    fflush(mdb->filesetfd);
 301    db_unlock(mdb);
 302    return 1;
 303 }
 304
 305 int db_create_counter_record(JCR *jcr, B_DB *mdb, COUNTER_DBR *cr)
 306 { return 0; }
 307
 308
 309 #endif /* HAVE_BACULA_DB */