]> git.sur5r.net Git - bacula/bacula/blob - bacula/src/stored/status.c
24Feb05
[bacula/bacula] / bacula / src / stored / status.c
1 /*
2  *  This file handles the status command
3  *
4  *     Kern Sibbald, May MMIII
5  *
6  *   Version $Id$
7  *
8  */
9 /*
10    Copyright (C) 2000-2005 Kern Sibbald
11
12    This program is free software; you can redistribute it and/or
13    modify it under the terms of the GNU General Public License as
14    published by the Free Software Foundation; either version 2 of
15    the License, or (at your option) any later version.
16
17    This program is distributed in the hope that it will be useful,
18    but WITHOUT ANY WARRANTY; without even the implied warranty of
19    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
20    General Public License for more details.
21
22    You should have received a copy of the GNU General Public
23    License along with this program; if not, write to the Free
24    Software Foundation, Inc., 59 Temple Place - Suite 330, Boston,
25    MA 02111-1307, USA.
26
27  */
28
29 #include "bacula.h"
30 #include "stored.h"
31
32 /* Exported variables */
33
34 /* Imported variables */
35 extern BSOCK *filed_chan;
36 extern int r_first, r_last;
37 extern struct s_res resources[];
38 extern char my_name[];
39 extern time_t daemon_start_time;
40 extern int num_jobs_run;
41
42
43 /* Static variables */
44 static char qstatus[] = ".status %127s\n";
45
46 static char OKqstatus[]   = "3000 OK .status\n";
47 static char DotStatusJob[] = "JobId=%d JobStatus=%c JobErrors=%d\n";
48
49
50 /* Forward referenced functions */
51 static void send_blocked_status(JCR *jcr, DEVICE *dev);
52 static void list_terminated_jobs(void *arg);
53 static void list_running_jobs(BSOCK *user);
54 static void sendit(const char *msg, int len, void *arg);
55 static const char *level_to_str(int level);
56
57
58 /*
59  * Status command from Director
60  */
61 bool status_cmd(JCR *jcr)
62 {
63    DEVRES *device;
64    DEVICE *dev;
65    BSOCK *user = jcr->dir_bsock;
66    char dt[MAX_TIME_LENGTH];
67    char b1[30], b2[30], b3[30];
68    int bpb;
69
70    bnet_fsend(user, "\n%s Version: " VERSION " (" BDATE ") %s %s %s\n", my_name,
71               HOST_OS, DISTNAME, DISTVER);
72    bstrftime_nc(dt, sizeof(dt), daemon_start_time);
73    bnet_fsend(user, _("Daemon started %s, %d Job%s run since started.\n"), dt, num_jobs_run,
74         num_jobs_run == 1 ? "" : "s");
75    if (debug_level > 0) {
76       char b1[35], b2[35], b3[35], b4[35];
77       bnet_fsend(user, _(" Heap: bytes=%s max_bytes=%s bufs=%s max_bufs=%s\n"),
78             edit_uint64_with_commas(sm_bytes, b1),
79             edit_uint64_with_commas(sm_max_bytes, b2),
80             edit_uint64_with_commas(sm_buffers, b3),
81             edit_uint64_with_commas(sm_max_buffers, b4));
82    }
83
84    /*
85     * List running jobs
86     */
87    list_running_jobs(user);
88
89    /*
90     * List terminated jobs
91     */
92    list_terminated_jobs(user);
93
94    /*
95     * List devices
96     */
97    bnet_fsend(user, _("\nDevice status:\n"));
98    LockRes();
99    foreach_res(device, R_DEVICE) {
100       dev = device->dev;
101       if (dev && dev->is_open()) {
102          if (dev->is_labeled()) {
103             bnet_fsend(user, _("Device \"%s\" is mounted with Volume \"%s\"\n"),
104                dev_name(dev), dev->VolHdr.VolName);
105          } else {
106             bnet_fsend(user, _("Device \"%s\" open but no Bacula volume is mounted.\n"), dev_name(dev));
107          }
108          send_blocked_status(jcr, dev);
109          if (dev->can_append()) {
110             bpb = dev->VolCatInfo.VolCatBlocks;
111             if (bpb <= 0) {
112                bpb = 1;
113             }
114             bpb = dev->VolCatInfo.VolCatBytes / bpb;
115             bnet_fsend(user, _("    Total Bytes=%s Blocks=%s Bytes/block=%s\n"),
116                edit_uint64_with_commas(dev->VolCatInfo.VolCatBytes, b1),
117                edit_uint64_with_commas(dev->VolCatInfo.VolCatBlocks, b2),
118                edit_uint64_with_commas(bpb, b3));
119          } else {  /* reading */
120             bpb = dev->VolCatInfo.VolCatReads;
121             if (bpb <= 0) {
122                bpb = 1;
123             }
124             if (dev->VolCatInfo.VolCatRBytes > 0) {
125                bpb = dev->VolCatInfo.VolCatRBytes / bpb;
126             } else {
127                bpb = 0;
128             }
129             bnet_fsend(user, _("    Total Bytes Read=%s Blocks Read=%s Bytes/block=%s\n"),
130                edit_uint64_with_commas(dev->VolCatInfo.VolCatRBytes, b1),
131                edit_uint64_with_commas(dev->VolCatInfo.VolCatReads, b2),
132                edit_uint64_with_commas(bpb, b3));
133          }
134          bnet_fsend(user, _("    Positioned at File=%s Block=%s\n"),
135             edit_uint64_with_commas(dev->file, b1),
136             edit_uint64_with_commas(dev->block_num, b2));
137
138       } else {
139          bnet_fsend(user, _("Archive \"%s\" is not open or does not exist.\n"), device->hdr.name);
140          send_blocked_status(jcr, dev);
141       }
142    }
143    UnlockRes();
144
145 #ifdef xxx
146    if (debug_level > 0) {
147       bnet_fsend(user, "====\n\n");
148       dump_resource(R_DEVICE, resources[R_DEVICE-r_first].res_head, sendit, user);
149    }
150    bnet_fsend(user, "====\n\n");
151 #endif
152
153    list_spool_stats(user);
154
155    bnet_sig(user, BNET_EOD);
156    return true;
157 }
158
159 static void send_blocked_status(JCR *jcr, DEVICE *dev)
160 {
161    BSOCK *user = jcr->dir_bsock;
162    DCR *dcr = jcr->dcr;
163
164    if (!dev) {
165       return;
166    }
167    switch (dev->dev_blocked) {
168    case BST_UNMOUNTED:
169       bnet_fsend(user, _("    Device is BLOCKED. User unmounted.\n"));
170       break;
171    case BST_UNMOUNTED_WAITING_FOR_SYSOP:
172       bnet_fsend(user, _("    Device is BLOCKED. User unmounted during wait for media/mount.\n"));
173       break;
174    case BST_WAITING_FOR_SYSOP:
175       if (jcr->JobStatus == JS_WaitMount) {
176          bnet_fsend(user, _("    Device is BLOCKED waiting for mount of volume \"%s\".\n"),
177             dcr->VolumeName);
178       } else {
179          bnet_fsend(user, _("    Device is BLOCKED waiting for appendable media.\n"));
180       }
181       break;
182    case BST_DOING_ACQUIRE:
183       bnet_fsend(user, _("    Device is being initialized.\n"));
184       break;
185    case BST_WRITING_LABEL:
186       bnet_fsend(user, _("    Device is blocked labeling a Volume.\n"));
187       break;
188    default:
189       break;
190    }
191    if (debug_level > 1) {
192       bnet_fsend(user, _("Configured device capabilities:\n"));
193       bnet_fsend(user, "%sEOF ", dev->capabilities & CAP_EOF ? "" : "!");
194       bnet_fsend(user, "%sBSR ", dev->capabilities & CAP_BSR ? "" : "!");
195       bnet_fsend(user, "%sBSF ", dev->capabilities & CAP_BSF ? "" : "!");
196       bnet_fsend(user, "%sFSR ", dev->capabilities & CAP_FSR ? "" : "!");
197       bnet_fsend(user, "%sFSF ", dev->capabilities & CAP_FSF ? "" : "!");
198       bnet_fsend(user, "%sEOM ", dev->capabilities & CAP_EOM ? "" : "!");
199       bnet_fsend(user, "%sREM ", dev->capabilities & CAP_REM ? "" : "!");
200       bnet_fsend(user, "%sRACCESS ", dev->capabilities & CAP_RACCESS ? "" : "!");
201       bnet_fsend(user, "%sAUTOMOUNT ", dev->capabilities & CAP_AUTOMOUNT ? "" : "!");
202       bnet_fsend(user, "%sLABEL ", dev->capabilities & CAP_LABEL ? "" : "!");
203       bnet_fsend(user, "%sANONVOLS ", dev->capabilities & CAP_ANONVOLS ? "" : "!");
204       bnet_fsend(user, "%sALWAYSOPEN ", dev->capabilities & CAP_ALWAYSOPEN ? "" : "!");
205       bnet_fsend(user, "\n");
206
207       bnet_fsend(user, _("Device status:\n"));
208       bnet_fsend(user, "%sOPENED ", dev->is_open() ? "" : "!");
209       bnet_fsend(user, "%sTAPE ", dev->is_tape() ? "" : "!");
210       bnet_fsend(user, "%sLABEL ", dev->is_labeled() ? "" : "!");
211       bnet_fsend(user, "%sMALLOC ", dev->state & ST_MALLOC ? "" : "!");
212       bnet_fsend(user, "%sAPPEND ", dev->can_append() ? "" : "!");
213       bnet_fsend(user, "%sREAD ", dev->can_read() ? "" : "!");
214       bnet_fsend(user, "%sEOT ", dev->at_eot() ? "" : "!");
215       bnet_fsend(user, "%sWEOT ", dev->state & ST_WEOT ? "" : "!");
216       bnet_fsend(user, "%sEOF ", dev->at_eof() ? "" : "!");
217       bnet_fsend(user, "%sNEXTVOL ", dev->state & ST_NEXTVOL ? "" : "!");
218       bnet_fsend(user, "%sSHORT ", dev->state & ST_SHORT ? "" : "!");
219       bnet_fsend(user, "%sMOUNTED ", dev->state & ST_MOUNTED ? "" : "!");
220       bnet_fsend(user, "\n");
221
222       bnet_fsend(user, _("Device parameters:\n"));
223       bnet_fsend(user, "Archive name: %s Device name: %s\n", dev->dev_name,
224          dev->device->hdr.name);
225       bnet_fsend(user, "File=%u block=%u\n", dev->file, dev->block_num);
226       bnet_fsend(user, "Min block=%u Max block=%u\n", dev->min_block_size, dev->max_block_size);
227    }
228
229 }
230
231 static void list_running_jobs(BSOCK *user)
232 {
233    bool found = false;
234    int bps, sec;
235    JCR *jcr;
236    char JobName[MAX_NAME_LENGTH];
237    char b1[30], b2[30], b3[30];
238
239    bnet_fsend(user, _("\nRunning Jobs:\n"));
240    lock_jcr_chain();
241    foreach_jcr(jcr) {
242       if (jcr->JobStatus == JS_WaitFD) {
243          bnet_fsend(user, _("%s Job %s waiting for Client connection.\n"),
244             job_type_to_str(jcr->JobType), jcr->Job);
245       }
246       if (jcr->dcr && jcr->dcr->device) {
247          bstrncpy(JobName, jcr->Job, sizeof(JobName));
248          /* There are three periods after the Job name */
249          char *p;
250          for (int i=0; i<3; i++) {
251             if ((p=strrchr(JobName, '.')) != NULL) {
252                *p = 0;
253             }
254          }
255          bnet_fsend(user, _("%s %s job %s JobId=%d Volume=\"%s\" device=\"%s\"\n"),
256                    job_level_to_str(jcr->JobLevel),
257                    job_type_to_str(jcr->JobType),
258                    JobName,
259                    jcr->JobId,
260                    jcr->dcr->VolumeName,
261                    jcr->dcr->device->device_name);
262          sec = time(NULL) - jcr->run_time;
263          if (sec <= 0) {
264             sec = 1;
265          }
266          bps = jcr->JobBytes / sec;
267          bnet_fsend(user, _("    Files=%s Bytes=%s Bytes/sec=%s\n"),
268             edit_uint64_with_commas(jcr->JobFiles, b1),
269             edit_uint64_with_commas(jcr->JobBytes, b2),
270             edit_uint64_with_commas(bps, b3));
271          found = true;
272 #ifdef DEBUG
273          if (jcr->file_bsock) {
274             bnet_fsend(user, "    FDReadSeqNo=%s in_msg=%u out_msg=%d fd=%d\n",
275                edit_uint64_with_commas(jcr->file_bsock->read_seqno, b1),
276                jcr->file_bsock->in_msg_no, jcr->file_bsock->out_msg_no,
277                jcr->file_bsock->fd);
278          } else {
279             bnet_fsend(user, "    FDSocket closed\n");
280          }
281 #endif
282       }
283       free_locked_jcr(jcr);
284    }
285    unlock_jcr_chain();
286    if (!found) {
287       bnet_fsend(user, _("No Jobs running.\n"));
288    }
289    bnet_fsend(user, "====\n");
290 }
291
292 static void list_terminated_jobs(void *arg)
293 {
294    char dt[MAX_TIME_LENGTH], b1[30], b2[30];
295    char level[10];
296    struct s_last_job *je;
297    const char *msg;
298
299    if (last_jobs->size() == 0) {
300       msg = _("No Terminated Jobs.\n");
301       sendit(msg, strlen(msg), arg);
302       return;
303    }
304    lock_last_jobs_list();
305    msg =  _("\nTerminated Jobs:\n");
306    sendit(msg, strlen(msg), arg);
307    msg =  _(" JobId  Level   Files          Bytes Status   Finished        Name \n");
308    sendit(msg, strlen(msg), arg);
309    msg = _("======================================================================\n");
310    sendit(msg, strlen(msg), arg);
311    foreach_dlist(je, last_jobs) {
312       char JobName[MAX_NAME_LENGTH];
313       const char *termstat;
314       char buf[1000];
315
316       bstrftime_nc(dt, sizeof(dt), je->end_time);
317       switch (je->JobType) {
318       case JT_ADMIN:
319       case JT_RESTORE:
320          bstrncpy(level, "    ", sizeof(level));
321          break;
322       default:
323          bstrncpy(level, level_to_str(je->JobLevel), sizeof(level));
324          level[4] = 0;
325          break;
326       }
327       switch (je->JobStatus) {
328       case JS_Created:
329          termstat = "Created";
330          break;
331       case JS_FatalError:
332       case JS_ErrorTerminated:
333          termstat = "Error";
334          break;
335       case JS_Differences:
336          termstat = "Diffs";
337          break;
338       case JS_Canceled:
339          termstat = "Cancel";
340          break;
341       case JS_Terminated:
342          termstat = "OK";
343          break;
344       default:
345          termstat = "Other";
346          break;
347       }
348       bstrncpy(JobName, je->Job, sizeof(JobName));
349       /* There are three periods after the Job name */
350       char *p;
351       for (int i=0; i<3; i++) {
352          if ((p=strrchr(JobName, '.')) != NULL) {
353             *p = 0;
354          }
355       }
356       bsnprintf(buf, sizeof(buf), _("%6d  %-6s %8s %14s %-7s  %-8s %s\n"),
357          je->JobId,
358          level,
359          edit_uint64_with_commas(je->JobFiles, b1),
360          edit_uint64_with_commas(je->JobBytes, b2),
361          termstat,
362          dt, JobName);
363       sendit(buf, strlen(buf), arg);
364    }
365    sendit("====\n", 5, arg);
366    unlock_last_jobs_list();
367 }
368
369 /*
370  * Convert Job Level into a string
371  */
372 static const char *level_to_str(int level)
373 {
374    const char *str;
375
376    switch (level) {
377    case L_BASE:
378       str = _("Base");
379    case L_FULL:
380       str = _("Full");
381       break;
382    case L_INCREMENTAL:
383       str = _("Incremental");
384       break;
385    case L_DIFFERENTIAL:
386       str = _("Differential");
387       break;
388    case L_SINCE:
389       str = _("Since");
390       break;
391    case L_VERIFY_CATALOG:
392       str = _("Verify Catalog");
393       break;
394    case L_VERIFY_INIT:
395       str = _("Init Catalog");
396       break;
397    case L_VERIFY_VOLUME_TO_CATALOG:
398       str = _("Volume to Catalog");
399       break;
400    case L_VERIFY_DISK_TO_CATALOG:
401       str = _("Disk to Catalog");
402       break;
403    case L_VERIFY_DATA:
404       str = _("Data");
405       break;
406    case L_NONE:
407       str = " ";
408       break;
409    default:
410       str = _("Unknown Job Level");
411       break;
412    }
413    return str;
414 }
415
416 /*
417  * Send to Director
418  */
419 static void sendit(const char *msg, int len, void *arg)
420 {
421    BSOCK *user = (BSOCK *)arg;
422
423    memcpy(user->msg, msg, len+1);
424    user->msglen = len+1;
425    bnet_send(user);
426 }
427
428 /*
429  * .status command from Director
430  */
431 bool qstatus_cmd(JCR *jcr)
432 {
433    BSOCK *dir = jcr->dir_bsock;
434    POOL_MEM time;
435    JCR *njcr;
436    s_last_job* job;
437
438    if (sscanf(dir->msg, qstatus, time.c_str()) != 1) {
439       pm_strcpy(jcr->errmsg, dir->msg);
440       Jmsg1(jcr, M_FATAL, 0, _("Bad .status command: %s\n"), jcr->errmsg);
441       bnet_fsend(dir, "3900 Bad .status command, missing argument.\n");
442       bnet_sig(dir, BNET_EOD);
443       return false;
444    }
445    unbash_spaces(time);
446
447    if (strcmp(time.c_str(), "current") == 0) {
448       bnet_fsend(dir, OKqstatus, time.c_str());
449       lock_jcr_chain();
450       foreach_jcr(njcr) {
451          if (njcr->JobId != 0) {
452             bnet_fsend(dir, DotStatusJob, njcr->JobId, njcr->JobStatus, njcr->JobErrors);
453          }
454          free_locked_jcr(njcr);
455       }
456       unlock_jcr_chain();
457    }
458    else if (strcmp(time.c_str(), "last") == 0) {
459       bnet_fsend(dir, OKqstatus, time.c_str());
460       if ((last_jobs) && (last_jobs->size() > 0)) {
461          job = (s_last_job*)last_jobs->last();
462          bnet_fsend(dir, DotStatusJob, job->JobId, job->JobStatus, job->Errors);
463       }
464    }
465    else {
466       pm_strcpy(jcr->errmsg, dir->msg);
467       Jmsg1(jcr, M_FATAL, 0, _("Bad .status command: %s\n"), jcr->errmsg);
468       bnet_fsend(dir, "3900 Bad .status command, wrong argument.\n");
469       bnet_sig(dir, BNET_EOD);
470       return false;
471    }
472    bnet_sig(dir, BNET_EOD);
473    return true;
474 }