1c217bc3c29cb5952d2c4474a6e4d14fa66849e5
[working/Evergreen.git] / Open-ILS / src / support-scripts / action_trigger_runner.pl.in
1 #!/usr/bin/perl
2 # ---------------------------------------------------------------
3 # Copyright (C) 2009 Equinox Software, Inc
4 # Author: Bill Erickson <erickson@esilibrary.com>
5 #
6 # This program is free software; you can redistribute it and/or
7 # modify it under the terms of the GNU General Public License
8 # as published by the Free Software Foundation; either version 2
9 # of the License, or (at your option) any later version.
10
11 # This program is distributed in the hope that it will be useful,
12 # but WITHOUT ANY WARRANTY; without even the implied warranty of
13 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14 # GNU General Public License for more details.
15 # ---------------------------------------------------------------
16 use strict;
17 use warnings;
18 use Getopt::Long;
19 use OpenSRF::System;
20 use OpenSRF::AppSession;
21 use OpenSRF::Utils::JSON;
22 use OpenSRF::Utils::Logger qw/$logger/;
23 use OpenSRF::EX qw(:try);
24 use OpenILS::Utils::Fieldmapper;
25 my $req_timeout = 10800;
26
27 # DEFAULT values
28
29 my $opt_lockfile      = '/tmp/action-trigger-LOCK';
30 my $opt_osrf_config   = '@sysconfdir@/opensrf_core.xml';
31 my $opt_custom_filter = '@sysconfdir@/action_trigger_filters.json';
32 my $opt_max_sleep     = 3600;  # default to 1 hour
33 my $opt_run_pending   = 0;
34 my $opt_debug_stdout  = 0;
35 my $opt_help          = 0;
36 my $opt_verbose;
37 my $opt_hooks;
38 my $opt_process_hooks = 0;
39 my $opt_granularity   = undef;
40 my $opt_gran_only     = undef;
41
42 (-f $opt_custom_filter) or undef($opt_custom_filter);   # discard default if no file exists
43
44 GetOptions(
45     'max-sleep'        => \$opt_max_sleep,
46     'osrf-config=s'    => \$opt_osrf_config,
47     'run-pending'      => \$opt_run_pending,
48     'hooks=s'          => \$opt_hooks,
49     'granularity=s'    => \$opt_granularity,
50     'granularity-only' => \$opt_gran_only,
51     'process-hooks'    => \$opt_process_hooks,
52     'debug-stdout'     => \$opt_debug_stdout,
53     'custom-filters=s' => \$opt_custom_filter,
54     'lock-file=s'      => \$opt_lockfile,
55     'verbose'          => \$opt_verbose,
56     'help'             => \$opt_help,
57 );
58
59 my $max_sleep = $opt_max_sleep;
60
61 #XXX need to figure out why this is required...
62 $opt_gran_only = $opt_granularity ? 1 : 0;
63
64 $opt_lockfile .= '.' . $opt_granularity if ($opt_granularity && $opt_gran_only);
65
66 # typical passive hook filters
67 my $hook_handlers = {
68
69     # default overdue circulations
70     'checkout.due' => {
71         context_org => 'circ_lib',
72         filter => {
73             checkin_time => undef, 
74             '-or' => [
75                 {stop_fines => ['MAXFINES']}, 
76                 {stop_fines => undef}
77             ]
78         }
79     }
80 };
81
82 if ($opt_custom_filter) {
83     open FILTERS, $opt_custom_filter or die "Cannot read custom filters at $opt_custom_filter";
84     $hook_handlers = OpenSRF::Utils::JSON->JSON2perl(join('',(<FILTERS>)));
85     close FILTERS;
86 }
87
88 sub help {
89     print <<HELP;
90
91 $0 : Create and process action/trigger events
92
93     --osrf-config=<config_file>
94         OpenSRF core config file.  Defaults to:
95             @sysconfdir@/opensrf_core.xml
96
97     --custom-filters=<filter_file>
98         File containing a JSON Object which describes any hooks that should
99         use a user-defined filter to find their target objects.  Defaults to:
100             @sysconfdir@/action_trigger_filters.json
101
102     --run-pending
103         Run pending events to send emails or take other actions as specified
104         by the reactor in the event definition.
105
106     --process-hooks
107         Create hook events
108
109     --max-sleep=<seconds>
110         When in process-hooks mode, wait up to <seconds> for the lock file to
111         go away.  Defaults to 3600 (1 hour).
112
113     --hooks=hook1[,hook2,hook3,...]
114         Define which hooks to create events for.  If none are defined,
115         it defaults to the list of hooks defined in the --custom-filters option.
116         Requires --process-hooks
117
118     --granularity=<label>
119         Limit creating events and running pending events to those only
120         with <label> granularity setting.
121
122     --debug-stdout
123         Print server responses to stdout (as JSON) for debugging
124
125     --lock-file=<file_name>
126         Lock file
127
128     --verbose
129         Show details of script processing.
130
131     --help
132         Show this help
133
134     Examples:
135
136         # To run all pending events that have no granularity set.  This is what 
137         # you tell CRON to run at regular intervals
138         perl $0 --run-pending
139
140         # To batch create all "checkout.due" events
141         perl $0 --hooks=checkout.due --process-hooks
142
143         # To batch create all events for a specific granularity and to send notices for all pending
144         # events with that same granularity.
145         perl $0 --run-pending --granularity=Hourly --process-hooks
146
147 HELP
148 }
149
150
151 # create events for the specified hooks using the configured filters and context orgs
152 sub process_hooks {
153     $opt_verbose and print "process_hooks: " . ($opt_process_hooks ? '(start)' : 'SKIPPING') . "\n";
154     return unless $opt_process_hooks;
155
156     my @hooks = ($opt_hooks) ? split(',', $opt_hooks) : keys(%$hook_handlers);
157     my $ses = OpenSRF::AppSession->create('open-ils.trigger');
158
159     for my $hook (@hooks) {
160         my $config = $$hook_handlers{$hook};
161         $opt_verbose and print "process_hooks: $hook " . ($config ? ($opt_granularity || '') : ' NO HANDLER') . "\n";
162         $config or next;
163
164         my $method = 'open-ils.trigger.passive.event.autocreate.batch';
165         $method =~ s/passive/active/ if $config->{active};
166         
167         my $req = $ses->request($method, $hook, $config->{context_org}, $config->{filter}, $opt_granularity);
168
169         my $debug_hook = "'$hook' and filter ".OpenSRF::Utils::JSON->perl2JSON($config->{filter});
170         $logger->info("at_runner: creating events for $debug_hook");
171
172         my @event_ids;
173         while (my $resp = $req->recv(timeout => $req_timeout)) {
174             push(@event_ids, $resp->content);
175         }
176
177         if(@event_ids) {
178             $logger->info("at_runner: created ".scalar(@event_ids)." events for $debug_hook");
179         } elsif($req->complete) {
180             $logger->info("at_runner: no events to create for $debug_hook");
181         } else {
182             $logger->warn("at_runner: timeout occurred during event creation for $debug_hook");
183         }
184     }
185 }
186
187 sub run_pending {
188     $opt_verbose and print "run_pending: " .
189         ($opt_run_pending ?
190             ($opt_granularity ?
191                 ( $opt_granularity . (
192                     $opt_gran_only ?
193                         ' ONLY' : 
194                         ' and NON-GRANULAR'
195                     )
196                 ) :
197                 'NON-GRANULAR'
198             ) :
199             'SKIPPING'
200         ) . "\n";
201
202     return unless $opt_run_pending;
203     my $ses = OpenSRF::AppSession->create('open-ils.trigger');
204     my $req = $ses->request('open-ils.trigger.event.run_all_pending' => $opt_granularity => $opt_gran_only);
205
206     my $check_lockfile = 1;
207     while (my $resp = $req->recv(timeout => $req_timeout)) {
208         if ($check_lockfile && -e $opt_lockfile) {
209             open LF, $opt_lockfile;
210             my $contents = <LF>;
211             close LF;
212             unlink $opt_lockfile if ($contents == $$);
213             $check_lockfile = 0;
214         }
215         $opt_debug_stdout and print OpenSRF::Utils::JSON->perl2JSON($resp->content) . "\n";
216     }
217 }
218
219 help() and exit if $opt_help;
220 help() and exit unless ($opt_run_pending or $opt_process_hooks);
221
222 # check the lockfile
223 if (-e $opt_lockfile) {
224     die "I'm already running with lockfile $opt_lockfile\n" unless ($opt_process_hooks or $opt_granularity);
225     # sleeping loop if we're in --process-hooks mode
226     while ($max_sleep >= 0 && sleep(1)) {
227         last unless ( -e $opt_lockfile ); 
228         $max_sleep--;
229     }
230 }
231
232 # there's a tiny race condition here ... oh well
233 die "Someone else has been holding the lockfile $opt_lockfile for at least $opt_max_sleep. Giving up now ...\n" if (-e $opt_lockfile);
234
235 # set the lockfile
236 open(F, ">$opt_lockfile") or die "Unable to open lockfile $opt_lockfile for writing\n";
237 print F $$;
238 close F;
239
240 try {
241         OpenSRF::System->bootstrap_client(config_file => $opt_osrf_config);
242         Fieldmapper->import(IDL => OpenSRF::Utils::SettingsClient->new->config_value("IDL"));
243     process_hooks();
244     run_pending();
245 } otherwise {
246     my $e = shift;
247     warn "$e\n";
248 };
249
250 if (-e $opt_lockfile) {
251     open LF, $opt_lockfile;
252     my $contents = <LF>;
253     close LF;
254     unlink $opt_lockfile if ($contents == $$);
255 }