git.sur5r.net Git - bacula/bacula/blob - bacula/src/dird/ua_update.c

   1 /*
   2  *
   3  *   Bacula Director -- Update command processing
   4  *     Split from ua_cmds.c March 2005
   5  *
   6  *     Kern Sibbald, September MM
   7  *
   8  *   Version $Id$
   9  */
  10 /*
  11    Copyright (C) 2000-2006 Kern Sibbald
  12
  13    This program is free software; you can redistribute it and/or
  14    modify it under the terms of the GNU General Public License
  15    version 2 as amended with additional clauses defined in the
  16    file LICENSE in the main source directory.
  17
  18    This program is distributed in the hope that it will be useful,
  19    but WITHOUT ANY WARRANTY; without even the implied warranty of
  20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
  21    the file LICENSE for additional details.
  22
  23  */
  24
  25 #include "bacula.h"
  26 #include "dird.h"
  27
  28 /* External variables */
  29 extern const char *list_pool;               /* in sql_cmds.c */
  30
  31 /* Imported functions */
  32 void update_slots(UAContext *ua);
  33
  34
  35
  36 /* Forward referenced functions */
  37 static int update_volume(UAContext *ua);
  38 static int update_pool(UAContext *ua);
  39
  40 /*
  41  * Update a Pool Record in the database.
  42  *  It is always updated from the Resource record.
  43  *
  44  *    update pool=<pool-name>
  45  *         updates pool from Pool resource
  46  *    update media pool=<pool-name> volume=<volume-name>
  47  *         changes pool info for volume
  48  *    update slots [scan=...]
  49  *         updates autochanger slots
  50  */
  51 int update_cmd(UAContext *ua, const char *cmd)
  52 {
  53    static const char *kw[] = {
  54       NT_("media"),  /* 0 */
  55       NT_("volume"), /* 1 */
  56       NT_("pool"),   /* 2 */
  57       NT_("slots"),  /* 3 */
  58       NULL};
  59
  60    if (!open_db(ua)) {
  61       return 1;
  62    }
  63
  64    switch (find_arg_keyword(ua, kw)) {
  65    case 0:
  66    case 1:
  67       update_volume(ua);
  68       return 1;
  69    case 2:
  70       update_pool(ua);
  71       return 1;
  72    case 3:
  73       update_slots(ua);
  74       return 1;
  75    default:
  76       break;
  77    }
  78
  79    start_prompt(ua, _("Update choice:\n"));
  80    add_prompt(ua, _("Volume parameters"));
  81    add_prompt(ua, _("Pool from resource"));
  82    add_prompt(ua, _("Slots from autochanger"));
  83    switch (do_prompt(ua, _("item"), _("Choose catalog item to update"), NULL, 0)) {
  84    case 0:
  85       update_volume(ua);
  86       break;
  87    case 1:
  88       update_pool(ua);
  89       break;
  90    case 2:
  91       update_slots(ua);
  92       break;
  93    default:
  94       break;
  95    }
  96    return 1;
  97 }
  98
  99 static void update_volstatus(UAContext *ua, const char *val, MEDIA_DBR *mr)
 100 {
 101    POOL_MEM query(PM_MESSAGE);
 102    const char *kw[] = {
 103       NT_("Append"),
 104       NT_("Archive"),
 105       NT_("Disabled"),
 106       NT_("Full"),
 107       NT_("Used"),
 108       NT_("Cleaning"),
 109       NT_("Recycle"),
 110       NT_("Read-Only"),
 111       NULL};
 112    bool found = false;
 113    int i;
 114
 115    for (i=0; kw[i]; i++) {
 116       if (strcasecmp(val, kw[i]) == 0) {
 117          found = true;
 118          break;
 119       }
 120    }
 121    if (!found) {
 122       bsendmsg(ua, _("Invalid VolStatus specified: %s\n"), val);
 123    } else {
 124       char ed1[50];
 125       bstrncpy(mr->VolStatus, kw[i], sizeof(mr->VolStatus));
 126       Mmsg(query, "UPDATE Media SET VolStatus='%s' WHERE MediaId=%s",
 127          mr->VolStatus, edit_int64(mr->MediaId,ed1));
 128       if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 129          bsendmsg(ua, "%s", db_strerror(ua->db));
 130       } else {
 131          bsendmsg(ua, _("New Volume status is: %s\n"), mr->VolStatus);
 132       }
 133    }
 134 }
 135
 136 static void update_volretention(UAContext *ua, char *val, MEDIA_DBR *mr)
 137 {
 138    char ed1[150], ed2[50];
 139    POOL_MEM query(PM_MESSAGE);
 140    if (!duration_to_utime(val, &mr->VolRetention)) {
 141       bsendmsg(ua, _("Invalid retention period specified: %s\n"), val);
 142       return;
 143    }
 144    Mmsg(query, "UPDATE Media SET VolRetention=%s WHERE MediaId=%s",
 145       edit_uint64(mr->VolRetention, ed1), edit_int64(mr->MediaId,ed2));
 146    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 147       bsendmsg(ua, "%s", db_strerror(ua->db));
 148    } else {
 149       bsendmsg(ua, _("New retention period is: %s\n"),
 150          edit_utime(mr->VolRetention, ed1, sizeof(ed1)));
 151    }
 152 }
 153
 154 static void update_voluseduration(UAContext *ua, char *val, MEDIA_DBR *mr)
 155 {
 156    char ed1[150], ed2[50];
 157    POOL_MEM query(PM_MESSAGE);
 158
 159    if (!duration_to_utime(val, &mr->VolUseDuration)) {
 160       bsendmsg(ua, _("Invalid use duration specified: %s\n"), val);
 161       return;
 162    }
 163    Mmsg(query, "UPDATE Media SET VolUseDuration=%s WHERE MediaId=%s",
 164       edit_uint64(mr->VolUseDuration, ed1), edit_int64(mr->MediaId,ed2));
 165    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 166       bsendmsg(ua, "%s", db_strerror(ua->db));
 167    } else {
 168       bsendmsg(ua, _("New use duration is: %s\n"),
 169          edit_utime(mr->VolUseDuration, ed1, sizeof(ed1)));
 170    }
 171 }
 172
 173 static void update_volmaxjobs(UAContext *ua, char *val, MEDIA_DBR *mr)
 174 {
 175    POOL_MEM query(PM_MESSAGE);
 176    char ed1[50];
 177    Mmsg(query, "UPDATE Media SET MaxVolJobs=%s WHERE MediaId=%s",
 178       val, edit_int64(mr->MediaId,ed1));
 179    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 180       bsendmsg(ua, "%s", db_strerror(ua->db));
 181    } else {
 182       bsendmsg(ua, _("New max jobs is: %s\n"), val);
 183    }
 184 }
 185
 186 static void update_volmaxfiles(UAContext *ua, char *val, MEDIA_DBR *mr)
 187 {
 188    POOL_MEM query(PM_MESSAGE);
 189    char ed1[50];
 190    Mmsg(query, "UPDATE Media SET MaxVolFiles=%s WHERE MediaId=%s",
 191       val, edit_int64(mr->MediaId, ed1));
 192    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 193       bsendmsg(ua, "%s", db_strerror(ua->db));
 194    } else {
 195       bsendmsg(ua, _("New max files is: %s\n"), val);
 196    }
 197 }
 198
 199 static void update_volmaxbytes(UAContext *ua, char *val, MEDIA_DBR *mr)
 200 {
 201    uint64_t maxbytes;
 202    char ed1[50], ed2[50];
 203    POOL_MEM query(PM_MESSAGE);
 204
 205    if (!size_to_uint64(val, strlen(val), &maxbytes)) {
 206       bsendmsg(ua, _("Invalid max. bytes specification: %s\n"), val);
 207       return;
 208    }
 209    Mmsg(query, "UPDATE Media SET MaxVolBytes=%s WHERE MediaId=%s",
 210       edit_uint64(maxbytes, ed1), edit_int64(mr->MediaId, ed2));
 211    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 212       bsendmsg(ua, "%s", db_strerror(ua->db));
 213    } else {
 214       bsendmsg(ua, _("New Max bytes is: %s\n"), edit_uint64(maxbytes, ed1));
 215    }
 216 }
 217
 218 static void update_volrecycle(UAContext *ua, char *val, MEDIA_DBR *mr)
 219 {
 220    int recycle;
 221    char ed1[50];
 222
 223    POOL_MEM query(PM_MESSAGE);
 224    if (!is_yesno(val, &recycle)) {
 225       bsendmsg(ua, _("Invalid value. It must be yes or no.\n"));
 226       return;
 227    }
 228    Mmsg(query, "UPDATE Media SET Recycle=%d WHERE MediaId=%s",
 229       recycle, edit_int64(mr->MediaId, ed1));
 230    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 231       bsendmsg(ua, "%s", db_strerror(ua->db));
 232    } else {
 233       bsendmsg(ua, _("New Recycle flag is: %s\n"),
 234          mr->Recycle==1?_("yes"):_("no"));
 235    }
 236 }
 237
 238 static void update_volinchanger(UAContext *ua, char *val, MEDIA_DBR *mr)
 239 {
 240    int InChanger;
 241    char ed1[50];
 242
 243    POOL_MEM query(PM_MESSAGE);
 244    if (!is_yesno(val, &InChanger)) {
 245       bsendmsg(ua, _("Invalid value. It must be yes or no.\n"));
 246       return;
 247    }
 248    Mmsg(query, "UPDATE Media SET InChanger=%d WHERE MediaId=%s",
 249       InChanger, edit_int64(mr->MediaId, ed1));
 250    if (!db_sql_query(ua->db, query.c_str(), NULL, NULL)) {
 251       bsendmsg(ua, "%s", db_strerror(ua->db));
 252    } else {
 253       bsendmsg(ua, _("New InChanger flag is: %s\n"),
 254          mr->InChanger==1?_("yes"):_("no"));
 255    }
 256 }
 257
 258
 259 static void update_volslot(UAContext *ua, char *val, MEDIA_DBR *mr)
 260 {
 261    POOL_DBR pr;
 262
 263    memset(&pr, 0, sizeof(POOL_DBR));
 264    pr.PoolId = mr->PoolId;
 265    if (!db_get_pool_record(ua->jcr, ua->db, &pr)) {
 266       bsendmsg(ua, "%s", db_strerror(ua->db));
 267       return;
 268    }
 269    mr->Slot = atoi(val);
 270    if (pr.MaxVols > 0 && mr->Slot > (int)pr.MaxVols) {
 271       bsendmsg(ua, _("Invalid slot, it must be between 0 and MaxVols=%d\n"),
 272          pr.MaxVols);
 273       return;
 274    }
 275    /*
 276     * Make sure to use db_update... rather than doing this directly,
 277     *   so that any Slot is handled correctly.
 278     */
 279    if (!db_update_media_record(ua->jcr, ua->db, mr)) {
 280       bsendmsg(ua, _("Error updating media record Slot: ERR=%s"), db_strerror(ua->db));
 281    } else {
 282       bsendmsg(ua, _("New Slot is: %d\n"), mr->Slot);
 283    }
 284 }
 285
 286 /* Modify the Pool in which this Volume is located */
 287 static void update_vol_pool(UAContext *ua, char *val, MEDIA_DBR *mr, POOL_DBR *opr)
 288 {
 289    POOL_DBR pr;
 290    POOLMEM *query;
 291    char ed1[50], ed2[50];
 292
 293    memset(&pr, 0, sizeof(pr));
 294    bstrncpy(pr.Name, val, sizeof(pr.Name));
 295    if (!get_pool_dbr(ua, &pr)) {
 296       return;
 297    }
 298    mr->PoolId = pr.PoolId;            /* set new PoolId */
 299    /*
 300     */
 301    query = get_pool_memory(PM_MESSAGE);
 302    db_lock(ua->db);
 303    Mmsg(query, "UPDATE Media SET PoolId=%s WHERE MediaId=%s",
 304       edit_int64(mr->PoolId, ed1),
 305       edit_int64(mr->MediaId, ed2));
 306    if (!db_sql_query(ua->db, query, NULL, NULL)) {
 307       bsendmsg(ua, "%s", db_strerror(ua->db));
 308    } else {
 309       bsendmsg(ua, _("New Pool is: %s\n"), pr.Name);
 310       opr->NumVols--;
 311       if (!db_update_pool_record(ua->jcr, ua->db, opr)) {
 312          bsendmsg(ua, "%s", db_strerror(ua->db));
 313       }
 314       pr.NumVols++;
 315       if (!db_update_pool_record(ua->jcr, ua->db, &pr)) {
 316          bsendmsg(ua, "%s", db_strerror(ua->db));
 317       }
 318    }
 319    db_unlock(ua->db);
 320    free_pool_memory(query);
 321 }
 322
 323 /*
 324  * Refresh the Volume information from the Pool record
 325  */
 326 static void update_vol_from_pool(UAContext *ua, MEDIA_DBR *mr)
 327 {
 328    POOL_DBR pr;
 329
 330    memset(&pr, 0, sizeof(pr));
 331    pr.PoolId = mr->PoolId;
 332    if (!db_get_pool_record(ua->jcr, ua->db, &pr) ||
 333        !acl_access_ok(ua, Pool_ACL, pr.Name)) {
 334       return;
 335    }
 336    set_pool_dbr_defaults_in_media_dbr(mr, &pr);
 337    if (!db_update_media_defaults(ua->jcr, ua->db, mr)) {
 338       bsendmsg(ua, _("Error updating Volume record: ERR=%s"), db_strerror(ua->db));
 339    } else {
 340       bsendmsg(ua, _("Volume defaults updated from \"%s\" Pool record.\n"),
 341          pr.Name);
 342    }
 343 }
 344
 345 /*
 346  * Refresh the Volume information from the Pool record
 347  *   for all Volumes
 348  */
 349 static void update_all_vols_from_pool(UAContext *ua)
 350 {
 351    POOL_DBR pr;
 352    MEDIA_DBR mr;
 353
 354    memset(&pr, 0, sizeof(pr));
 355    memset(&mr, 0, sizeof(mr));
 356    if (!get_pool_dbr(ua, &pr)) {
 357       return;
 358    }
 359    set_pool_dbr_defaults_in_media_dbr(&mr, &pr);
 360    mr.PoolId = pr.PoolId;
 361    if (!db_update_media_defaults(ua->jcr, ua->db, &mr)) {
 362       bsendmsg(ua, _("Error updating Volume records: ERR=%s"), db_strerror(ua->db));
 363    } else {
 364       bsendmsg(ua, _("All Volume defaults updated from Pool record.\n"));
 365    }
 366 }
 367
 368
 369 /*
 370  * Update a media record -- allows you to change the
 371  *  Volume status. E.g. if you want Bacula to stop
 372  *  writing on the volume, set it to anything other
 373  *  than Append.
 374  */
 375 static int update_volume(UAContext *ua)
 376 {
 377    MEDIA_DBR mr;
 378    POOL_DBR pr;
 379    POOLMEM *query;
 380    char ed1[130];
 381    bool done = false;
 382    int i;
 383    const char *kw[] = {
 384       NT_("VolStatus"),                /* 0 */
 385       NT_("VolRetention"),             /* 1 */
 386       NT_("VolUse"),                   /* 2 */
 387       NT_("MaxVolJobs"),               /* 3 */
 388       NT_("MaxVolFiles"),              /* 4 */
 389       NT_("MaxVolBytes"),              /* 5 */
 390       NT_("Recycle"),                  /* 6 */
 391       NT_("InChanger"),                /* 7 */
 392       NT_("Slot"),                     /* 8 */
 393       NT_("Pool"),                     /* 9 */
 394       NT_("FromPool"),                 /* 10 */
 395       NT_("AllFromPool"),              /* 11 !!! see below !!! */
 396       NULL };
 397
 398 #define AllFromPool 11               /* keep this updated with above */
 399
 400    for (i=0; kw[i]; i++) {
 401       int j;
 402       POOL_DBR pr;
 403       if ((j=find_arg_with_value(ua, kw[i])) > 0) {
 404          if (i != AllFromPool && !select_media_dbr(ua, &mr)) {
 405             return 0;
 406          }
 407          switch (i) {
 408          case 0:
 409             update_volstatus(ua, ua->argv[j], &mr);
 410             break;
 411          case 1:
 412             update_volretention(ua, ua->argv[j], &mr);
 413             break;
 414          case 2:
 415             update_voluseduration(ua, ua->argv[j], &mr);
 416             break;
 417          case 3:
 418             update_volmaxjobs(ua, ua->argv[j], &mr);
 419             break;
 420          case 4:
 421             update_volmaxfiles(ua, ua->argv[j], &mr);
 422             break;
 423          case 5:
 424             update_volmaxbytes(ua, ua->argv[j], &mr);
 425             break;
 426          case 6:
 427             update_volrecycle(ua, ua->argv[j], &mr);
 428             break;
 429          case 7:
 430             update_volinchanger(ua, ua->argv[j], &mr);
 431             break;
 432          case 8:
 433             update_volslot(ua, ua->argv[j], &mr);
 434             break;
 435          case 9:
 436             memset(&pr, 0, sizeof(POOL_DBR));
 437             pr.PoolId = mr.PoolId;
 438             if (!db_get_pool_record(ua->jcr, ua->db, &pr)) {
 439                bsendmsg(ua, "%s", db_strerror(ua->db));
 440                break;
 441             }
 442             update_vol_pool(ua, ua->argv[j], &mr, &pr);
 443             break;
 444          case 10:
 445             update_vol_from_pool(ua, &mr);
 446             return 1;
 447          case 11:
 448             update_all_vols_from_pool(ua);
 449             return 1;
 450          }
 451          done = true;
 452       }
 453    }
 454
 455    for ( ; !done; ) {
 456       start_prompt(ua, _("Parameters to modify:\n"));
 457       add_prompt(ua, _("Volume Status"));              /* 0 */
 458       add_prompt(ua, _("Volume Retention Period"));    /* 1 */
 459       add_prompt(ua, _("Volume Use Duration"));        /* 2 */
 460       add_prompt(ua, _("Maximum Volume Jobs"));        /* 3 */
 461       add_prompt(ua, _("Maximum Volume Files"));       /* 4 */
 462       add_prompt(ua, _("Maximum Volume Bytes"));       /* 5 */
 463       add_prompt(ua, _("Recycle Flag"));               /* 6 */
 464       add_prompt(ua, _("Slot"));                       /* 7 */
 465       add_prompt(ua, _("InChanger Flag"));             /* 8 */
 466       add_prompt(ua, _("Volume Files"));               /* 9 */
 467       add_prompt(ua, _("Pool"));                       /* 10 */
 468       add_prompt(ua, _("Volume from Pool"));           /* 11 */
 469       add_prompt(ua, _("All Volumes from Pool"));      /* 12 */
 470       add_prompt(ua, _("Done"));                       /* 13 */
 471       i = do_prompt(ua, "", _("Select parameter to modify"), NULL, 0);
 472
 473       /* For All Volumes from Pool we don't need a Volume record */
 474       if (i != 12 && i != 13) {
 475          if (!select_media_dbr(ua, &mr)) {  /* Get Volume record */
 476             return 0;
 477          }
 478          bsendmsg(ua, _("Updating Volume \"%s\"\n"), mr.VolumeName);
 479       }
 480       switch (i) {
 481       case 0:                         /* Volume Status */
 482          /* Modify Volume Status */
 483          bsendmsg(ua, _("Current Volume status is: %s\n"), mr.VolStatus);
 484          start_prompt(ua, _("Possible Values are:\n"));
 485          add_prompt(ua, NT_("Append"));
 486          add_prompt(ua, NT_("Archive"));
 487          add_prompt(ua, NT_("Disabled"));
 488          add_prompt(ua, NT_("Full"));
 489          add_prompt(ua, NT_("Used"));
 490          add_prompt(ua, NT_("Cleaning"));
 491          if (strcmp(mr.VolStatus, NT_("Purged")) == 0) {
 492             add_prompt(ua, NT_("Recycle"));
 493          }
 494          add_prompt(ua, NT_("Read-Only"));
 495          if (do_prompt(ua, "", _("Choose new Volume Status"), ua->cmd, sizeof(mr.VolStatus)) < 0) {
 496             return 1;
 497          }
 498          update_volstatus(ua, ua->cmd, &mr);
 499          break;
 500       case 1:                         /* Retention */
 501          bsendmsg(ua, _("Current retention period is: %s\n"),
 502             edit_utime(mr.VolRetention, ed1, sizeof(ed1)));
 503          if (!get_cmd(ua, _("Enter Volume Retention period: "))) {
 504             return 0;
 505          }
 506          update_volretention(ua, ua->cmd, &mr);
 507          break;
 508
 509       case 2:                         /* Use Duration */
 510          bsendmsg(ua, _("Current use duration is: %s\n"),
 511             edit_utime(mr.VolUseDuration, ed1, sizeof(ed1)));
 512          if (!get_cmd(ua, _("Enter Volume Use Duration: "))) {
 513             return 0;
 514          }
 515          update_voluseduration(ua, ua->cmd, &mr);
 516          break;
 517
 518       case 3:                         /* Max Jobs */
 519          bsendmsg(ua, _("Current max jobs is: %u\n"), mr.MaxVolJobs);
 520          if (!get_pint(ua, _("Enter new Maximum Jobs: "))) {
 521             return 0;
 522          }
 523          update_volmaxjobs(ua, ua->cmd, &mr);
 524          break;
 525
 526       case 4:                         /* Max Files */
 527          bsendmsg(ua, _("Current max files is: %u\n"), mr.MaxVolFiles);
 528          if (!get_pint(ua, _("Enter new Maximum Files: "))) {
 529             return 0;
 530          }
 531          update_volmaxfiles(ua, ua->cmd, &mr);
 532          break;
 533
 534       case 5:                         /* Max Bytes */
 535          bsendmsg(ua, _("Current value is: %s\n"), edit_uint64(mr.MaxVolBytes, ed1));
 536          if (!get_cmd(ua, _("Enter new Maximum Bytes: "))) {
 537             return 0;
 538          }
 539          update_volmaxbytes(ua, ua->cmd, &mr);
 540          break;
 541
 542
 543       case 6:                         /* Recycle */
 544          bsendmsg(ua, _("Current recycle flag is: %s\n"),
 545             mr.Recycle==1?_("yes"):_("no"));
 546          if (!get_yesno(ua, _("Enter new Recycle status: "))) {
 547             return 0;
 548          }
 549          update_volrecycle(ua, ua->cmd, &mr);
 550          break;
 551
 552       case 7:                         /* Slot */
 553          bsendmsg(ua, _("Current Slot is: %d\n"), mr.Slot);
 554          if (!get_pint(ua, _("Enter new Slot: "))) {
 555             return 0;
 556          }
 557          update_volslot(ua, ua->cmd, &mr);
 558          break;
 559
 560       case 8:                         /* InChanger */
 561          bsendmsg(ua, _("Current InChanger flag is: %d\n"), mr.InChanger);
 562          if (!get_yesno(ua, _("Set InChanger flag? yes/no: "))) {
 563             return 0;
 564          }
 565          mr.InChanger = ua->pint32_val;
 566          /*
 567           * Make sure to use db_update... rather than doing this directly,
 568           *   so that any Slot is handled correctly.
 569           */
 570          if (!db_update_media_record(ua->jcr, ua->db, &mr)) {
 571             bsendmsg(ua, _("Error updating media record Slot: ERR=%s"), db_strerror(ua->db));
 572          } else {
 573             bsendmsg(ua, _("New InChanger flag is: %d\n"), mr.InChanger);
 574          }
 575          break;
 576
 577
 578       case 9:                         /* Volume Files */
 579          int32_t VolFiles;
 580          bsendmsg(ua, _("Warning changing Volume Files can result\n"
 581                         "in loss of data on your Volume\n\n"));
 582          bsendmsg(ua, _("Current Volume Files is: %u\n"), mr.VolFiles);
 583          if (!get_pint(ua, _("Enter new number of Files for Volume: "))) {
 584             return 0;
 585          }
 586          VolFiles = ua->pint32_val;
 587          if (VolFiles != (int)(mr.VolFiles + 1)) {
 588             bsendmsg(ua, _("Normally, you should only increase Volume Files by one!\n"));
 589             if (!get_yesno(ua, _("Continue? (yes/no): ")) || ua->pint32_val == 0) {
 590                break;
 591             }
 592          }
 593          query = get_pool_memory(PM_MESSAGE);
 594          Mmsg(query, "UPDATE Media SET VolFiles=%u WHERE MediaId=%s",
 595             VolFiles, edit_int64(mr.MediaId, ed1));
 596          if (!db_sql_query(ua->db, query, NULL, NULL)) {
 597             bsendmsg(ua, "%s", db_strerror(ua->db));
 598          } else {
 599             bsendmsg(ua, _("New Volume Files is: %u\n"), VolFiles);
 600          }
 601          free_pool_memory(query);
 602          break;
 603
 604       case 10:                        /* Volume's Pool */
 605          memset(&pr, 0, sizeof(POOL_DBR));
 606          pr.PoolId = mr.PoolId;
 607          if (!db_get_pool_record(ua->jcr, ua->db, &pr)) {
 608             bsendmsg(ua, "%s", db_strerror(ua->db));
 609             return 0;
 610          }
 611          bsendmsg(ua, _("Current Pool is: %s\n"), pr.Name);
 612          if (!get_cmd(ua, _("Enter new Pool name: "))) {
 613             return 0;
 614          }
 615          update_vol_pool(ua, ua->cmd, &mr, &pr);
 616          return 1;
 617
 618       case 11:
 619          update_vol_from_pool(ua, &mr);
 620          return 1;
 621       case 12:
 622          update_all_vols_from_pool(ua);
 623          return 1;
 624       default:                        /* Done or error */
 625          bsendmsg(ua, _("Selection terminated.\n"));
 626          return 1;
 627       }
 628    }
 629    return 1;
 630 }
 631
 632 /*
 633  * Update pool record -- pull info from current POOL resource
 634  */
 635 static int update_pool(UAContext *ua)
 636 {
 637    POOL_DBR  pr;
 638    int id;
 639    POOL *pool;
 640    POOLMEM *query;
 641    char ed1[50];
 642
 643    pool = get_pool_resource(ua);
 644    if (!pool) {
 645       return 0;
 646    }
 647
 648    memset(&pr, 0, sizeof(pr));
 649    bstrncpy(pr.Name, pool->hdr.name, sizeof(pr.Name));
 650    if (!get_pool_dbr(ua, &pr)) {
 651       return 0;
 652    }
 653
 654    set_pooldbr_from_poolres(&pr, pool, POOL_OP_UPDATE); /* update */
 655
 656    id = db_update_pool_record(ua->jcr, ua->db, &pr);
 657    if (id <= 0) {
 658       bsendmsg(ua, _("db_update_pool_record returned %d. ERR=%s\n"),
 659          id, db_strerror(ua->db));
 660    }
 661    query = get_pool_memory(PM_MESSAGE);
 662    Mmsg(query, list_pool, edit_int64(pr.PoolId, ed1));
 663    db_list_sql_query(ua->jcr, ua->db, query, prtit, ua, 1, HORZ_LIST);
 664    free_pool_memory(query);
 665    bsendmsg(ua, _("Pool DB record updated from resource.\n"));
 666    return 1;
 667 }