GitHub Webhooks: Perl-Utility-Library

GitHub Webhooks: Perl-Utility-Library

Dies ist Folgeartikel 4 aus meiner Serie zu GitHub-Webhooks.

Die Perl-Skripte, die ich in den folgenden Artikeln genauer erläutere, benutzen ein paar übergreifende Funktionen, die ich auf billigste Weise in eine Library ausgelagert habe:

Ich habe einfach die Datei WebHookLib.pm ins gleiche Verzeichnis wie die Skripte geworfen und binde sie dann dort über

  1. #!/usr/bin/perl -I.
  2. use WebHookLib;

ein. Man beachte das -I. um das aktuelle Verzeichnis in den Suchpfad einzufügen. Äußerst schäbig, funktioniert aber.

Ich habe alle Funktionen in der Library mit POD-Dokumentation versehen (was sich auch schon gelohnt hat, weil ich nach sechs Tagen Programmierpause nicht mehr wusste, was ich vorher gebaut habe), aber die lasse ich jetzt der Einfachheit weg. Stattdessen schreibe ich einfach nach jeder Methode ein paar Zeilen. Dafür ist das dann auch – anders als im Produktivcode – deutsche Doku :-)

Falls ihr die Library so direkt verwenden wollt, müsst ihr sie euch hier aus den Code-Bröckchen zusammenkopieren. Ich sollte das echt mal alles in ein git-Repository kippen…

WebHookLib.pm

  1. sub is_debug()
  2. {
  3.     return $ENV{DEBUG} eq '1';
  4. }

Liefert den Debug-Status. Ich habe alle Skripte so gebaut, dass sie keine „Außenwirkung“ entfalten, wenn ich beim Aufruf die Umgebungsvariable DEBUG auf 1 setze. So kann ich in Ruhe Fehler suchen und Testläufe machen und bekomme z.B. Emails nur auf STDOUT angezeigt statt die Mailingliste damit zu fluten.

  1. sub crlf
  2. {
  3.     my ($text) = @_;
  4.     $text =~ s/\r\n/\n/g;
  5.     return $text;
  6. }

Diese Funktion wandelt in einem String CRLF nach LF um und ist schrecklich benamst. GitHub liefert mehrzeilige Texte mit CRLF aus und das macht sich später in den Emails nicht so gut.

  1. sub get_branch
  2. {
  3.     my ($ref) = @_;
  4.     $ref =~ s:^.*/:/:;
  5.     return $ref;
  6. }

Ermittelt den Branch aus einer git-Ref: aus refs/heads/master wird /master.

  1. sub get_short_branch
  2. {
  3.     my ($ref) = @_;
  4.     $branch = get_branch($ref);
  5.     $branch =~ s:^/master$::;
  6.     return $branch;
  7. }

Gibt den Branch einer git-Ref zurück, wenn es nicht der Master-Branch ist. Funktioniert wie get_branch(), aber aus refs/heads/master wird ein Leerstring.

  1. use JSON::MaybeXS;
  2.  
  3. sub read_payload
  4. {
  5.     my $json_file = $ARGV[0];
  6.     die "no input file given" unless defined $json_file and $json_file;
  7.     die "input file `$json_file' does not exist" unless -e $json_file;
  8.     die "input file `$json_file' not readable" unless -r $json_file;
  9.  
  10.     open my $file, '<', $json_file or die "can't open `$json_file': $!";
  11.     local $/;
  12.     my $json = decode_json(<$file>);
  13.     close $file or die "can't close `$jsonfile': $!";
  14.     return $json->{payload};
  15. }

Hierüber wird das JSON eingelesen: Der erste Kommandozeilenparameter ($ARGV[0]) wird als der Datei genommen, welche dann gelesen und als JSON geparst wird. Gibt nur den payload-Teil der Daten zurück, also genau das, was GitHub geschickt hat.

