Technosorcery Networks

Git + Lighthouse

Jacob — Sun, 18 May 2008 21:43:53 +0000

I’ve been playing around with Git, CIA.vc, and Lighthouse on a project of mine that’s recently been resurrected.

There is a pretty good update hook for CIA.vc integration called ciabot.pl that I’ve been using, without any complaints. Unfortunately, I haven’t been able to find anything to integrate Git with Lighthouse that hasn’t needed modification out of the box. I tried the (pre|post)-receive hooks provided at Obvious Code, but it had a few issues. It would use the author/committer information of the first rev it saw, and use that for every revision it handled. Lighthouse couldn’t understand the “changed-at” time format it was using. The hook also relied on writing out a file with the last rev it saw, so it knew where to pick up, which I didn’t really like.

So, I decided to write my own in Perl. The latest version is available via Git (Git Web).

git clone http://technosorcery.net/git/lighthouseapp-git-hook/

The script can either be called straight from an existing update hook, or can be the update hook. It will split out commits on its own given the old and new SHA1.

Full script (as of this writing) available after the cut.

#!/usr/bin/perl -w
 
use strict;
binmode STDIN, ':utf8';
 
use LWP::UserAgent ();
 
use Date::Format          qw/ time2str /;
use HTTP::Request::Common qw/ POST     /;
use XML::Simple           qw/ XMLout   /;
use YAML                  qw/ Dump     /;
 
#################################################
# Configuration Options                         #
#################################################
my $git = '/home/jhelwig/bin/git';
my %tokens = (
    # Fallback token to use if one isn't found for an author.
    'default' => '',
    # Individual tokens for author/committer.
    # If author email can't be found, committer's email will be tried.
    'jacob@technosorcery.net' => undef,
    'Another Author' => undef,
);
my $lighthouseapp_account_url = 'http://account-name.lighthouseapp.com';
my $lighthouseapp_project_id = 0;
 
#################################################
 
shift @ARGV;
my $old_sha1 = shift @ARGV;
my $new_sha1 = shift @ARGV;
 
my $rev_list = `$git rev-list --pretty=format:"" $old_sha1..$new_sha1`;
$rev_list =~ s/^commit //gm;
 
my @revs = reverse(split("\n", $rev_list));
 
foreach my $rev (@revs) {
    chomp(my $author_name = `$git show --pretty=format:"%an" $rev | sed q`);
    chomp(my $author_email = `$git show --pretty=format:"%ae" $rev | sed q`);
    chomp(my $author_date = `$git show --pretty=format:"%aD" $rev | sed q`);
    chomp(my $committer_name = `$git show --pretty=format:"%cn" $rev | sed q`);
    chomp(my $committer_email = `$git show --pretty=format:"%ce" $rev | sed q`);
    chomp(my $committer_date = `$git show --pretty=format:"%cD" $rev | sed q`);
    chomp(my $changed_at = time2str("%Y-%m-%dT%TZ", `$git show --pretty=format:"%ct" $rev | sed q`, 'GMT'));
    chomp(my $commit_log = `$git log -n1 --pretty=medium $rev | sed '1,4d'`);
 
    my $body = <<"HERE";
$commit_log
 
Author:     $author_name <$author_email>
AuthorDate: $author_date
Commit:     $committer_name <$committer_email>
CommitDate: $committer_date
HERE
 
    chomp(my $commit_subject = `$git show --pretty=format:"%s" $rev | sed q`);
    my $changes_yaml = Dump([
        map { [ split(/\s+/, $_) ] } split("\n", `$git diff-tree -r --name-status $rev | sed '1d'`)
    ]);
 
    my $xml = XMLout({ 'changeset' => {
            'title'      => [ $commit_subject, ],
            'body'       => [ $body, ],
            'revision'   => [ $rev, ],
            'changes'    => {
                'type'    => 'yaml',
                'content' => $changes_yaml,
            },
            'changed-at' => {
                'type'    => 'datetime',
                'content' => $changed_at,
            },
        }},
        KeepRoot => 1,
    );
 
    my $lh_token = defined($tokens{$author_email})
        ? $tokens{$author_email}
        : defined($tokens{$committer_email})
            ? $tokens{$committer_email}
            : $tokens{'default'};
 
    my $ua = LWP::UserAgent->new();
    $ua->timeout(3);
    $ua->env_proxy();
 
    my $response = $ua->simple_request(POST(
        "$lighthouseapp_account_url/projects/$lighthouseapp_project_id/changesets.xml",
        'content-type' => 'application/xml',
        'X-LighthouseToken' => $lh_token,
        Content => $xml
    ));
 
    unless ($response->is_success()) {
        print $response->status_line() . "\n"
            . $response->content() . "\n\n";
 
    }
}

