blob: 39c9aeed2e766824a900459c4364c6831ba82744 [file] [log] [blame]
#!/usr/bin/perl -T
# This Source Code Form is subject to the terms of the Mozilla Public
# License, v. 2.0. If a copy of the MPL was not distributed with this
# file, You can obtain one at http://mozilla.org/MPL/2.0/.
#
# This Source Code Form is "Incompatible With Secondary Licenses", as
# defined by the Mozilla Public License, v. 2.0.
################################################################################
# Script Initialization
################################################################################
use 5.10.1;
use strict;
use warnings;
use lib qw(. lib);
use Bugzilla;
use Bugzilla::Constants;
use Bugzilla::Search;
use Bugzilla::User;
use Bugzilla::Mailer;
use Bugzilla::Util;
use Bugzilla::Group;
# create some handles that we'll need
my $template = Bugzilla->template;
my $dbh = Bugzilla->dbh;
my $sth;
# @seen_schedules is a list of all of the schedules that have already been
# touched by reset_timer. If reset_timer sees a schedule more than once, it
# sets it to NULL so it won't come up again until the next execution of
# whine.pl
my @seen_schedules = ();
# These statement handles should live outside of their functions in order to
# allow the database to keep their SQL compiled.
my $sth_run_queries =
$dbh->prepare("SELECT " .
"query_name, title, onemailperbug " .
"FROM whine_queries " .
"WHERE eventid=? " .
"ORDER BY sortkey");
my $sth_get_query =
$dbh->prepare("SELECT query FROM namedqueries " .
"WHERE userid = ? AND name = ?");
# get the event that's scheduled with the lowest run_next value
my $sth_next_scheduled_event = $dbh->prepare(
"SELECT " .
" whine_schedules.eventid, " .
" whine_events.owner_userid, " .
" whine_events.subject, " .
" whine_events.body, " .
" whine_events.mailifnobugs " .
"FROM whine_schedules " .
"LEFT JOIN whine_events " .
" ON whine_events.id = whine_schedules.eventid " .
"WHERE run_next <= NOW() " .
"ORDER BY run_next " .
$dbh->sql_limit(1)
);
# get all pending schedules matching an eventid
my $sth_schedules_by_event = $dbh->prepare(
"SELECT id, mailto_type, mailto " .
"FROM whine_schedules " .
"WHERE eventid=? AND run_next <= NOW()"
);
################################################################################
# Main Body Execution
################################################################################
# This script needs to check through the database for schedules that have
# run_next set to NULL, which means that schedule is new or has been altered.
# It then sets it to run immediately if the schedule entry has it running at
# an interval like every hour, otherwise to the appropriate day and time.
# After that, it looks over each user to see if they have schedules that need
# running, then runs those and generates the email messages.
# Send whines from the address in the 'mailfrom' Parameter so that all
# Bugzilla-originated mail appears to come from a single address.
my $fromaddress = Bugzilla->params->{'mailfrom'};
# get the current date and time
my ($now_sec, $now_minute, $now_hour, $now_day, $now_month, $now_year,
$now_weekday) = localtime;
# Convert year to two digits
$now_year = sprintf("%02d", $now_year % 100);
# Convert the month to January being "1" instead of January being "0".
$now_month++;
my @daysinmonth = qw(0 31 28 31 30 31 30 31 31 30 31 30 31);
# Alter February in case of a leap year. This simple way to do it only
# applies if you won't be looking at February of next year, which whining
# doesn't need to do.
if (($now_year % 4 == 0) &&
(($now_year % 100 != 0) || ($now_year % 400 == 0))) {
$daysinmonth[2] = 29;
}
# run_day can contain either a calendar day (1, 2, 3...), a day of the week
# (Mon, Tue, Wed...), a range of days (All, MF), or 'last' for the last day of
# the month.
#
# run_time can contain either an hour (0, 1, 2...) or an interval
# (60min, 30min, 15min).
#
# We go over each uninitialized schedule record and use its settings to
# determine what the next time it runs should be
my $sched_h = $dbh->prepare("SELECT id, run_day, run_time " .
"FROM whine_schedules " .
"WHERE run_next IS NULL" );
$sched_h->execute();
while (my ($schedule_id, $day, $time) = $sched_h->fetchrow_array) {
# fill in some defaults in case they're blank
$day ||= '0';
$time ||= '0';
# If this schedule is supposed to run today, we see if it's supposed to be
# run at a particular hour. If so, we set it for that hour, and if not,
# it runs at an interval over the course of a day, which means we should
# set it to run immediately.
if (&check_today($day)) {
# Values that are not entirely numeric are intervals, like "30min"
if ($time !~ /^\d+$/) {
# set it to now
$sth = $dbh->prepare( "UPDATE whine_schedules " .
"SET run_next=NOW() " .
"WHERE id=?");
$sth->execute($schedule_id);
}
# A time greater than now means it still has to run today
elsif ($time >= $now_hour) {
# set it to today + number of hours
$sth = $dbh->prepare(
"UPDATE whine_schedules " .
"SET run_next = " .
$dbh->sql_date_math('CURRENT_DATE', '+', '?', 'HOUR') .
" WHERE id = ?");
$sth->execute($time, $schedule_id);
}
# the target time is less than the current time
else { # set it for the next applicable day
$day = &get_next_date($day);
my $run_next = $dbh->sql_date_math('('
. $dbh->sql_date_math('CURRENT_DATE', '+', '?', 'DAY')
. ')', '+', '?', 'HOUR');
$sth = $dbh->prepare("UPDATE whine_schedules " .
"SET run_next = $run_next
WHERE id = ?");
$sth->execute($day, $time, $schedule_id);
}
}
# If the schedule is not supposed to run today, we set it to run on the
# appropriate date and time
else {
my $target_date = &get_next_date($day);
# If configured for a particular time, set it to that, otherwise
# midnight
my $target_time = ($time =~ /^\d+$/) ? $time : 0;
my $run_next = $dbh->sql_date_math('('
. $dbh->sql_date_math('CURRENT_DATE', '+', '?', 'DAY')
. ')', '+', '?', 'HOUR');
$sth = $dbh->prepare("UPDATE whine_schedules " .
"SET run_next = $run_next
WHERE id = ?");
$sth->execute($target_date, $target_time, $schedule_id);
}
}
$sched_h->finish();
# get_next_event
#
# This function will:
# 1. Lock whine_schedules
# 2. Grab the most overdue pending schedules on the same event that must run
# 3. Update those schedules' run_next value
# 4. Unlock the table
# 5. Return an event hashref
#
# The event hashref consists of:
# eventid - ID of the event
# author - user object for the event's creator
# users - array of user objects for recipients
# subject - Subject line for the email
# body - the text inserted above the bug lists
# mailifnobugs - send message even if there are no query or query results
sub get_next_event {
my $event = {};
# Loop until there's something to return
until (scalar keys %{$event}) {
$dbh->bz_start_transaction();
# Get the event ID for the first pending schedule
$sth_next_scheduled_event->execute;
my $fetched = $sth_next_scheduled_event->fetch;
$sth_next_scheduled_event->finish;
return undef unless $fetched;
my ($eventid, $owner_id, $subject, $body, $mailifnobugs) = @{$fetched};
my $owner = Bugzilla::User->new($owner_id);
my $whineatothers = $owner->in_group('bz_canusewhineatothers');
my %user_objects; # Used for keeping track of who has been added
# Get all schedules that match that event ID and are pending
$sth_schedules_by_event->execute($eventid);
# Add the users from those schedules to the list
while (my $row = $sth_schedules_by_event->fetch) {
my ($sid, $mailto_type, $mailto) = @{$row};
# Only bother doing any work if this user has whine permission
if ($owner->in_group('bz_canusewhines')) {
if ($mailto_type == MAILTO_USER) {
if (not defined $user_objects{$mailto}) {
if ($mailto == $owner_id) {
$user_objects{$mailto} = $owner;
}
elsif ($whineatothers) {
$user_objects{$mailto} = Bugzilla::User->new($mailto);
}
}
}
elsif ($mailto_type == MAILTO_GROUP) {
my $sth = $dbh->prepare("SELECT name FROM groups " .
"WHERE id=?");
$sth->execute($mailto);
my $groupname = $sth->fetch->[0];
my $group_id = Bugzilla::Group::ValidateGroupName(
$groupname, $owner);
if ($group_id) {
my $glist = join(',',
@{Bugzilla::Group->flatten_group_membership(
$group_id)});
$sth = $dbh->prepare("SELECT user_id FROM " .
"user_group_map " .
"WHERE group_id IN ($glist)");
$sth->execute();
for my $row (@{$sth->fetchall_arrayref}) {
if (not defined $user_objects{$row->[0]}) {
$user_objects{$row->[0]} =
Bugzilla::User->new($row->[0]);
}
}
}
}
}
reset_timer($sid);
}
$dbh->bz_commit_transaction();
# Only set $event if the user is allowed to do whining
if ($owner->in_group('bz_canusewhines')) {
my @users = values %user_objects;
$event = {
'eventid' => $eventid,
'author' => $owner,
'mailto' => \@users,
'subject' => $subject,
'body' => $body,
'mailifnobugs' => $mailifnobugs,
};
}
}
return $event;
}
# Run the queries for each event
#
# $event:
# eventid (the database ID for this event)
# author (user object for who created the event)
# mailto (array of user objects for mail targets)
# subject (subject line for message)
# body (text blurb at top of message)
# mailifnobugs (send message even if there are no query or query results)
while (my $event = get_next_event) {
my $eventid = $event->{'eventid'};
# We loop for each target user because some of the queries will be using
# subjective pronouns
$dbh = Bugzilla->switch_to_shadow_db();
for my $target (@{$event->{'mailto'}}) {
my $args = {
'subject' => $event->{'subject'},
'body' => $event->{'body'},
'eventid' => $event->{'eventid'},
'author' => $event->{'author'},
'recipient' => $target,
'from' => $fromaddress,
};
# run the queries for this schedule
my $queries = run_queries($args);
# If mailifnobugs is false, make sure there is something to output
if (!$event->{'mailifnobugs'}) {
my $there_are_bugs = 0;
for my $query (@{$queries}) {
$there_are_bugs = 1 if scalar @{$query->{'bugs'}};
}
next unless $there_are_bugs;
}
$args->{'queries'} = $queries;
mail($args);
}
$dbh = Bugzilla->switch_to_main_db();
}
################################################################################
# Functions
################################################################################
# The mail and run_queries functions use an anonymous hash ($args) for their
# arguments, which are then passed to the templates.
#
# When run_queries is run, $args contains the following fields:
# - body Message body defined in event
# - from Bugzilla system email address
# - queries array of hashes containing:
# - bugs: array of hashes mapping fieldnames to values for this bug
# - title: text title given to this query in the whine event
# - columnlist: array of fieldnames to display in the mail
# - name: text name of this query
# - schedule_id integer id of the schedule being run
# - subject Subject line for the message
# - recipient user object for the recipient
# - author user object of the person who created the whine event
sub mail {
my $args = shift;
# Don't send mail to someone whose bugmail notification is disabled.
return if $args->{recipient}->email_disabled;
$args->{to_user} = $args->{recipient};
MessageToMTA(generate_email(
$args,
{
header => 'whine/header.txt.tmpl',
text => 'whine/mail.txt.tmpl',
html => 'whine/mail.html.tmpl',
}
));
}
# run_queries runs all of the queries associated with a schedule ID, adding
# the results to $args or mailing off the template if a query wants individual
# messages for each bug
sub run_queries {
my $args = shift;
my $return_queries = [];
$sth_run_queries->execute($args->{'eventid'});
my @queries = ();
for (@{$sth_run_queries->fetchall_arrayref}) {
push(@queries,
{
'name' => $_->[0],
'title' => $_->[1],
'onemailperbug' => $_->[2],
'columnlist' => [],
'bugs' => [],
}
);
}
foreach my $thisquery (@queries) {
next unless $thisquery->{'name'}; # named query is blank
my $savedquery = get_query($thisquery->{'name'}, $args->{'author'});
next unless $savedquery; # silently ignore missing queries
# Execute the saved query
my @searchfields = ('bug_id', DEFAULT_COLUMN_LIST);
# A new Bugzilla::CGI object needs to be created to allow
# Bugzilla::Search to execute a saved query. It's exceedingly weird,
# but that's how it works.
my $searchparams = new Bugzilla::CGI($savedquery);
# Use the columnlist for the saved query, if it exists, and make
# sure bug_id is always in the list.
if (my $columnlist = $searchparams->param('columnlist')) {
@searchfields = split(/[\s,]+/, $columnlist);
unshift(@searchfields, 'bug_id') unless grep { $_ eq 'bug_id' } @searchfields;
}
push @{$thisquery->{'columnlist'}}, @searchfields;
my @orderstrings = split(/,\s*/, $searchparams->param('order') || '');
my $search = new Bugzilla::Search(
'fields' => \@searchfields,
'params' => scalar $searchparams->Vars,
'user' => $args->{'recipient'}, # the search runs as the recipient
'order' => \@orderstrings
);
# If a query fails for whatever reason, it shouldn't kill the script.
my $data = eval { $search->data };
if ($@) {
print STDERR get_text('whine_query_failed', { query_name => $thisquery->{'name'},
author => $args->{'author'},
reason => $@ }) . "\n";
next;
}
foreach my $row (@$data) {
my $bug = {};
for my $field (@searchfields) {
my $fieldname = $field;
$fieldname =~ s/^bugs\.//; # No need for bugs.whatever
$bug->{$fieldname} = shift @$row;
}
if ($thisquery->{'onemailperbug'}) {
$args->{'queries'} = [
{
'name' => $thisquery->{'name'},
'title' => $thisquery->{'title'},
'columnlist' => $thisquery->{'columnlist'},
'bugs' => [ $bug ],
},
];
mail($args);
delete $args->{'queries'};
}
else { # It belongs in one message with any other lists
push @{$thisquery->{'bugs'}}, $bug;
}
}
if (!$thisquery->{'onemailperbug'} && @{$thisquery->{'bugs'}}) {
push @{$return_queries}, $thisquery;
}
}
return $return_queries;
}
# get_query gets the namedquery. It's similar to LookupNamedQuery (in
# buglist.cgi), but doesn't care if a query name really exists or not, since
# individual named queries might go away without the whine_queries that point
# to them being removed.
sub get_query {
my ($name, $user) = @_;
my $qname = $name;
$sth_get_query->execute($user->id, $qname);
my $fetched = $sth_get_query->fetch;
$sth_get_query->finish;
return $fetched ? $fetched->[0] : '';
}
# check_today gets a run day from the schedule and sees if it matches today
# a run day value can contain any of:
# - a three-letter day of the week
# - a number for a day of the month
# - 'last' for the last day of the month
# - 'All' for every day
# - 'MF' for every weekday
sub check_today {
my $run_day = shift;
if (($run_day eq 'MF')
&& ($now_weekday > 0)
&& ($now_weekday < 6)) {
return 1;
}
elsif (
length($run_day) == 3 &&
index("SunMonTueWedThuFriSat", $run_day)/3 == $now_weekday) {
return 1;
}
elsif (($run_day eq 'All')
|| (($run_day eq 'last') &&
($now_day == $daysinmonth[$now_month] ))
|| ($run_day eq $now_day)) {
return 1;
}
return 0;
}
# reset_timer sets the next time a whine is supposed to run, assuming it just
# ran moments ago. Its only parameter is a schedule ID.
#
# reset_timer does not lock the whine_schedules table. Anything that calls it
# should do that itself.
sub reset_timer {
my $schedule_id = shift;
# Schedules may not be executed more than once for each invocation of
# whine.pl -- there are legitimate circumstances that can cause this, like
# a set of whines that take a very long time to execute, so it's done
# quietly.
if (grep($_ == $schedule_id, @seen_schedules)) {
null_schedule($schedule_id);
return;
}
push @seen_schedules, $schedule_id;
$sth = $dbh->prepare( "SELECT run_day, run_time FROM whine_schedules " .
"WHERE id=?" );
$sth->execute($schedule_id);
my ($run_day, $run_time) = $sth->fetchrow_array;
# It may happen that the run_time field is NULL or blank due to
# a bug in editwhines.cgi when this field was initially 0.
$run_time ||= 0;
my $run_today = 0;
my $minute_offset = 0;
# If the schedule is to run today, and it runs many times per day,
# it shall be set to run immediately.
$run_today = &check_today($run_day);
if (($run_today) && ($run_time !~ /^\d+$/)) {
# The default of 60 catches any bad value
my $minute_interval = 60;
if ($run_time =~ /^(\d+)min$/i) {
$minute_interval = $1;
}
# set the minute offset to the next interval point
$minute_offset = $minute_interval - ($now_minute % $minute_interval);
}
elsif (($run_today) && ($run_time > $now_hour)) {
# timed event for later today
# (This should only happen if, for example, an 11pm scheduled event
# didn't happen until after midnight)
$minute_offset = (60 * ($run_time - $now_hour)) - $now_minute;
}
else {
# it's not something that runs later today.
$minute_offset = 0;
# Set the target time if it's a specific hour
my $target_time = ($run_time =~ /^\d+$/) ? $run_time : 0;
my $nextdate = &get_next_date($run_day);
my $run_next = $dbh->sql_date_math('('
. $dbh->sql_date_math('CURRENT_DATE', '+', '?', 'DAY')
. ')', '+', '?', 'HOUR');
$sth = $dbh->prepare("UPDATE whine_schedules " .
"SET run_next = $run_next
WHERE id = ?");
$sth->execute($nextdate, $target_time, $schedule_id);
return;
}
if ($minute_offset > 0) {
# Scheduling is done in terms of whole minutes.
my $next_run = $dbh->selectrow_array(
'SELECT ' . $dbh->sql_date_math('NOW()', '+', '?', 'MINUTE'),
undef, $minute_offset);
$next_run = format_time($next_run, "%Y-%m-%d %R");
$sth = $dbh->prepare("UPDATE whine_schedules " .
"SET run_next = ? WHERE id = ?");
$sth->execute($next_run, $schedule_id);
} else {
# The minute offset is zero or less, which is not supposed to happen.
# complain to STDERR
null_schedule($schedule_id);
print STDERR "Error: bad minute_offset for schedule ID $schedule_id\n";
}
}
# null_schedule is used to safeguard against infinite loops. Schedules with
# run_next set to NULL will not be available to get_next_event until they are
# rescheduled, which only happens when whine.pl starts.
sub null_schedule {
my $schedule_id = shift;
$sth = $dbh->prepare("UPDATE whine_schedules " .
"SET run_next = NULL " .
"WHERE id=?");
$sth->execute($schedule_id);
}
# get_next_date determines the difference in days between now and the next
# time a schedule should run, excluding today
#
# It takes a run_day argument (see check_today, above, for an explanation),
# and returns an integer, representing a number of days.
sub get_next_date {
my $day = shift;
my $add_days = 0;
if ($day eq 'All') {
$add_days = 1;
}
elsif ($day eq 'last') {
# next_date should contain the last day of this month, or next month
# if it's today
if ($daysinmonth[$now_month] == $now_day) {
my $month = $now_month + 1;
$month = 1 if $month > 12;
$add_days = $daysinmonth[$month] + 1;
}
else {
$add_days = $daysinmonth[$now_month] - $now_day;
}
}
elsif ($day eq 'MF') { # any day Monday through Friday
if ($now_weekday < 5) { # Sun-Thurs
$add_days = 1;
}
elsif ($now_weekday == 5) { # Friday
$add_days = 3;
}
else { # it's 6, Saturday
$add_days = 2;
}
}
elsif ($day !~ /^\d+$/) { # A specific day of the week
# The default is used if there is a bad value in the database, in
# which case we mark it to a less-popular day (Sunday)
my $day_num = 0;
if (length($day) == 3) {
$day_num = (index("SunMonTueWedThuFriSat", $day)/3) or 0;
}
$add_days = $day_num - $now_weekday;
if ($add_days <= 0) { # it's next week
$add_days += 7;
}
}
else { # it's a number, so we set it for that calendar day
$add_days = $day - $now_day;
# If it's already beyond that day this month, set it to the next one
if ($add_days <= 0) {
$add_days += $daysinmonth[$now_month];
}
}
return $add_days;
}