git.gag.com Git - debian/amanda/blob - perl/Amanda/Logfile.swg

   1 /*
   2  * Copyright (c) Zmanda, Inc.  All Rights Reserved.
   3  *
   4  * This library is free software; you can redistribute it and/or modify it
   5  * under the terms of the GNU Lesser General Public License version 2.1
   6  * as published by the Free Software Foundation.
   7  *
   8  * This library is distributed in the hope that it will be useful, but
   9  * WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  10  * or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU Lesser General Public
  11  * License for more details.
  12  *
  13  * You should have received a copy of the GNU Lesser General Public License
  14  * along with this library; if not, write to the Free Software Foundation,
  15  * Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307 USA.
  16  *
  17  * Contact information: Zmanda Inc., 505 N Mathlida Ave, Suite 120
  18  * Sunnyvale, CA 94085, USA, or: http://www.zmanda.com
  19  */
  20
  21 %module "Amanda::Logfile"
  22 %include "amglue/amglue.swg"
  23 %include "exception.i"
  24 %include "amglue/dumpspecs.swg"
  25 %import "Amanda/Cmdline.swg"
  26
  27 %{
  28 #include <glib.h>
  29 #include "logfile.h"
  30 #include "find.h"
  31 #include "diskfile.h" /* for the gross hack, below */
  32 %}
  33
  34 %perlcode %{
  35 =head1 NAME
  36
  37 Amanda::Logfile - manage Amanda trace logs
  38
  39 =head1 SYNOPSIS
  40
  41   use Amanda::Logfile qw(:logtype_t); # XXX change
  42   use Amanda::Config qw( :getconf config_dir_relative );
  43
  44   for my $logfile (Amanda::Logfile::find_log()) {
  45     $logfile = config_dir_relative(getconf($CNF_LOGDIR)) . "/" . $logfile;
  46
  47     my $hdl = Amanda::Logfile::open_logfile($logfile);
  48     while (my ($type, $prog, $str) = Amanda::Logfile::get_logline($hdl)) {
  49       if ($type == $L_INFO) {
  50         my $pname = Amanda::Logfile::program_t_to_string($prog);
  51         print "Found info line from $pname: $str\n";
  52       }
  53     }
  54     Amanda::Logfile::close_logfile($log);
  55
  56     my @dumps = Amanda::Logfile::search_logfile("TapeLabel-001", "19780615", $logfile);
  57
  58     my @matching = Amanda::Logfile::dumps_match([@dumps], "myhost", "/usr", undef, undef, 0);
  59     for my $dump (@matching) {
  60       print "$dump->{'label'}:$dump->{'filenum'} = $dump->{'hostname'}:$dump->{'disk'}\n";
  61     }
  62   }
  63
  64 =head1 API STATUS
  65
  66 Stabilizing
  67
  68 =head1 RAW LOGFILE ACCESS
  69
  70 This section corresponds to the C C<logfile> module.
  71
  72 Raw access to logfiles is accomplished by opening a logfile and
  73 fetching log lines one by one via the C<get_logline> function.
  74
  75 A log line is represented by a list C<($type, $prog, $string)>
  76 where C<$type> is one of the C<L_*> constants (available in export
  77 tag C<logtype_t>), C<$prog> is one of the C<P_*> constants (available
  78 in export tag C<program_t>), and C<$str> is the remainder of the line.
  79
  80 Both families of constants can be converted to symbolic names with
  81 C<logtype_t_to_string> and C<program_t_to_string>, respectively.
  82
  83 =head2 FUNCTIONS
  84
  85 =over
  86
  87 =item C<open_logfile($filename)>
  88
  89 Opens a logfile for reading, returning an opaque log file handle.
  90
  91 =item C<close_logfile($handle)>
  92
  93 Closes a log file handle.
  94
  95 =item C<get_logline($handle)>
  96
  97 Return a list as described above representing the next log line in
  98 C<$handle>, or nothing at the end of the logfile.
  99
 100 =back
 101
 102 All of these functions can be imported by name if desired.
 103
 104 =head1 Amanda::Find::find_result_t objects
 105
 106 These objects contain information about dumps, as read from logfiles.
 107 Instance variables are:
 108
 109 =over
 110
 111 =item C<$timestamp>
 112
 113 =item C<$hostname>
 114
 115 =item C<$diskname>
 116
 117 =item C<$level>
 118
 119 =item C<$label>
 120
 121 =item C<$filenum>
 122
 123 =item C<$status>
 124
 125 =item C<$partnum>
 126
 127 =back
 128
 129 =head1 HIGHER-LEVEL FUNCTIONS
 130
 131 Functions in this section extract information from logfiles.
 132
 133 =over
 134
 135 =item C<find_log()>
 136
 137 Return a list of logfiles for active tapes.  The tapelist must be loaded before
 138 this function is called (see L<Amanda::Tapelist>).
 139
 140 =item C<search_logfile($label, $datestamp, $logfile, $add_missing_disks)>
 141
 142 Return all results in C<$logfile> matching C<$label> and C<$datestamp>.
 143 If C<$add_missing_disks> is true, then any disks in the logfile
 144 not present in the disklist are added to the disklist; otherwise,
 145 such dumps are skipped.
 146
 147 =item C<dumps_match([@results], $hostname, $diskname, $datestamp, $level, $ok)>
 148
 149 Return a filtered version of C<@results> containing only results that match the
 150 given expressions.  If C<$ok> is true, don't match partial results.  Note that
 151 C<$level> is given as a string, since it is a match expression.
 152
 153 All of these functions can be imported by name.
 154
 155 =cut
 156 %}
 157
 158 amglue_export_ok(
 159     open_logfile get_logline close_logfile
 160 );
 161
 162
 163 amglue_add_enum_tag_fns(logtype_t);
 164 amglue_add_constant(L_BOGUS, logtype_t);
 165 amglue_add_constant(L_FATAL, logtype_t);
 166 amglue_add_constant(L_ERROR, logtype_t);
 167 amglue_add_constant(L_WARNING, logtype_t);
 168 amglue_add_constant(L_INFO, logtype_t);
 169 amglue_add_constant(L_SUMMARY, logtype_t);
 170 amglue_add_constant(L_START, logtype_t);
 171 amglue_add_constant(L_FINISH, logtype_t);
 172 amglue_add_constant(L_DISK, logtype_t);
 173 amglue_add_constant(L_DONE, logtype_t);
 174 amglue_add_constant(L_PART, logtype_t);
 175 amglue_add_constant(L_PARTPARTIAL, logtype_t);
 176 amglue_add_constant(L_SUCCESS, logtype_t);
 177 amglue_add_constant(L_PARTIAL, logtype_t);
 178 amglue_add_constant(L_FAIL, logtype_t);
 179 amglue_add_constant(L_STRANGE, logtype_t);
 180 amglue_add_constant(L_CHUNK, logtype_t);
 181 amglue_add_constant(L_CHUNKSUCCESS, logtype_t);
 182 amglue_add_constant(L_STATS, logtype_t);
 183 amglue_add_constant(L_MARKER, logtype_t);
 184 amglue_add_constant(L_CONT, logtype_t);
 185
 186 amglue_add_enum_tag_fns(program_t);
 187 amglue_add_constant(P_UNKNOWN, program_t);
 188 amglue_add_constant(P_PLANNER, program_t);
 189 amglue_add_constant(P_DRIVER, program_t);
 190 amglue_add_constant(P_REPORTER, program_t);
 191 amglue_add_constant(P_DUMPER, program_t);
 192 amglue_add_constant(P_CHUNKER, program_t);
 193 amglue_add_constant(P_TAPER, program_t);
 194 amglue_add_constant(P_AMFLUSH, program_t);
 195
 196 /* TODO: support for writing logfiles is omitted for the moment. */
 197
 198 %inline %{
 199 /* open_ and close_logfile are both simple wrappers around fopen/fclose. */
 200 typedef FILE loghandle;
 201
 202 loghandle *open_logfile(char *filename) {
 203     return fopen(filename, "r");
 204 }
 205 %}
 206
 207 %inline %{
 208 void close_logfile(loghandle *logfile) {
 209     if (logfile) fclose(logfile);
 210 }
 211 %}
 212
 213 /* We fake the return type of get_logline, and use a typemap to
 214  * slurp curstr, curprog, and curlog into a return value.  */
 215 %{
 216 typedef int LOGLINE_RETURN;
 217 %}
 218 %typemap(out) LOGLINE_RETURN {
 219     if ($1 != 0) {
 220         EXTEND(SP, 3);
 221         $result = sv_2mortal(newSViv(curlog));
 222         argvi++;
 223         $result = sv_2mortal(newSViv(curprog));
 224         argvi++;
 225         $result = sv_2mortal(newSVpv(curstr, 0));
 226         argvi++;
 227     }
 228     /* otherwise (end of logfile) return an empty list */
 229 }
 230 LOGLINE_RETURN get_logline(FILE *logfile);
 231
 232 typedef struct {
 233     %extend {
 234         /* destructor */
 235         ~find_result_t() {
 236             find_result_t *selfp = self;
 237             free_find_result(&selfp);
 238         }
 239     }
 240
 241     %immutable;
 242     char *timestamp;
 243     char *hostname;
 244     char *diskname;
 245     int level;
 246     char *label;
 247     off_t filenum;
 248     char *status;
 249     char *partnum;
 250     %mutable;
 251 } find_result_t;
 252
 253 /* This typemap is used in a few functions.  It converts a linked list of find_result_t's
 254  * into an array of same, de-linking the list in the process.  This gives ownership of the
 255  * objects to perl, which is consistent with the C interface to this module.
 256  */
 257 %typemap(out) find_result_t * {
 258     find_result_t *iter;
 259     int len;
 260
 261     /* measure the list and make room on the perl stack */
 262     for (len=0, iter=$1; iter; iter=iter->next) len++;
 263     EXTEND(SP, len);
 264
 265     iter = $1;
 266     while (iter) {
 267         find_result_t *next;
 268         /* Let SWIG take ownership of the object */
 269         $result = SWIG_NewPointerObj(iter, $descriptor(find_result_t *), SWIG_OWNER | SWIG_SHADOW);
 270         argvi++;
 271
 272         /* null out the 'next' field */
 273         next = iter->next;
 274         iter->next = NULL;
 275         iter = next;
 276     }
 277 }
 278
 279 /* Similarly, on input we link an array full of find_result_t's.  The list is then
 280  * unlinked on return.  Note that the array is supplied as an arrayref (since it's
 281  * usually the first argument).
 282  */
 283 %typemap(in) find_result_t * {
 284     AV *av;
 285     I32 len, i;
 286     find_result_t *head = NULL, *tail = NULL;
 287
 288     if (!SvROK($input) || SvTYPE(SvRV($input)) != SVt_PVAV) {
 289         SWIG_exception(SWIG_TypeError, "expected an arrayref of find_result_t's");
 290     }
 291
 292     av = (AV *)SvRV($input);
 293     len = av_len(av) + 1;
 294
 295     for (i = 0; i < len; i++) {
 296         SV **val = av_fetch(av, i, 0);
 297         find_result_t *r;
 298
 299         if (!val || SWIG_ConvertPtr(*val, (void **)&r, $descriptor(find_result_t *), 0) == -1) {
 300             SWIG_exception(SWIG_TypeError, "array member is not a find_result_t");
 301         }
 302
 303         if (!head) {
 304             head = tail = r;
 305         } else {
 306             tail->next = r;
 307             tail = r;
 308         }
 309
 310         tail->next = NULL;
 311     }
 312
 313     /* point to the head of that list */
 314     $1 = head;
 315 }
 316
 317 %typemap(freearg) find_result_t * {
 318     find_result_t *iter = $1, *next;
 319
 320     /* undo all the links we added earlier */
 321     while (iter) {
 322         next = iter->next;
 323         iter->next = NULL;
 324         iter = next;
 325     }
 326 }
 327
 328 %typemap(out) char ** {
 329     char **iter;
 330     int len, i;
 331
 332     /* measure the length of the array and make sure perl has enough room */
 333     for (len=0, iter=$1; *iter; iter++) len++;
 334     EXTEND(SP, len);
 335
 336     /* now copy it to the perl stack */
 337     for (i=0, iter=$1; *iter; iter++, i++) {
 338         $result = sv_2mortal(newSVpv(*iter, 0));
 339         argvi++;
 340     }
 341 }
 342
 343 amglue_export_ok(
 344     find_log search_logfile dumps_match
 345 );
 346
 347 char **find_log(void);
 348
 349 %rename(search_logfile) search_logfile_wrap;
 350 %inline %{
 351 find_result_t *search_logfile_wrap(char *label, char *datestamp,
 352                                    char *logfile, int add_missing_disks) {
 353     find_result_t *rv = NULL;
 354
 355     /* We use a static variable to collect any unrecognized disks */
 356     static disklist_t unrecognized_disks = { NULL, NULL };
 357
 358     search_logfile(&rv, label, datestamp, logfile,
 359         add_missing_disks? &unrecognized_disks : NULL);
 360
 361     return rv;
 362 }
 363 %}
 364
 365 find_result_t *dumps_match(find_result_t *output_find, char *hostname,
 366                            char *diskname, char *datestamp, char *level, int ok);
 367
 368 find_result_t *dumps_match_dumpspecs(find_result_t *output_find,
 369     amglue_dumpspec_list *dumpspecs,
 370     gboolean ok);