contrib/continuous/cidaemon - git - Git at Google

 #!/usr/bin/perl
 #
 # A daemon that waits for update events sent by its companion
 # post-receive-cinotify hook, checks out a new copy of source,
 # compiles it, and emails the guilty parties if the compile
 # (and optionally test suite) fails.
 #
 # To use this daemon, configure it and run it.  It will disconnect
 # from your terminal and fork into the background.  The daemon must
 # have local filesystem access to the source repositories, as it
 # uses objects/info/alternates to avoid copying objects.
 #
 # Add its companion post-receive-cinotify hook as the post-receive
 # hook to each repository that the daemon should monitor.  Yes, a
 # single daemon can monitor more than one repository.
 #
 # To use multiple daemons on the same system, give them each a
 # unique queue file and tmpdir.
 #
 # Global Config
 # -------------
 # Reads from a Git style configuration file.  This will be
 # ~/.gitconfig by default but can be overridden by setting
 # the GIT_CONFIG_FILE environment variable before starting.
 #
 # cidaemon.smtpHost
 #   Hostname of the SMTP server the daemon will send email
 #   through.  Defaults to 'localhost'.
 #
 # cidaemon.smtpUser
 #   Username to authenticate to the SMTP server as.  This
 #   variable is optional; if it is not supplied then no
 #   authentication will be performed.
 #
 # cidaemon.smtpPassword
 #   Password to authenticate to the SMTP server as.  This
 #   variable is optional.  If not supplied but smtpUser was,
 #   the daemon prompts for the password before forking into
 #   the background.
 #
 # cidaemon.smtpAuth
 #   Type of authentication to perform with the SMTP server.
 #   If set to 'login' and smtpUser was defined, this will
 #   use the AUTH LOGIN command, which is suitable for use
 #   with at least one version of Microsoft Exchange Server.
 #   If not set the daemon will use whatever auth methods
 #   are supported by your version of Net::SMTP.
 #
 # cidaemon.email
 #   Email address that daemon generated emails will be sent
 #   from.  This should be a useful email address within your
 #   organization.  Required.
 #
 # cidaemon.name
 #   Human friendly name that the daemon will send emails as.
 #   Defaults to 'cidaemon'.
 #
 # cidaemon.scanDelay
 #   Number of seconds to sleep between polls of the queue file.
 #   Defaults to 60.
 #
 # cidaemon.recentCache
 #   Number of recent commit SHA-1s per repository to cache and
 #   skip building if they appear again.  This is useful to avoid
 #   rebuilding the same commit multiple times just because it was
 #   pushed into more than one branch.  Defaults to 100.
 #
 # cidaemon.tmpdir
 #   Scratch directory to create the builds within.  The daemon
 #   makes a new subdirectory for each build, then deletes it when
 #   the build has finished.  The pid file is also placed here.
 #   Defaults to '/tmp'.
 #
 # cidaemon.queue
 #   Path to the queue file that the post-receive-cinotify hook
 #   appends events to.  This file is polled by the daemon.  It
 #   must not be on an NFS mount (uses flock).  Required.
 #
 # cidaemon.nocc
 #   Perl regex patterns to match against author and committer
 #   lines.  If a pattern matches, that author or committer will
 #   not be notified of a build failure.
 #
 # Per Repository Config
 # ----------------------
 # Read from the source repository's config file.
 #
 # builder.command
 #   Shell command to execute the build.  This command must
 #   return 0 on "success" and non-zero on failure.  If you
 #   also want to run a test suite, make sure your command
 #   does that too.  Required.
 #
 # builder.queue
 #   Queue file to notify the cidaemon through.  Should match
 #   cidaemon.queue.  If not set the hook will not notify the
 #   cidaemon.
 #
 # builder.skip
 #   Perl regex patterns of refs that should not be sent to
 #   cidaemon.  Updates of these refs will be ignored.
 #
 # builder.newBranchBase
 #   Glob patterns of refs that should be used to form the
 #   'old' revions of a newly created ref.  This should set
 #   to be globs that match your 'mainline' branches.  This
 #   way a build failure of a brand new topic branch does not
 #   attempt to email everyone since the beginning of time;
 #   instead it only emails those authors of commits not in
 #   these 'mainline' branches.

 local $ENV{PATH} = join ':', qw(
 	/opt/git/bin
 	/usr/bin
 	/bin
 	);

 use strict;
 use warnings;
 use FindBin qw($RealBin);
 use File::Spec;
 use lib File::Spec->catfile($RealBin, '..', 'perl5');
 use Storable qw(retrieve nstore);
 use Fcntl ':flock';
 use POSIX qw(strftime);
 use Getopt::Long qw(:config no_auto_abbrev auto_help);

 sub git_config ($;$)
 {
 	my $var = shift;
 	my $required = shift || 0;
 	local *GIT;
 	open GIT, '-|','git','config','--get',$var;
 	my $r = <GIT>;
 	chop $r if $r;
 	close GIT;
 	die "error: $var not set.\n" if ($required && !$r);
 	return $r;
 }

 package EXCHANGE_NET_SMTP;

 # Microsoft Exchange Server requires an 'AUTH LOGIN'
 # style of authentication.  This is different from
 # the default supported by Net::SMTP so we subclass
 # and override the auth method to support that.

 use Net::SMTP;
 use Net::Cmd;
 use MIME::Base64 qw(encode_base64);
 our @ISA = qw(Net::SMTP);
 our $auth_type = ::git_config 'cidaemon.smtpAuth';

 sub new
 {
 	my $self = shift;
 	my $type = ref($self) || $self;
 	$type->SUPER::new(@_);
 }

 sub auth
 {
 	my $self = shift;
 	return $self->SUPER::auth(@_) unless $auth_type eq 'login';

 	my $user = encode_base64 shift, '';
 	my $pass = encode_base64 shift, '';
 	return 0 unless CMD_MORE == $self->command("AUTH LOGIN")->response;
 	return 0 unless CMD_MORE == $self->command($user)->response;
 	CMD_OK == $self->command($pass)->response;
 }

 package main;

 my ($debug_flag, %recent);

 my $ex_host = git_config('cidaemon.smtpHost') || 'localhost';
 my $ex_user = git_config('cidaemon.smtpUser');
 my $ex_pass = git_config('cidaemon.smtpPassword');

 my $ex_from_addr = git_config('cidaemon.email', 1);
 my $ex_from_name = git_config('cidaemon.name') || 'cidaemon';

 my $scan_delay = git_config('cidaemon.scanDelay') || 60;
 my $recent_size = git_config('cidaemon.recentCache') || 100;
 my $tmpdir = git_config('cidaemon.tmpdir') || '/tmp';
 my $queue_name = git_config('cidaemon.queue', 1);
 my $queue_lock = "$queue_name.lock";

 my @nocc_list;
 open GIT,'git config --get-all cidaemon.nocc|';
 while (<GIT>) {
 	chop;
 	push @nocc_list, $_;
 }
 close GIT;

 sub nocc_author ($)
 {
 	local $_ = shift;
 	foreach my $pat (@nocc_list) {
 		return 1 if /$pat/;
 	}
 	0;
 }

 sub input_echo ($)
 {
 	my $prompt = shift;

 	local $| = 1;
 	print $prompt;
 	my $input = <STDIN>;
 	chop $input;
 	return $input;
 }

 sub input_noecho ($)
 {
 	my $prompt = shift;

 	my $end = sub {system('stty','echo');print "\n";exit};
 	local $SIG{TERM} = $end;
 	local $SIG{INT} = $end;
 	system('stty','-echo');

 	local $| = 1;
 	print $prompt;
 	my $input = <STDIN>;
 	system('stty','echo');
 	print "\n";
 	chop $input;
 	return $input;
 }

 sub rfc2822_date ()
 {
 	 strftime("%a, %d %b %Y %H:%M:%S %Z", localtime);
 }

 sub send_email ($$$)
 {
 	my ($subj, $body, $to) = @_;
 	my $now = rfc2822_date;
 	my $to_str = '';
 	my @rcpt_to;
 	foreach (@$to) {
 		my $s = $_;
 		$s =~ s/^/"/;
 		$s =~ s/(\s+<)/"$1/;
 		$to_str .= ', ' if $to_str;
 		$to_str .= $s;
 		push @rcpt_to, $1 if $s =~ /<(.*)>/;
 	}
 	die "Nobody to send to.\n" unless @rcpt_to;
 	my $msg = <<EOF;
 From: "$ex_from_name" <$ex_from_addr>
 To: $to_str
 Date: $now
 Subject: $subj

 $body
 EOF

 	my $smtp = EXCHANGE_NET_SMTP->new(Host => $ex_host)
 		or die "Cannot connect to $ex_host: $!\n";
 	if ($ex_user && $ex_pass) {
 		$smtp->auth($ex_user,$ex_pass)
 			or die "$ex_host rejected $ex_user\n";
 	}
 	$smtp->mail($ex_from_addr)
 		or die "$ex_host rejected $ex_from_addr\n";
 	scalar($smtp->recipient(@rcpt_to, { SkipBad => 1 }))
 		or die "$ex_host did not accept any addresses.\n";
 	$smtp->data($msg)
 		or die "$ex_host rejected message data\n";
 	$smtp->quit;
 }

 sub pop_queue ()
 {
 	open LOCK, ">$queue_lock" or die "Can't open $queue_lock: $!";
 	flock LOCK, LOCK_EX;

 	my $queue = -f $queue_name ? retrieve $queue_name : [];
 	my $ent = shift @$queue;
 	nstore $queue, $queue_name;

 	flock LOCK, LOCK_UN;
 	close LOCK;
 	$ent;
 }

 sub git_exec (@)
 {
 	system('git',@_) == 0 or die "Cannot git " . join(' ', @_) . "\n";
 }

 sub git_val (@)
 {
 	open(C, '-|','git',@_);
 	my $r = <C>;
 	chop $r if $r;
 	close C;
 	$r;
 }

 sub do_build ($$)
 {
 	my ($git_dir, $new) = @_;

 	my $tmp = File::Spec->catfile($tmpdir, "builder$$");
 	system('rm','-rf',$tmp) == 0 or die "Cannot clear $tmp\n";
 	die "Cannot clear $tmp.\n" if -e $tmp;

 	my $result = 1;
 	eval {
 		my $command;
 		{
 			local $ENV{GIT_DIR} = $git_dir;
 			$command = git_val 'config','builder.command';
 		}
 		die "No builder.command for $git_dir.\n" unless $command;

 		git_exec 'clone','-n','-l','-s',$git_dir,$tmp;
 		chmod 0700, $tmp or die "Cannot lock $tmp\n";
 		chdir $tmp or die "Cannot enter $tmp\n";

 		git_exec 'update-ref','HEAD',$new;
 		git_exec 'read-tree','-m','-u','HEAD','HEAD';
 		system $command;
 		if ($? == -1) {
 			print STDERR "failed to execute '$command': $!\n";
 			$result = 1;
 		} elsif ($? & 127) {
 			my $sig = $? & 127;
 			print STDERR "'$command' died from signal $sig\n";
 			$result = 1;
 		} else {
 			my $r = $? >> 8;
 			print STDERR "'$command' exited with $r\n" if $r;
 			$result = $r;
 		}
 	};
 	if ($@) {
 		$result = 2;
 		print STDERR "$@\n";
 	}

 	chdir '/';
 	system('rm','-rf',$tmp);
 	rmdir $tmp;
 	$result;
 }

 sub build_failed ($$$$$)
 {
 	my ($git_dir, $ref, $old, $new, $msg) = @_;

 	$git_dir =~ m,/([^/]+)$,;
 	my $repo_name = $1;
 	$ref =~ s,^refs/(heads|tags)/,,;

 	my %authors;
 	my $shortlog;
 	my $revstr;
 	{
 		local $ENV{GIT_DIR} = $git_dir;
 		my @revs = ($new);
 		push @revs, '--not', @$old if @$old;
 		open LOG,'-|','git','rev-list','--pretty=raw',@revs;
 		while (<LOG>) {
 			if (s/^(author|committer) //) {
 				chomp;
 				s/>.*$/>/;
 				$authors{$_} = 1 unless nocc_author $_;
 			}
 		}
 		close LOG;
 		open LOG,'-|','git','shortlog',@revs;
 		$shortlog .= $_ while <LOG>;
 		close LOG;
 		$revstr = join(' ', @revs);
 	}

 	my @to = sort keys %authors;
 	unless (@to) {
 		print STDERR "error: No authors in $revstr\n";
 		return;
 	}

 	my $subject = "[$repo_name] $ref : Build Failed";
 	my $body = <<EOF;
 Project: $git_dir
 Branch:  $ref
 Commits: $revstr

 $shortlog
 Build Output:
 --------------------------------------------------------------
 $msg
 EOF
 	send_email($subject, $body, \@to);
 }

 sub run_build ($$$$)
 {
 	my ($git_dir, $ref, $old, $new) = @_;

 	if ($debug_flag) {
 		my @revs = ($new);
 		push @revs, '--not', @$old if @$old;
 		print "BUILDING $git_dir\n";
 		print "  BRANCH: $ref\n";
 		print "  COMMITS: ", join(' ', @revs), "\n";
 	}

 	local(*R, *W);
 	pipe R, W or die "cannot pipe builder: $!";

 	my $builder = fork();
 	if (!defined $builder) {
 		die "cannot fork builder: $!";
 	} elsif (0 == $builder) {
 		close R;
 		close STDIN;open(STDIN, '/dev/null');
 		open(STDOUT, '>&W');
 		open(STDERR, '>&W');
 		exit do_build $git_dir, $new;
 	} else {
 		close W;
 		my $out = '';
 		$out .= $_ while <R>;
 		close R;
 		waitpid $builder, 0;
 		build_failed $git_dir, $ref, $old, $new, $out if $?;
 	}

 	print "DONE\n\n" if $debug_flag;
 }

 sub daemon_loop ()
 {
 	my $run = 1;
 	my $stop_sub = sub {$run = 0};
 	$SIG{HUP} = $stop_sub;
 	$SIG{INT} = $stop_sub;
 	$SIG{TERM} = $stop_sub;

 	mkdir $tmpdir, 0755;
 	my $pidfile = File::Spec->catfile($tmpdir, "cidaemon.pid");
 	open(O, ">$pidfile"); print O "$$\n"; close O;

 	while ($run) {
 		my $ent = pop_queue;
 		if ($ent) {
 			my ($git_dir, $ref, $old, $new) = @$ent;

 			$ent = $recent{$git_dir};
 			$recent{$git_dir} = $ent = [[], {}] unless $ent;
 			my ($rec_arr, $rec_hash) = @$ent;
 			next if $rec_hash->{$new}++;
 			while (@$rec_arr >= $recent_size) {
 				my $to_kill = shift @$rec_arr;
 				delete $rec_hash->{$to_kill};
 			}
 			push @$rec_arr, $new;

 			run_build $git_dir, $ref, $old, $new;
 		} else {
 			sleep $scan_delay;
 		}
 	}

 	unlink $pidfile;
 }

 $debug_flag = 0;
 GetOptions(
 	'debug|d' => \$debug_flag,
 	'smtp-user=s' => \$ex_user,
 ) or die "usage: $0 [--debug] [--smtp-user=user]\n";

 $ex_pass = input_noecho("$ex_user SMTP password: ")
 	if ($ex_user && !$ex_pass);

 if ($debug_flag) {
 	daemon_loop;
 	exit 0;
 }

 my $daemon = fork();
 if (!defined $daemon) {
 	die "cannot fork daemon: $!";
 } elsif (0 == $daemon) {
 	close STDIN;open(STDIN, '/dev/null');
 	close STDOUT;open(STDOUT, '>/dev/null');
 	close STDERR;open(STDERR, '>/dev/null');
 	daemon_loop;
 	exit 0;
 } else {
 	print "Daemon $daemon running in the background.\n";
 }
	#!/usr/bin/perl
	#
	# A daemon that waits for update events sent by its companion
	# post-receive-cinotify hook, checks out a new copy of source,
	# compiles it, and emails the guilty parties if the compile
	# (and optionally test suite) fails.
	#
	# To use this daemon, configure it and run it. It will disconnect
	# from your terminal and fork into the background. The daemon must
	# have local filesystem access to the source repositories, as it
	# uses objects/info/alternates to avoid copying objects.
	#
	# Add its companion post-receive-cinotify hook as the post-receive
	# hook to each repository that the daemon should monitor. Yes, a
	# single daemon can monitor more than one repository.
	#
	# To use multiple daemons on the same system, give them each a
	# unique queue file and tmpdir.
	#
	# Global Config
	# -------------
	# Reads from a Git style configuration file. This will be
	# ~/.gitconfig by default but can be overridden by setting
	# the GIT_CONFIG_FILE environment variable before starting.
	#
	# cidaemon.smtpHost
	# Hostname of the SMTP server the daemon will send email
	# through. Defaults to 'localhost'.
	#
	# cidaemon.smtpUser
	# Username to authenticate to the SMTP server as. This
	# variable is optional; if it is not supplied then no
	# authentication will be performed.
	#
	# cidaemon.smtpPassword
	# Password to authenticate to the SMTP server as. This
	# variable is optional. If not supplied but smtpUser was,
	# the daemon prompts for the password before forking into
	# the background.
	#
	# cidaemon.smtpAuth
	# Type of authentication to perform with the SMTP server.
	# If set to 'login' and smtpUser was defined, this will
	# use the AUTH LOGIN command, which is suitable for use
	# with at least one version of Microsoft Exchange Server.
	# If not set the daemon will use whatever auth methods
	# are supported by your version of Net::SMTP.
	#
	# cidaemon.email
	# Email address that daemon generated emails will be sent
	# from. This should be a useful email address within your
	# organization. Required.
	#
	# cidaemon.name
	# Human friendly name that the daemon will send emails as.
	# Defaults to 'cidaemon'.
	#
	# cidaemon.scanDelay
	# Number of seconds to sleep between polls of the queue file.
	# Defaults to 60.
	#
	# cidaemon.recentCache
	# Number of recent commit SHA-1s per repository to cache and
	# skip building if they appear again. This is useful to avoid
	# rebuilding the same commit multiple times just because it was
	# pushed into more than one branch. Defaults to 100.
	#
	# cidaemon.tmpdir
	# Scratch directory to create the builds within. The daemon
	# makes a new subdirectory for each build, then deletes it when
	# the build has finished. The pid file is also placed here.
	# Defaults to '/tmp'.
	#
	# cidaemon.queue
	# Path to the queue file that the post-receive-cinotify hook
	# appends events to. This file is polled by the daemon. It
	# must not be on an NFS mount (uses flock). Required.
	#
	# cidaemon.nocc
	# Perl regex patterns to match against author and committer
	# lines. If a pattern matches, that author or committer will
	# not be notified of a build failure.
	#
	# Per Repository Config
	# ----------------------
	# Read from the source repository's config file.
	#
	# builder.command
	# Shell command to execute the build. This command must
	# return 0 on "success" and non-zero on failure. If you
	# also want to run a test suite, make sure your command
	# does that too. Required.
	#
	# builder.queue
	# Queue file to notify the cidaemon through. Should match
	# cidaemon.queue. If not set the hook will not notify the
	# cidaemon.
	#
	# builder.skip
	# Perl regex patterns of refs that should not be sent to
	# cidaemon. Updates of these refs will be ignored.
	#
	# builder.newBranchBase
	# Glob patterns of refs that should be used to form the
	# 'old' revions of a newly created ref. This should set
	# to be globs that match your 'mainline' branches. This
	# way a build failure of a brand new topic branch does not
	# attempt to email everyone since the beginning of time;
	# instead it only emails those authors of commits not in
	# these 'mainline' branches.

	local $ENV{PATH} = join ':', qw(
	/opt/git/bin
	/usr/bin
	/bin
	);

	use strict;
	use warnings;
	use FindBin qw($RealBin);
	use File::Spec;
	use lib File::Spec->catfile($RealBin, '..', 'perl5');
	use Storable qw(retrieve nstore);
	use Fcntl ':flock';
	use POSIX qw(strftime);
	use Getopt::Long qw(:config no_auto_abbrev auto_help);

	sub git_config ($;$)
	{
	my $var = shift;
	my $required = shift \|\| 0;
	local *GIT;
	open GIT, '-\|','git','config','--get',$var;
	my $r = <GIT>;
	chop $r if $r;
	close GIT;
	die "error: $var not set.\n" if ($required && !$r);
	return $r;
	}

	package EXCHANGE_NET_SMTP;

	# Microsoft Exchange Server requires an 'AUTH LOGIN'
	# style of authentication. This is different from
	# the default supported by Net::SMTP so we subclass
	# and override the auth method to support that.

	use Net::SMTP;
	use Net::Cmd;
	use MIME::Base64 qw(encode_base64);
	our @ISA = qw(Net::SMTP);
	our $auth_type = ::git_config 'cidaemon.smtpAuth';

	sub new
	{
	my $self = shift;
	my $type = ref($self) \|\| $self;
	$type->SUPER::new(@_);
	}

	sub auth
	{
	my $self = shift;
	return $self->SUPER::auth(@_) unless $auth_type eq 'login';

	my $user = encode_base64 shift, '';
	my $pass = encode_base64 shift, '';
	return 0 unless CMD_MORE == $self->command("AUTH LOGIN")->response;
	return 0 unless CMD_MORE == $self->command($user)->response;
	CMD_OK == $self->command($pass)->response;
	}

	package main;

	my ($debug_flag, %recent);

	my $ex_host = git_config('cidaemon.smtpHost') \|\| 'localhost';
	my $ex_user = git_config('cidaemon.smtpUser');
	my $ex_pass = git_config('cidaemon.smtpPassword');

	my $ex_from_addr = git_config('cidaemon.email', 1);
	my $ex_from_name = git_config('cidaemon.name') \|\| 'cidaemon';

	my $scan_delay = git_config('cidaemon.scanDelay') \|\| 60;
	my $recent_size = git_config('cidaemon.recentCache') \|\| 100;
	my $tmpdir = git_config('cidaemon.tmpdir') \|\| '/tmp';
	my $queue_name = git_config('cidaemon.queue', 1);
	my $queue_lock = "$queue_name.lock";

	my @nocc_list;
	open GIT,'git config --get-all cidaemon.nocc\|';
	while (<GIT>) {
	chop;
	push @nocc_list, $_;
	}
	close GIT;

	sub nocc_author ($)
	{
	local $_ = shift;
	foreach my $pat (@nocc_list) {
	return 1 if /$pat/;
	}
	0;
	}

	sub input_echo ($)
	{
	my $prompt = shift;

	local $\| = 1;
	print $prompt;
	my $input = <STDIN>;
	chop $input;
	return $input;
	}

	sub input_noecho ($)
	{
	my $prompt = shift;

	my $end = sub {system('stty','echo');print "\n";exit};
	local $SIG{TERM} = $end;
	local $SIG{INT} = $end;
	system('stty','-echo');

	local $\| = 1;
	print $prompt;
	my $input = <STDIN>;
	system('stty','echo');
	print "\n";
	chop $input;
	return $input;
	}

	sub rfc2822_date ()
	{
	strftime("%a, %d %b %Y %H:%M:%S %Z", localtime);
	}

	sub send_email ($$$)
	{
	my ($subj, $body, $to) = @_;
	my $now = rfc2822_date;
	my $to_str = '';
	my @rcpt_to;
	foreach (@$to) {
	my $s = $_;
	$s =~ s/^/"/;
	$s =~ s/(\s+<)/"$1/;
	$to_str .= ', ' if $to_str;
	$to_str .= $s;
	push @rcpt_to, $1 if $s =~ /<(.*)>/;
	}
	die "Nobody to send to.\n" unless @rcpt_to;
	my $msg = <<EOF;
	From: "$ex_from_name" <$ex_from_addr>
	To: $to_str
	Date: $now
	Subject: $subj

	$body
	EOF

	my $smtp = EXCHANGE_NET_SMTP->new(Host => $ex_host)
	or die "Cannot connect to $ex_host: $!\n";
	if ($ex_user && $ex_pass) {
	$smtp->auth($ex_user,$ex_pass)
	or die "$ex_host rejected $ex_user\n";
	}
	$smtp->mail($ex_from_addr)
	or die "$ex_host rejected $ex_from_addr\n";
	scalar($smtp->recipient(@rcpt_to, { SkipBad => 1 }))
	or die "$ex_host did not accept any addresses.\n";
	$smtp->data($msg)
	or die "$ex_host rejected message data\n";
	$smtp->quit;
	}

	sub pop_queue ()
	{
	open LOCK, ">$queue_lock" or die "Can't open $queue_lock: $!";
	flock LOCK, LOCK_EX;

	my $queue = -f $queue_name ? retrieve $queue_name : [];
	my $ent = shift @$queue;
	nstore $queue, $queue_name;

	flock LOCK, LOCK_UN;
	close LOCK;
	$ent;
	}

	sub git_exec (@)
	{
	system('git',@_) == 0 or die "Cannot git " . join(' ', @_) . "\n";
	}

	sub git_val (@)
	{
	open(C, '-\|','git',@_);
	my $r = <C>;
	chop $r if $r;
	close C;
	$r;
	}

	sub do_build ($$)
	{
	my ($git_dir, $new) = @_;

	my $tmp = File::Spec->catfile($tmpdir, "builder$$");
	system('rm','-rf',$tmp) == 0 or die "Cannot clear $tmp\n";
	die "Cannot clear $tmp.\n" if -e $tmp;

	my $result = 1;
	eval {
	my $command;
	{
	local $ENV{GIT_DIR} = $git_dir;
	$command = git_val 'config','builder.command';
	}
	die "No builder.command for $git_dir.\n" unless $command;

	git_exec 'clone','-n','-l','-s',$git_dir,$tmp;
	chmod 0700, $tmp or die "Cannot lock $tmp\n";
	chdir $tmp or die "Cannot enter $tmp\n";

	git_exec 'update-ref','HEAD',$new;
	git_exec 'read-tree','-m','-u','HEAD','HEAD';
	system $command;
	if ($? == -1) {
	print STDERR "failed to execute '$command': $!\n";
	$result = 1;
	} elsif ($? & 127) {
	my $sig = $? & 127;
	print STDERR "'$command' died from signal $sig\n";
	$result = 1;
	} else {
	my $r = $? >> 8;
	print STDERR "'$command' exited with $r\n" if $r;
	$result = $r;
	}
	};
	if ($@) {
	$result = 2;
	print STDERR "$@\n";
	}

	chdir '/';
	system('rm','-rf',$tmp);
	rmdir $tmp;
	$result;
	}

	sub build_failed ($$$$$)
	{
	my ($git_dir, $ref, $old, $new, $msg) = @_;

	$git_dir =~ m,/([^/]+)$,;
	my $repo_name = $1;
	$ref =~ s,^refs/(heads\|tags)/,,;

	my %authors;
	my $shortlog;
	my $revstr;
	{
	local $ENV{GIT_DIR} = $git_dir;
	my @revs = ($new);
	push @revs, '--not', @$old if @$old;
	open LOG,'-\|','git','rev-list','--pretty=raw',@revs;
	while (<LOG>) {
	if (s/^(author\|committer) //) {
	chomp;
	s/>.*$/>/;
	$authors{$_} = 1 unless nocc_author $_;
	}
	}
	close LOG;
	open LOG,'-\|','git','shortlog',@revs;
	$shortlog .= $_ while <LOG>;
	close LOG;
	$revstr = join(' ', @revs);
	}

	my @to = sort keys %authors;
	unless (@to) {
	print STDERR "error: No authors in $revstr\n";
	return;
	}

	my $subject = "[$repo_name] $ref : Build Failed";
	my $body = <<EOF;
	Project: $git_dir
	Branch: $ref
	Commits: $revstr

	$shortlog
	Build Output:
	--------------------------------------------------------------
	$msg
	EOF
	send_email($subject, $body, \@to);
	}

	sub run_build ($$$$)
	{
	my ($git_dir, $ref, $old, $new) = @_;

	if ($debug_flag) {
	my @revs = ($new);
	push @revs, '--not', @$old if @$old;
	print "BUILDING $git_dir\n";
	print " BRANCH: $ref\n";
	print " COMMITS: ", join(' ', @revs), "\n";
	}

	local(R, W);
	pipe R, W or die "cannot pipe builder: $!";

	my $builder = fork();
	if (!defined $builder) {
	die "cannot fork builder: $!";
	} elsif (0 == $builder) {
	close R;
	close STDIN;open(STDIN, '/dev/null');
	open(STDOUT, '>&W');
	open(STDERR, '>&W');
	exit do_build $git_dir, $new;
	} else {
	close W;
	my $out = '';
	$out .= $_ while <R>;
	close R;
	waitpid $builder, 0;
	build_failed $git_dir, $ref, $old, $new, $out if $?;
	}

	print "DONE\n\n" if $debug_flag;
	}

	sub daemon_loop ()
	{
	my $run = 1;
	my $stop_sub = sub {$run = 0};
	$SIG{HUP} = $stop_sub;
	$SIG{INT} = $stop_sub;
	$SIG{TERM} = $stop_sub;

	mkdir $tmpdir, 0755;
	my $pidfile = File::Spec->catfile($tmpdir, "cidaemon.pid");
	open(O, ">$pidfile"); print O "$$\n"; close O;

	while ($run) {
	my $ent = pop_queue;
	if ($ent) {
	my ($git_dir, $ref, $old, $new) = @$ent;

	$ent = $recent{$git_dir};
	$recent{$git_dir} = $ent = [[], {}] unless $ent;
	my ($rec_arr, $rec_hash) = @$ent;
	next if $rec_hash->{$new}++;
	while (@$rec_arr >= $recent_size) {
	my $to_kill = shift @$rec_arr;
	delete $rec_hash->{$to_kill};
	}
	push @$rec_arr, $new;

	run_build $git_dir, $ref, $old, $new;
	} else {
	sleep $scan_delay;
	}
	}

	unlink $pidfile;
	}

	$debug_flag = 0;
	GetOptions(
	'debug\|d' => \$debug_flag,
	'smtp-user=s' => \$ex_user,
	) or die "usage: $0 [--debug] [--smtp-user=user]\n";

	$ex_pass = input_noecho("$ex_user SMTP password: ")
	if ($ex_user && !$ex_pass);

	if ($debug_flag) {
	daemon_loop;
	exit 0;
	}

	my $daemon = fork();
	if (!defined $daemon) {
	die "cannot fork daemon: $!";
	} elsif (0 == $daemon) {
	close STDIN;open(STDIN, '/dev/null');
	close STDOUT;open(STDOUT, '>/dev/null');
	close STDERR;open(STDERR, '>/dev/null');
	daemon_loop;
	exit 0;
	} else {
	print "Daemon $daemon running in the background.\n";
	}