Soft resolution of Request Tracker tickets.

Jacob — Thu, 06 Sep 2007 16:51:36 +0000

We wanted to be able to close a ticket, without actually “closing” it. Thus the “pending” ticket status was born. We can set a ticket’s status as “pending”, and have it automatically

marked as “closed” n days later, if there haven’t been any replies in that time.

I have received permission from my employer to release this under the GNU GPLv2.

Now that the background info is done with, here’s the solution I came up with to be able to have a soft resolution of tickets.

First up: Add the status itself to the list of inactive statuses, since supposedly the ticket is done with, or the requester just doesn’t care enough anymore to be bothered with replying to it.

Put the following in etc/RT_SiteConfig.pm:

@InactiveStatus = qw(resolved rejected pending deleted) unless @InactiveStatus;

You’ll then need to create local/lib/RT/Action/AutoResolve.pm with the following content:

package RT::Action::AutoResolve;
require RT::Action::Generic;
 
use strict;
use vars qw/@ISA/;
@ISA=qw(RT::Action::Generic);
 
sub Describe  {
    my $self = shift;
    return (ref $self );
}
 
sub Prepare {
    my $self = shift;
 
    # if the ticket is already resolved don't re-resolve it.
    if ( ( $self->TicketObj->Status eq 'resolved' ) ) {
        return undef;
    } else {
        return (1);
    }
}
 
sub Commit {
    my $self = shift;
    $self->TicketObj->SetStatus( 'resolved' );
 
    return (1);
}
 
1;

This will be used as the --action argument to rt-crontool.

Create local/lib/RT/Condition/UntouchedInDays.pm for the --condition used with rt-crontool:

package RT::Condition::UntouchedInDays;
require RT::Condition::Generic;
 
use RT::Date;
 
@ISA = qw(RT::Condition::Generic); 
 
use strict;
use vars qw/@ISA/; 
 
sub IsApplicable {
        my $self = shift;
        if ((time()-$self->TicketObj->LastUpdatedObj->Unix)/3600/24 >= $self->Argument) {
                return 1
        }
        else {
                return 0;
        }
}
 
1;

local/lib/RT/Search/PendingTicketsInQueue.pm will be used for the --search.

package RT::Search::PendingTicketsInQueue;
 
use strict;
use base qw(RT::Search::Generic);
 
 
sub Describe  {
  my $self = shift;
  return ($self->loc("No description for [_1]", ref $self));
}
 
sub Prepare  {
  my $self = shift;
 
  $self->TicketsObj->LimitQueue(VALUE => $self->Argument);
 
  $self->TicketsObj->LimitStatus(VALUE => 'pending');
 
  return(1);
}
1;

Now that the pre-requisites are in place, we can create the rt-pending script that should be called daily to resolve tickets that have been set as pending for n days (in this example: n = 7).

#! /bin/sh
 
/opt/rt3/bin/rt-crontool --search RT::Search::PendingTicketsInQueue --search-arg 'Help Desk' --condition RT::Condition::UntouchedInDays --condition-arg 7 --action RT::Action::AutoResolve

That finishes up the portion to mark the tickets as resolved, after the given number of days have passed, with no updates to a ticket. Next up is re-opening the ticket if someone replies to it.

Welcome!

Jacob — Sat, 26 May 2007 22:00:22 +0000

Welcome to Technosorcery Networks. There’s not much up here right now, but I have gotten permission from my current employer to release some of the extensions to Request Tracker that I have written while at work. As I document these extensions at work, I’ll also be putting them up here, for anyone else to add them to his or her RT instance.