2 * Copyright (c) Zmanda, Inc. All Rights Reserved.
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.
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.
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.
17 * Contact information: Zmanda Inc., 465 S Mathlida Ave, Suite 300
18 * Sunnyvale, CA 94086, USA, or: http://www.zmanda.com
21 %module "Amanda::Logfile"
22 %include "amglue/amglue.swg"
23 %include "exception.i"
24 %include "amglue/dumpspecs.swg"
25 %import "Amanda/Cmdline.swg"
31 #include "diskfile.h" /* for the gross hack, below */
37 Amanda::Logfile - manage Amanda trace logs
41 use Amanda::Logfile qw(:logtype_t);
42 use Amanda::Config qw( :getconf config_dir_relative );
44 for my $logfile (Amanda::Logfile::find_log()) {
45 $logfile = config_dir_relative(getconf($CNF_LOGDIR)) . "/" . $logfile;
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";
54 Amanda::Logfile::close_logfile($log);
56 my @dumps = Amanda::Logfile::search_logfile("TapeLabel-001", "19780615", $logfile, 1);
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";
68 =head1 RAW LOGFILE ACCESS
70 This section corresponds to the C C<logfile> module.
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.
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.
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.
87 =item C<open_logfile($filename)>
89 Opens a logfile for reading, returning an opaque log file handle.
91 =item C<close_logfile($handle)>
93 Closes a log file handle.
95 =item C<get_logline($handle)>
97 Return a list as described above representing the next log line in
98 C<$handle>, or nothing at the end of the logfile.
102 All of these functions can be imported by name if desired.
104 =head1 Amanda::Find::find_result_t objects
106 These objects contain information about dumps, as read from logfiles.
107 Instance variables are:
133 Note that the format for these variables are based on that found in the
134 logfiles. In particular, C<partnum> is a string, usually with a slash (C</>)
135 in it. Also, C<timestamp> is the timestamp for the run in which the client
136 dump took place, and not for the timestamp of the logfile.
138 =head1 HIGHER-LEVEL FUNCTIONS
140 Functions in this section extract information from logfiles.
146 Return a list of logfiles for active tapes. The tapelist must be loaded before
147 this function is called (see L<Amanda::Tapelist>).
149 =item C<search_logfile($label, $datestamp, $logfile, $add_missing_disks)>
151 Return all results in C<$logfile> matching C<$label> and C<$datestamp>.
152 If C<$add_missing_disks> is true, then any disks in the logfile
153 not present in the disklist are added to the disklist; otherwise,
154 such dumps are skipped.
156 =item C<dumps_match([@results], $hostname, $diskname, $datestamp, $level, $ok)>
158 Return a filtered version of C<@results> containing only results that match the
159 given expressions. If C<$ok> is true, don't match partial results. Note that
160 C<$level> is given as a string, since it is a match expression.
162 All of these functions can be imported by name.
170 open_logfile get_logline close_logfile
174 amglue_add_enum_tag_fns(logtype_t);
175 amglue_add_constant(L_BOGUS, logtype_t);
176 amglue_add_constant(L_FATAL, logtype_t);
177 amglue_add_constant(L_ERROR, logtype_t);
178 amglue_add_constant(L_WARNING, logtype_t);
179 amglue_add_constant(L_INFO, logtype_t);
180 amglue_add_constant(L_SUMMARY, logtype_t);
181 amglue_add_constant(L_START, logtype_t);
182 amglue_add_constant(L_FINISH, logtype_t);
183 amglue_add_constant(L_DISK, logtype_t);
184 amglue_add_constant(L_DONE, logtype_t);
185 amglue_add_constant(L_PART, logtype_t);
186 amglue_add_constant(L_PARTPARTIAL, logtype_t);
187 amglue_add_constant(L_SUCCESS, logtype_t);
188 amglue_add_constant(L_PARTIAL, logtype_t);
189 amglue_add_constant(L_FAIL, logtype_t);
190 amglue_add_constant(L_STRANGE, logtype_t);
191 amglue_add_constant(L_CHUNK, logtype_t);
192 amglue_add_constant(L_CHUNKSUCCESS, logtype_t);
193 amglue_add_constant(L_STATS, logtype_t);
194 amglue_add_constant(L_MARKER, logtype_t);
195 amglue_add_constant(L_CONT, logtype_t);
197 amglue_add_enum_tag_fns(program_t);
198 amglue_add_constant(P_UNKNOWN, program_t);
199 amglue_add_constant(P_PLANNER, program_t);
200 amglue_add_constant(P_DRIVER, program_t);
201 amglue_add_constant(P_REPORTER, program_t);
202 amglue_add_constant(P_DUMPER, program_t);
203 amglue_add_constant(P_CHUNKER, program_t);
204 amglue_add_constant(P_TAPER, program_t);
205 amglue_add_constant(P_AMFLUSH, program_t);
207 /* TODO: support for writing logfiles is omitted for the moment. */
210 /* open_ and close_logfile are both simple wrappers around fopen/fclose. */
211 typedef FILE loghandle;
213 loghandle *open_logfile(char *filename) {
214 return fopen(filename, "r");
219 void close_logfile(loghandle *logfile) {
220 if (logfile) fclose(logfile);
224 /* We fake the return type of get_logline, and use a typemap to
225 * slurp curstr, curprog, and curlog into a return value. */
227 typedef int LOGLINE_RETURN;
229 %typemap(out) LOGLINE_RETURN {
232 $result = sv_2mortal(newSViv(curlog));
234 $result = sv_2mortal(newSViv(curprog));
236 $result = sv_2mortal(newSVpv(curstr, 0));
239 /* otherwise (end of logfile) return an empty list */
241 LOGLINE_RETURN get_logline(FILE *logfile);
247 find_result_t *selfp = self;
248 free_find_result(&selfp);
266 /* This typemap is used in a few functions. It converts a linked list of find_result_t's
267 * into an array of same, de-linking the list in the process. This gives ownership of the
268 * objects to perl, which is consistent with the C interface to this module.
270 %typemap(out) find_result_t * {
274 /* measure the list and make room on the perl stack */
275 for (len=0, iter=$1; iter; iter=iter->next) len++;
281 /* Let SWIG take ownership of the object */
282 $result = SWIG_NewPointerObj(iter, $descriptor(find_result_t *), SWIG_OWNER | SWIG_SHADOW);
285 /* null out the 'next' field */
292 /* Similarly, on input we link an array full of find_result_t's. The list is then
293 * unlinked on return. Note that the array is supplied as an arrayref (since it's
294 * usually the first argument).
296 %typemap(in) find_result_t * {
299 find_result_t *head = NULL, *tail = NULL;
301 if (!SvROK($input) || SvTYPE(SvRV($input)) != SVt_PVAV) {
302 SWIG_exception(SWIG_TypeError, "expected an arrayref of find_result_t's");
305 av = (AV *)SvRV($input);
306 len = av_len(av) + 1;
308 for (i = 0; i < len; i++) {
309 SV **val = av_fetch(av, i, 0);
312 if (!val || SWIG_ConvertPtr(*val, (void **)&r, $descriptor(find_result_t *), 0) == -1) {
313 SWIG_exception(SWIG_TypeError, "array member is not a find_result_t");
326 /* point to the head of that list */
330 %typemap(freearg) find_result_t * {
331 find_result_t *iter = $1, *next;
333 /* undo all the links we added earlier */
341 %typemap(out) char ** {
345 /* measure the length of the array and make sure perl has enough room */
346 for (len=0, iter=$1; *iter; iter++) len++;
349 /* now copy it to the perl stack */
350 for (i=0, iter=$1; *iter; iter++, i++) {
351 $result = sv_2mortal(newSVpv(*iter, 0));
357 find_log search_logfile dumps_match
360 char **find_log(void);
362 %rename(search_logfile) search_logfile_wrap;
364 find_result_t *search_logfile_wrap(char *label, char *datestamp,
365 char *logfile, int add_missing_disks) {
366 find_result_t *rv = NULL;
368 /* We use a static variable to collect any unrecognized disks */
369 static disklist_t unrecognized_disks = { NULL, NULL };
371 search_logfile(&rv, label, datestamp, logfile,
372 add_missing_disks? &unrecognized_disks : NULL);
378 find_result_t *dumps_match(find_result_t *output_find, char *hostname,
379 char *diskname, char *datestamp, char *level, int ok);
381 find_result_t *dumps_match_dumpspecs(find_result_t *output_find,
382 amglue_dumpspec_list *dumpspecs,