src/butc/test_budb.c

   1 /*
   2  * Copyright 2000, International Business Machines Corporation and others.
   3  * All Rights Reserved.
   4  *
   5  * This software has been released under the terms of the IBM Public
   6  * License.  For details, see the LICENSE file in the top-level source
   7  * directory or online at http://www.openafs.org/dl/license10.html
   8  */
   9
  10 #include <sys/types.h>
  11 #include <netinet/in.h>
  12
  13 #include <afsconfig.h>
  14 #include <afs/param.h>
  15
  16 RCSID
  17     ("$Header$");
  18
  19 #include <afs/auth.h>
  20 #include <afs/budb_client.h>
  21 #include <afs/budb.h>
  22 #include <rx/rx_globals.h>
  23
  24 extern struct udbHandleS udbHandle;
  25
  26 #define ERROR(code) {err = code; printf("   - Got error %d.\n", err); goto error;}
  27
  28 int
  29 connect_buserver()
  30 {
  31     int code, err = 0;
  32     char cellName[64];
  33     struct ubik_client *cstruct;
  34     int version;
  35
  36     /*
  37      * Setup RX connection and establish connection with the buserver
  38      */
  39     code = rx_Init(htons(0));
  40     if (code) {
  41         printf("Error in rx_Init call\n");
  42         ERROR(code);
  43     }
  44
  45     rx_SetRxDeadTime(60);
  46
  47     /*
  48      * Connect to buserver
  49      */
  50     cellName[0] = '\0';
  51     code = udbClientInit(0, 0, cellName);
  52     if (code) {
  53         printf("Error in udbClientInit call\n");
  54         ERROR(code);
  55     }
  56
  57     /* Get the versin */
  58     code = ubik_Call(BUDB_T_GetVersion, udbHandle.uh_client, 0, &version);
  59     if (code) {
  60         printf("Error in ubik_Call to BUDB_T_GetVersion\n");
  61         ERROR(code);
  62     }
  63     printf("BUDB Server Version = %d\n", version);
  64
  65   error:
  66     return err;
  67 }
  68
  69 int
  70 verifyDb()
  71 {
  72     int code, err = 0;
  73     afs_int32 status, orphans, host;
  74
  75     code =
  76         ubik_Call(BUDB_DbVerify, udbHandle.uh_client, 0, &status, &orphans,
  77                   &host);
  78     if (code) {
  79         printf("Error in ubik_Call to BUDB_DbVerify\n");
  80         ERROR(code);
  81     }
  82
  83     if (!status)
  84         printf("DATABASE OK     ");
  85     else
  86         printf("DATABASE NOT OK ");
  87     printf("- orphans %d; host %d.%d.%d.%d\n", orphans,
  88            ((host & 0xFF000000) >> 24), ((host & 0xFF0000) >> 16),
  89            ((host & 0xFF00) >> 8), (host & 0xFF));
  90
  91   error:
  92     return err;
  93 }
  94
  95 int
  96 deleteDump(dumpID)
  97      afs_int32 dumpID;
  98 {
  99     int code;
 100     budb_dumpsList dumps;
 101
 102     dumps.budb_dumpsList_len = 0;
 103     dumps.budb_dumpsList_val = 0;
 104
 105     code = bcdb_deleteDump(dumpID, 0, 0, &dumps);
 106     return code;
 107 }
 108
 109 #define NPASS     50
 110 #define NDUMPS    4
 111 #define NTAPES    2
 112 #define NVOLUMES 10
 113
 114 int
 115 main()
 116 {
 117     int code, err = 0;
 118     int pass = 0;
 119     int d, t, v;
 120     afs_int32 newTape;
 121     struct budb_dumpEntry dumpEntry[NDUMPS];
 122     struct budb_tapeEntry tapeEntry[NTAPES];
 123     struct budb_volumeEntry volumeEntry[NVOLUMES];
 124
 125     code = connect_buserver();
 126     if (code) {
 127         printf("Error in connect_buserver call\n");
 128         ERROR(code);
 129     }
 130
 131     for (pass = 0; pass < NPASS; pass++) {
 132         printf("PASS %d\n", pass + 1);
 133
 134
 135         for (d = 0; d < NDUMPS; d++) {
 136             /* ************************ */
 137             /* Create and finish a dump */
 138             /* ************************ */
 139             dumpEntry[d].id = 0;
 140             dumpEntry[d].parent = 0;
 141             dumpEntry[d].level = 0;
 142             dumpEntry[d].flags = 0;
 143             strcpy(dumpEntry[d].volumeSetName, "TestVolSetName");
 144             strcpy(dumpEntry[d].dumpPath, "/TestDumpPath");
 145             strcpy(dumpEntry[d].name, "TestVolSetName.TestDumpPath");
 146             dumpEntry[d].created = 0;
 147             dumpEntry[d].incTime = 0;
 148             dumpEntry[d].nVolumes = 0;
 149             dumpEntry[d].tapes.id = 0;
 150             strcpy(dumpEntry[d].tapes.tapeServer, "");
 151             strcpy(dumpEntry[d].tapes.format,
 152                    "TestVolSetName.TestDumpPath.%d");
 153             dumpEntry[d].tapes.maxTapes = 1;
 154             dumpEntry[d].tapes.a = 0;
 155             dumpEntry[d].tapes.b = 1;
 156             strcpy(dumpEntry[d].dumper.name, "admin");
 157             strcpy(dumpEntry[d].dumper.instance, "");
 158             strcpy(dumpEntry[d].dumper.cell, "");
 159             dumpEntry[d].initialDumpID = 0;
 160             if (d == 1)
 161                 dumpEntry[d].initialDumpID = dumpEntry[0].id;
 162             dumpEntry[d].appendedDumpID = 0;
 163
 164             code = bcdb_CreateDump(&dumpEntry[d]);
 165             if (code) {
 166                 printf("Error in bcdb_CreateDump call\n");
 167                 ERROR(code);
 168             }
 169             printf("\nCreated dump %s (DumpID %u)\n", dumpEntry[d].name,
 170                    dumpEntry[d].id);
 171
 172             for (t = 0; t < NTAPES; t++) {
 173                 /* ************************ */
 174                 /* Create and finish a tape */
 175                 /* ************************ */
 176                 sprintf(tapeEntry[t].name, "TestVolSetName.TestDumpPath.%d",
 177                         t + 1);
 178                 tapeEntry[t].flags = 0;
 179                 tapeEntry[t].written = 0;
 180                 tapeEntry[t].expires = 0;       /* date tape expires */
 181                 tapeEntry[t].nMBytes = 0;
 182                 tapeEntry[t].nBytes = 0;
 183                 tapeEntry[t].nFiles = 0;
 184                 tapeEntry[t].nVolumes = 0;
 185                 tapeEntry[t].seq = (t + 1);     /* Tape in sequence */
 186                 tapeEntry[t].tapeid = 0;
 187                 tapeEntry[t].useCount = 999;    /* Number of time tape is used */
 188                 tapeEntry[t].useKBytes = 0;
 189                 tapeEntry[t].dump = dumpEntry[d].id;
 190
 191                 bcdb_UseTape(&tapeEntry[t], &newTape);
 192                 if (code) {
 193                     printf("Error in bcdb_UseTape call\n");
 194                     ERROR(code);
 195                 }
 196                 printf("   Created tape %s (%u)\n", tapeEntry[t].name,
 197                        tapeEntry[t].dump);
 198
 199                 for (v = 0; v < NVOLUMES; v++) {
 200                     /* ************************* */
 201                     /* Create a volume           */
 202                     /* ************************* */
 203                     sprintf(volumeEntry[v].name, "TestVolumeName.%d",
 204                             (t * NVOLUMES) + (v + 1));
 205                     volumeEntry[v].flags =
 206                         (BUDB_VOL_FIRSTFRAG | BUDB_VOL_LASTFRAG);
 207                     volumeEntry[v].id = 1234567890;     /* volume id */
 208                     strcpy(volumeEntry[v].server, "");
 209                     volumeEntry[v].partition = 0;
 210                     volumeEntry[v].tapeSeq = 0;
 211                     volumeEntry[v].position = v + 2;    /* positin on tape */
 212                     volumeEntry[v].clone = 0;   /* clone date */
 213                     volumeEntry[v].incTime = 0;
 214                     volumeEntry[v].startByte = 0;
 215                     volumeEntry[v].nBytes = (v + 1) * 100000;   /* vary size of volume */
 216                     volumeEntry[v].seq = 1;     /* The first fragment */
 217                     volumeEntry[v].dump = dumpEntry[d].id;      /* the dump id */
 218                     strcpy(volumeEntry[v].tape, tapeEntry[t].name);     /* the tape name */
 219
 220                     code = bcdb_AddVolume(&volumeEntry[v]);
 221                     if (code) {
 222                         printf("Error in bcdb_AddVolume call\n");
 223                         ERROR(code);
 224                     }
 225                     printf("      Added volume %s\n", volumeEntry[v].name);
 226                 }
 227
 228                 tapeEntry[t].nFiles = 77777;
 229                 tapeEntry[t].useKBytes = 88888;
 230                 code = bcdb_FinishTape(&tapeEntry[t]);
 231                 if (code) {
 232                     printf("Error in bcdb_FinishTape call\n");
 233                     ERROR(code);
 234                 }
 235                 printf("   Finished tape %s (%u)\n", tapeEntry[t].name,
 236                        tapeEntry[t].dump);
 237             }
 238
 239             code = bcdb_FinishDump(&dumpEntry[d]);
 240             if (code) {
 241                 printf("Error in bcdb_FinishDump call\n");
 242                 ERROR(code);
 243             }
 244             printf("Finished dump %s (DumpID %u)\n", dumpEntry[d].name,
 245                    dumpEntry[d].id);
 246
 247             code = verifyDb();
 248             if (code) {
 249                 printf("Error in verifyDb call\n");
 250                 ERROR(code);
 251             }
 252         }
 253
 254         /* ********************************************** */
 255         /* Delete one of the dumps - only if not appended */
 256         /* ********************************************** */
 257         if (!dumpEntry[(pass % NDUMPS)].initialDumpID) {
 258             code = deleteDump(dumpEntry[(pass % NDUMPS)].id);
 259             if (code) {
 260                 printf("Error in deleteDump call\n");
 261                 ERROR(code);
 262             }
 263             printf("Deleted DumpID %u\n", dumpEntry[(pass % NDUMPS)].id);
 264         }
 265
 266         code = verifyDb();
 267         if (code) {
 268             printf("Error in verifyDb call\n");
 269             ERROR(code);
 270         }
 271     }
 272
 273   error:
 274     return err;
 275 }