Das use JSON::MaybeXS; steht eigentlich ganz oben in der Perl-Datei, aber wenn ich den Code hier stückchenweise präsentiere, zeige ich es da, wo es benötigt wird. Und eigentlich ist ja auch recht egal, wo man sein use hinschreibt.

  1. sub shorten
  2. {
  3.     my ($text, $max) = @_;
  4.  
  5.     if (length $text <= $max) {
  6.         return $text;
  7.     }
  8.     return substr($text, 0, $max-1) . "…";
  9. }

Verkürzt $text, wenn er länger als $max Zeichen ist. shorten("Hallo", 3) liefert "Ha…" zurück. Ganz wichtig, wenn man twittern will :-)

  1. sub send_mail
  2. {
  3.     my ($to, $subject, $body) = @_;
  4.  
  5.     my $fh;
  6.     if (is_debug) {
  7.         $fh = *STDOUT;
  8.         print $fh "--MAIL START\n";
  9.     }
  10.     else {
  11.         open $fh, '|-', "/usr/sbin/exim -i $to" or die "can't open pipe to exim: $!";
  12.     }
  13.  
  14.     print $fh "From: GitHub Webhooks <absender\@example.org>\n";
  15.     print $fh "Content-Type: text/plain; charset=utf-8\n";
  16.     print $fh "Content-Disposition: inline\n";
  17.     print $fh "Content-Transfer-Encoding: 8bit\n";
  18.     print $fh "To: $to\n";
  19.     print $fh "Subject: $subject";
  20.     print $fh "\n";
  21.     print $fh "$body";
  22.  
  23.     if (is_debug) {
  24.         print $fh "--MAIL END\n";
  25.     }
  26.     else {
  27.         close $fh or die "can't close pipe to exim: $!";
  28.     }
  29. }

Verschickt eine Email. Ich war zu faul, mich in eines der zahlreich vorhandenen Perl-Module einzulesen (z.B. Email::Simple plus Email::Sender) und habe schnell selber was geklimpert.

Funktioniert, fällt aber bestimmt schnell auseinander. Bitte nicht nachmachen!

  1. sub tweet_it
  2. {
  3.     my ($tweet) = @_;
  4.     $tweet = shorten($tweet, 277);
  5.     if (is_debug) {
  6.         print "--TWEET START\n$tweet\n--TWEET END\n";
  7.     }
  8.     else {
  9.         system('git/mtweet/mtweet', "$tweet") == 0 or die "mtweet call failed: $?";
  10.     }
  11. }

Twittert einen Text. Er wird großzügig auf 277 Zeichen gekürzt und danach meinem selbstgebauten Kommandozeilen-Twitterclient mtweet übergeben. mtweet hatte ich fünf Jahre lang nicht angefasst, aber es funktioniert immer noch :-)

  1. 1;

Ganz klar: Jede gute Perl-Datei, die per use eingebunden wird, hört so auf, sonst gibt es einen Fehler beim Laden.

Geschrieben von in Hacken, Internet um 22:22 | Kommentare (2) | Trackback (1)
◀ f r t ▶
Trackbacks
Trackback-URL für diesen Eintrag

Netz - Rettung - Recht am : Wellenreiten 02/2019

Wer als &quot;Websurfer&quot; metaphorisch auf den Wellen des Netzes reitet, findet dabei zwar keine paradiesischen Inseln, manchmal aber immerhin ganz interessante Lektüre. Im Februar 2019 kann ich u.a. folgende Fundstücke empfehlen und der werten Leserschaft ans
Kommentare
Kommentare dieses Artikels abonnieren (als RSS)
Ansicht der Kommentare: (Linear | Verschachtelt)

-thh am um :

> Ich sollte das echt mal alles in ein git-Repository kippen…

Daa wäre jedenfalls sehr löblich!

mitch am um :

Das steht ernsthaft auf dem Plan, aber vorher muss diese Artikelserie fertig werden.
Normalerweise brauche ich für so viele Beiträge im Blog ein ganzes Jahr ;-)
Kommentar schreiben
Um über Antworten auf Deinen Kommentar informiert zu werden, abonniere bitte entweder den Kommentarfeed des ganzen Blogs oder den dieses Eintrages.