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::Tapefile>, and note that this module will be
 139 renamed to L<Amanda::Tapelist> in Amanda-2.6.1).
 140
 141 =item C<search_logfile($label, $datestamp, $logfile, $add_missing_disks)>
 142
 143 Return all results in C<$logfile> matching C<$label> and C<$datestamp>.
 144 If C<$add_missing_disks> is true, then any disks in the logfile
 145 not present in the disklist are added to the disklist; otherwise,
 146 such dumps are skipped.
 147
 148 =item C<dumps_match([@results], $hostname, $diskname, $datestamp, $level, $ok)>
 149
 150 Return a filtered version of C<@results> containing only results that match the
 151 given expressions.  If C<$ok> is true, don't match partial results.  Note that
 152 C<$level> is given as a string, since it is a match expression.
 153
 154 All of these functions can be imported by name.
 155
 156 =back
 157
 158 =cut
 159 %}
 160
 161 amglue_export_ok(
 162     open_logfile get_logline close_logfile
 163 );
 164
 165
 166 amglue_add_enum_tag_fns(logtype_t);
 167 amglue_add_constant(L_BOGUS, logtype_t);
 168 amglue_add_constant(L_FATAL, logtype_t);
 169 amglue_add_constant(L_ERROR, logtype_t);
 170 amglue_add_constant(L_WARNING, logtype_t);
 171 amglue_add_constant(L_INFO, logtype_t);
 172 amglue_add_constant(L_SUMMARY, logtype_t);
 173 amglue_add_constant(L_START, logtype_t);
 174 amglue_add_constant(L_FINISH, logtype_t);
 175 amglue_add_constant(L_DISK, logtype_t);
 176 amglue_add_constant(L_DONE, logtype_t);
 177 amglue_add_constant(L_PART, logtype_t);
 178 amglue_add_constant(L_PARTPARTIAL, logtype_t);
 179 amglue_add_constant(L_SUCCESS, logtype_t);
 180 amglue_add_constant(L_PARTIAL, logtype_t);
 181 amglue_add_constant(L_FAIL, logtype_t);
 182 amglue_add_constant(L_STRANGE, logtype_t);
 183 amglue_add_constant(L_CHUNK, logtype_t);
 184 amglue_add_constant(L_CHUNKSUCCESS, logtype_t);
 185 amglue_add_constant(L_STATS, logtype_t);
 186 amglue_add_constant(L_MARKER, logtype_t);
 187 amglue_add_constant(L_CONT, logtype_t);
 188
 189 amglue_add_enum_tag_fns(program_t);
 190 amglue_add_constant(P_UNKNOWN, program_t);
 191 amglue_add_constant(P_PLANNER, program_t);
 192 amglue_add_constant(P_DRIVER, program_t);
 193 amglue_add_constant(P_REPORTER, program_t);
 194 amglue_add_constant(P_DUMPER, program_t);
 195 amglue_add_constant(P_CHUNKER, program_t);
 196 amglue_add_constant(P_TAPER, program_t);
 197 amglue_add_constant(P_AMFLUSH, program_t);
 198
 199 /* TODO: support for writing logfiles is omitted for the moment. */
 200
 201 %inline %{
 202 /* open_ and close_logfile are both simple wrappers around fopen/fclose. */
 203 typedef FILE loghandle;
 204
 205 loghandle *open_logfile(char *filename) {
 206     return fopen(filename, "r");
 207 }
 208 %}
 209
 210 %inline %{
 211 void close_logfile(loghandle *logfile) {
 212     if (logfile) fclose(logfile);
 213 }
 214 %}
 215
 216 /* We fake the return type of get_logline, and use a typemap to
 217  * slurp curstr, curprog, and curlog into a return value.  */
 218 %{
 219 typedef int LOGLINE_RETURN;
 220 %}
 221 %typemap(out) LOGLINE_RETURN {
 222     if ($1 != 0) {
 223         EXTEND(SP, 3);
 224         $result = sv_2mortal(newSViv(curlog));
 225         argvi++;
 226         $result = sv_2mortal(newSViv(curprog));
 227         argvi++;
 228         $result = sv_2mortal(newSVpv(curstr, 0));
 229         argvi++;
 230     }
 231     /* otherwise (end of logfile) return an empty list */
 232 }
 233 LOGLINE_RETURN get_logline(FILE *logfile);
 234
 235 typedef struct {
 236     %extend {
 237         /* destructor */
 238         ~find_result_t() {
 239             find_result_t *selfp = self;
 240             free_find_result(&selfp);
 241         }
 242     }
 243
 244     %immutable;
 245     char *timestamp;
 246     char *hostname;
 247     char *diskname;
 248     int level;
 249     char *label;
 250     off_t filenum;
 251     char *status;
 252     char *partnum;
 253     %mutable;
 254 } find_result_t;
 255
 256 /* This typemap is used in a few functions.  It converts a linked list of find_result_t's
 257  * into an array of same, de-linking the list in the process.  This gives ownership of the
 258  * objects to perl, which is consistent with the C interface to this module.
 259  */
 260 %typemap(out) find_result_t * {
 261     find_result_t *iter;
 262     int len;
 263
 264     /* measure the list and make room on the perl stack */
 265     for (len=0, iter=$1; iter; iter=iter->next) len++;
 266     EXTEND(SP, len);
 267
 268     iter = $1;
 269     while (iter) {
 270         find_result_t *next;
 271         /* Let SWIG take ownership of the object */
 272         $result = SWIG_NewPointerObj(iter, $descriptor(find_result_t *), SWIG_OWNER | SWIG_SHADOW);
 273         argvi++;
 274
 275         /* null out the 'next' field */
 276         next = iter->next;
 277         iter->next = NULL;
 278         iter = next;
 279     }
 280 }
 281
 282 /* Similarly, on input we link an array full of find_result_t's.  The list is then
 283  * unlinked on return.  Note that the array is supplied as an arrayref (since it's
 284  * usually the first argument).
 285  */
 286 %typemap(in) find_result_t * {
 287     AV *av;
 288     I32 len, i;
 289     find_result_t *head = NULL, *tail = NULL;
 290
 291     if (!SvROK($input) || SvTYPE(SvRV($input)) != SVt_PVAV) {
 292         SWIG_exception(SWIG_TypeError, "expected an arrayref of find_result_t's");
 293     }
 294
 295     av = (AV *)SvRV($input);
 296     len = av_len(av) + 1;
 297
 298     for (i = 0; i < len; i++) {
 299         SV **val = av_fetch(av, i, 0);
 300         find_result_t *r;
 301
 302         if (!val || SWIG_ConvertPtr(*val, (void **)&r, $descriptor(find_result_t *), 0) == -1) {
 303             SWIG_exception(SWIG_TypeError, "array member is not a find_result_t");
 304         }
 305
 306         if (!head) {
 307             head = tail = r;
 308         } else {
 309             tail->next = r;
 310             tail = r;
 311         }
 312
 313         tail->next = NULL;
 314     }
 315
 316     /* point to the head of that list */
 317     $1 = head;
 318 }
 319
 320 %typemap(freearg) find_result_t * {
 321     find_result_t *iter = $1, *next;
 322
 323     /* undo all the links we added earlier */
 324     while (iter) {
 325         next = iter->next;
 326         iter->next = NULL;
 327         iter = next;
 328     }
 329 }
 330
 331 %typemap(out) char ** {
 332     char **iter;
 333     int len, i;
 334
 335     /* measure the length of the array and make sure perl has enough room */
 336     for (len=0, iter=$1; *iter; iter++) len++;
 337     EXTEND(SP, len);
 338
 339     /* now copy it to the perl stack */
 340     for (i=0, iter=$1; *iter; iter++, i++) {
 341         $result = sv_2mortal(newSVpv(*iter, 0));
 342         argvi++;
 343     }
 344 }
 345
 346 amglue_export_ok(
 347     find_log search_logfile dumps_match
 348 );
 349
 350 char **find_log(void);
 351
 352 %rename(search_logfile) search_logfile_wrap;
 353 %inline %{
 354 find_result_t *search_logfile_wrap(char *label, char *datestamp,
 355                                    char *logfile, int add_missing_disks) {
 356     find_result_t *rv = NULL;
 357
 358     /* We use a static variable to collect any unrecognized disks */
 359     static disklist_t unrecognized_disks = { NULL, NULL };
 360
 361     search_logfile(&rv, label, datestamp, logfile,
 362         add_missing_disks? &unrecognized_disks : NULL);
 363
 364     return rv;
 365 }
 366 %}
 367
 368 find_result_t *dumps_match(find_result_t *output_find, char *hostname,
 369                            char *diskname, char *datestamp, char *level, int ok);
 370
 371 find_result_t *dumps_match_dumpspecs(find_result_t *output_find,
 372     amglue_dumpspec_list *dumpspecs,
 373     gboolean ok);