Blog

Start 1 2 3 4

Einführung in Test::Class::Moose

15.12.2020 // Gregor Goldbach

Mit Test::Class::Moose können Entwickler die Mittel von Moose nutzen, um ihre Testsuite objektorientiert aufzubauen. In einem vorherigen Artikel habe ich gezeigt, wie diese Tests durch einen Testtreiber ausgeführt werden. In diesem Artikel zeigen ich an einem einfachen Beispiel die grundsätzliche Verwendung von Test::Class::Moose.

Traditionelle Perl-Tests

In Perl schreiben Entwickler seit Jahrzehnten Tests mit den Werkzeugen, die das Modul Test::More und seiner Verwandten zur Verfügung stellen. Hier ein Beispiel aus der Dokumentation dieses Moduls:

ok( $exp{9} == 81,                   'simple exponential' );
ok( Film->can('db_Main'),            'set_db()' );
ok( $p->tests == 4,                  'saw tests' );
ok( !grep(!defined $_, @items),      'all items defined' );

Die Testwerkzeuge wie ok sind einfache Funktionen, die einen erwarteten mit einem tatsächlich berechneten Wert vergleichen. Die mit diesen Werkzeugen erstellten Testsuites bestehen häufig aus prozedural geschriebenen Testskripten, die in einem Verzeichnis namens »t« liegen. Sie werden dann vom Programm prove oder einem geskripteten Testtreiber ausgeführt, der das Modul Test:: Harness verwendet.

Die so aufgebauten Testsuiten werden mit zunehmender Größe unübersichtlich. Zudem ist es nicht immer einfach, gezielt einzelne Funktionalitäten zu testen. Dies liegt zum Teil auch daran, dass Test::More keine Möglichkeit bietet, Tests zu feiner zu gruppieren und dann nur diese auszuführen.

Eine Abhilfe kann hier der objektorientierte Aufbau von Testsuites schaffen. Die Idee ist hierbei, einzelnen Funktionalitäten durch Testklassen auf Fehler überprüfen zu lassen. Hierfür gibt es seit vielen Jahren die Distribution Test::Class.

Um Tests feinkörniger auswählen zu können, als es mit Test::Class möglich ist, hat Curtis Ovid Poe einen ähnlichen Ansatz mit Moose umgesetzt: Test::Class::Moose.

Test::Class + Moose = Test::Class::Moose

Der Ansatz von Test::Class::Moose scheint recht einfach zu sein. Die eigentlichen Tests werden weiterhin mit Test::More geschrieben, Test::Class::Moosebietet nur einen Rahmen, um die Testsuite besser zu strukturieren, indem die Testsuite objektorientiert aufgebaut wird. Der getestete Code muss dafür nicht unbedingt objektorientiert sein.

Damit Test::Class::Moose genutzt werden kann, muss eine Testklasse von Test::Class::Moose abgeleitet werden.

Eine einfache Klasse testen

Eine beispielhafte Testklasse, die Test::Class::Moose und die Methode add der Klasse Calculator testet, sieht so aus:

package TestFor::Calculator;
use Test::Class::Moose;
with 'Test::Class::Moose::Role::AutoUse';

sub test_add {
    my $c = Calculator->new;

    subtest 'identity' => sub {
        my $n        = 42;
        my $expected = $n;
        my $got      = $c->add( $n, 0 );
        is $got, $expected;
    };
}

Die Datei liegt in t/lib/TestFor/Calculator.pm.

In der ersten Zeile folgen wir dem Beispiel aus der Dokumentation von Test::Class::Moose und legen als Namensraum TestFor::Calculator fest. Die zweite Zeile lädt Test::Class::Moose und erledigt damit die Hauptarbeit. Es sorgt nicht nur für die Ableitung der Testklasse, sondern bindet unter anderem auch die Pragmas strict und warnings sowie das Modul Test::Most ein. Es nimmt somit den Entwickler:innen viel Schreibarbeit ab und macht den Quelltext kürzer, übersichtlicher und einheitlicher.

Der eigentliche Test befindet sich in der Methode test_add und arbeitet mit dem Testwerkzeug is, das automatisch bereitgestellt wird. Alle Methoden einer Klasse, die mit test_ beginnen, werden als Testmethoden aufgefasst und in alphabetischer Reihenfolge ausgeführt.

Die dazugehörige Beispielklasse Calculator (lib/Calculator.pm) erhält die Methode add, um zwei Zahlen zu addieren:

package Calculator;

use Moose;
use v5.20;
use feature 'signatures';
no warnings 'experimental::signatures';

sub add ($self, $n, $m) {
  return $n+$m;
}

1;

Wir nutzen nun folgenden in meinem anderen Artikel beschriebenen Testrunner (t/run_test_class.t), um den Test laufen zu lassen:

use Test::Class::Moose::CLI;
Test::Class::Moose::CLI->new_with_options->run;

Der Testlauf sieht dann wie folgt aus:

$ prove -lv t/run_test_class.t
t/run_test_class.t ..
1..1
ok 1 - TestFor::Calculator {
    1..1
    ok 1 - test_add {
        # Subtest: identity
        ok 1 - identity {
            ok 1
            1..1
        }
        1..1
    }
}
ok
All tests successful.
Files=1, Tests=1,  0 wallclock secs ( 0.02 usr  0.01 sys +  0.39 cusr  0.03 csys =  0.45 CPU)
Result: PASS

Tests ergänzen

Wir fügen nun in unsere Testklasse einen Test für eine neue Method sub ein, die zwei Zahlen voneinander abziehen soll:

sub test_sub {
    my $c = Calculator->new;

    subtest 'identity' => sub {
        my $n        = 42;
        my $expected = $n;
        my $got      = $c->sub( $n, 0 );
        is $got, $expected;
    };

    subtest 'negate' => sub {
        my $m        = 42;
        my $expected = -$m;
        my $got      = $c->sub( 0, $m );
        is $got, $expected;
    };
}

Wir implementieren nun die neue Methode ...

sub sub ($self, $n, $m) {
  return $n-$m;
}

... und rufen die Tests für diese Methode auf. Hier nutzen wir eine Eigenschaft vom Testrunner: Anders als bei der alleinigen Verwendung von Test::More können wir auch nur Teile einer Testklasse ausführen.

Es ist hier ein Auswahl von Testmethoden möglich, indem wir den Namen über die Option --methods angeben. Hinweis: Damit die Übergabe funktioniert, muss prove mit einem Doppeldoppelpunkt mitgeteilt werden, dass die folgenden Argument nicht ausgewertet, sondern an das aufgerufene Testprogramm übergeben werden soll:

$ prove -lv t/run_test_class.t :: --methods test_sub
t/run_test_class.t ..
1..1
ok 1 - TestFor::Calculator {
    1..1
    ok 1 - test_sub {
        # Subtest: identity
        ok 1 - identity {
            ok 1
            1..1
        }
        # Subtest: negate
        ok 2 - negate {
            ok 1
            1..1
        }
        1..2
    }
}
ok
All tests successful.
Files=1, Tests=1,  1 wallclock secs ( 0.02 usr  0.00 sys +  0.41 cusr  0.04 csys =  0.47 CPU)
Result: PASS

Da unsere schmalen Testmenge keine Fehler in der neuen Methode gefunden hat, rufen wir nun mutig alle Tests auf:

$ prove -lv t/run_test_class.t
t/run_test_class.t ..
1..1
ok 1 - TestFor::Calculator {
    1..2
    ok 1 - test_add {
        # Subtest: identity
        ok 1 - identity {
            ok 1
            1..1
        }
        1..1
    }
    ok 2 - test_sub {
        # Subtest: identity
        ok 1 - identity {
            ok 1
            1..1
        }
        # Subtest: negate
        ok 2 - negate {
            ok 1
            1..1
        }
        1..2
    }
}
ok
All tests successful.
Files=1, Tests=1,  0 wallclock secs ( 0.02 usr  0.01 sys +  0.40 cusr  0.04 csys =  0.47 CPU)
Result: PASS

Die Einschränkung der auszuführenden Testmenge ist nicht nur auf Methodennamen beschränkt, sondern umfasst auch Testklassen. Mehr dazu kann in meinem Artikel zum Testrunner erfahren werden oder in der Dokumentation von Test::Class::Moose::CLI.

Reihenfolge der Testausführung ändern

Test::Class::Moose führt Tests mit dem vorgestellten Testtreiber stets in der gleichen Reihenfolge aus. Der Treiber lädt zunächst alle Testklassen und führt dann in alphabetischer Reihenfolge der Klassen die Testmethoden ebenfalls in alphabetischer Reihenfolge aus. Damit sind Testläufe reproduzierbar und ihre Ergebnisse vergleichbar.

Um verdeckte Abhängigkeiten von Testmethoden zu finden, können diese auch in zufälliger Reihenfolge ausgeführt werden:

$ prove -lv t/run_test_class.t :: --randomize-methods
t/run_test_class.t ..
1..1
ok 1 - TestFor::Calculator {
    1..2
    ok 1 - test_sub {
        # Subtest: identity
        ok 1 - identity {
            ok 1
            1..1
        }
        # Subtest: negate
        ok 2 - negate {
            ok 1
            1..1
        }
        1..2
    }
    ok 2 - test_add {
        # Subtest: identity
        ok 1 - identity {
            ok 1
            1..1
        }
        1..1
    }
}
ok
All tests successful.
Files=1, Tests=1,  0 wallclock secs ( 0.02 usr  0.01 sys +  0.39 cusr  0.04 csys =  0.46 CPU)
Result: PASS

Auch zu --randomize-methods gibt es ein Gegenstück für Testklassen: --randomize-classes.

Test2 anstelle von Test::More verwenden

Eingangs habe ich erwähnt, dass Test::Class::Moose die Infrastruktur für den Aufbau einer Testsuite zur Verfügung stellt. Die eigentlichen Tests schreiben Entwickler weiterhin mit Test::More.

Seit mehreren Jahren kann Test2 als Ersatz für Test::More produktiv genutzt werden. Um diese Distribution zu nutzen, muss nur wenig geändert werden.

Im Normalfall bindet das Ableiten von Test::Class::Moose auch gleich das Modul Test::Most ein, das wiederum Test::More und verwandte Module einbindet. Um dies zu unterbinden und Test2 zu verwenden, muss folgende Zeile beim Ableiten von Test::Class::Moose verwendet werden:

use Test::Class::Moose bare => 1;

Die verwendeten Testwerkzeuge müssen dann manuell eingebunden werden. In unserem Beispiel brauchen wir Test2::Tools::Compare für die Testwerkzeuge zum Vergleichen und Test2::Tools::Subtests für die Aufteilung in Untertests:

use Test::Class::Moose bare => 1;
use Test2::Tools::Compare;
use Test2::Tools::Subtest qw(subtest_buffered);

Die Anleitung von Test::Class::Moose zeigt in einem Beispiel, wie man eine eigene Basisklasse für Testklassen definieren kann, um sich diese Schreibarbeit zu ersparen.

Untertests funktionieren in Test2 etwas anders, da zwei Werkzeuge bereitgestellt werden. Warum ist das so?

Test::More gibt Entwickler:innen subtest an die Hand. Diese Funktion gibt Text sofort auf der Konsole aus, sobald er von aufgerufenen Code erzeugt wird. Dieses Verhalten bietet Test2 mit dem Werkzeug subtest_streamed. Bei nebenläufig ausgeführtem Code kann dies zu unübersichtlicher Ausgabe führen. Daher bietet Test2 auch die Funktion subtest_buffered an, die die Ausgabe puffert und in der korrekten Reihenfolge ausgibt.

Wir müssen also unsere beispielhafte Testklasse etwas umschreiben:

package TestFor::Calculator;

use Test::Class::Moose bare => 1;
use Test2::Tools::Compare;
use Test2::Tools::Subtest qw(subtest_buffered);

with 'Test::Class::Moose::Role::AutoUse';

sub test_add {
    my $c = Calculator->new;

    subtest_buffered 'identity' => sub {
        my $n        = 42;
        my $expected = $n;
        my $got      = $c->add( $n, 0 );
        is $got, $expected;
    };
}

sub test_sub {
    my $c = Calculator->new;

    subtest_buffered 'identity' => sub {
        my $n        = 42;
        my $expected = $n;
        my $got      = $c->sub( $n, 0 );
        is $got, $expected;
    };

    subtest_buffered 'negate' => sub {
        my $m        = 42;
        my $expected = -$m;
        my $got      = $c->sub( 0, $m );
        is $got, $expected;
    };
}

Wenn wir die Tests wie bisher mit prove aufrufen, werden wir keine Änderung feststellen. Die Ausgabe ist die gleiche, allerdings laufen die Tests nun unter Test2.

Um eine deutliche Änderung zu sehen, können wir die Tests mit yath, dem Gegenstück von prove unter Test2, aufrufen:

$ yath -lv t/run_test_class.t

** Defaulting to the 'test' command **

( LAUNCH )  job  1    t/run_test_class.t
[  PLAN  ]  job  1    Expected assertions: 1
[  PASS  ]  job  1  +~TestFor::Calculator
[  PLAN  ]  job  1    | Expected assertions: 2
[  PASS  ]  job  1    +~test_add
[  PASS  ]  job  1    | +~identity
[  PASS  ]  job  1    | | + <UNNAMED ASSERTION>
[  PLAN  ]  job  1    | | | Expected assertions: 1
            job  1    | | ^
[  PLAN  ]  job  1    | | Expected assertions: 1
            job  1    | ^
[  PASS  ]  job  1    +~test_sub
[  PASS  ]  job  1    | +~identity
[  PASS  ]  job  1    | | + <UNNAMED ASSERTION>
[  PLAN  ]  job  1    | | | Expected assertions: 1
            job  1    | | ^
[  PASS  ]  job  1    | +~negate
[  PASS  ]  job  1    | | + <UNNAMED ASSERTION>
[  PLAN  ]  job  1    | | | Expected assertions: 1
            job  1    | | ^
[  PLAN  ]  job  1    | | Expected assertions: 2
            job  1    | ^
            job  1    ^
( PASSED )  job  1    t/run_test_class.t
(  TIME  )  job  1    Startup: 0.41443s | Events: 0.01167s | Cleanup: 0.01234s | Total: 0.43844s

                                Yath Result Summary
-----------------------------------------------------------------------------------
     File Count: 1
Assertion Count: 9
      Wall Time: 0.65 seconds
       CPU Time: 0.83 seconds (usr: 0.12s | sys: 0.02s | cusr: 0.60s | csys: 0.09s)
      CPU Usage: 127%
    -->  Result: PASSED  <--

Durch wenige Anpassungen in den Tests kann so die moderne Testinfrastruktur von Perl genutzt werden.

Zusammenfassung

Mit der Distribution Test::Class::Moose können Entwickler:innen ihre Testsuite übersichtlich strukturieren. Entwickler:innen können diesen Rahmen nutzen, um mit den Testwerkzeugen aus Test::More und dem neueren Test2 ihre Tests feinkörnig auszuführen.

In diesem Artikel konnte ich nur einen kurzen Überblick geben. Mehr zur Motivation und den Möglichkeiten von Test::Class::Moose hat Dave Rolsky 2016 in einem Vortrag gezeigt.

Weiterlesen


Permalink:

Arbeiten mit Nuclino Teil 3

11.12.2020 // Renée Bäcker

In den vergangenen beiden Artikeln über unser Nuclino-Backup habe ich erst vorgestellt, wie wir die Backups erstellen und anschließend wie wir das Programm schneller gemacht haben.

Jetzt wo wir das Backup haben, kommen natürlich noch weitere Ideen. Wie können wir die Daten nutzen, so dass wir Nuclino als eine große Datenquelle nutzen und dann alle möglichen Produkte daraus ziehen: Dokumentation für Kunden, Schulungsunterlagen als PDF, Konzepte für Projekte, Blogposts etc.

Die Texte in Nuclino sind alle mit Markdown verfasst. Die Blogposts sind seit jeher als Markdown gespeichert und PDFs kann man bequem mit pandoc aus Markdown-Dateien generieren.

Was wir als erstes brauchen ist ein Mapping, damit wir bei den Brains – Sammlungen von Dokumenten in einem Workspace – anstelle der UUIDs mit konkreten Namen arbeiten können.

Außerdem benötigen wir ein Mapping der UUIDs zu Dateinamen und Titeln. Mit Hilfe dieses Mappings Übersetzen wir die Links mit der Nuclino-Domain in Links mit einer beliebigen neuen Domain setzen die Titel der Dateien als Überschrift in die Dokumente ein.

Wir wollen also so etwas:

{
  "brains" : {
    "0184e034-3156-11eb-bf6d-2bbce7395d9b":"Kunden",
    "0f0b2e2a-3156-11eb-a397-97d9e025800c":"FeatureAddons",
    "14c45b66-3156-11eb-bf04-835bcdf7bdc7":"PerlAcademy",
    ...
  },
  "documents" : {
    "19c8e5e6-3156-11eb-ba6d-8beba50b7276": {
      "file":"index.html",
      "title":"index.html"
    },
    "27fc869a-3156-11eb-98f5-8f9deed3e298": {
      "file":"GraphQL vs. REST 0051eb4b.md",
      "title":"GraphQL vs. REST"
    },
    ...
  }
}

Wer sich mit Nuclino auseinandersetzt, wird schnell feststellen, dass da nur ganz wenige normale HTTP-Anfragen abgesetzt werden. Der Informationsaustausch zwischen Browser und Server erfolgt über Websockets.

Also ist wieder eine Analyse der Kommunikation notwendig. Da helfen wieder die Entwicklertools des Browsers mit der Netzwerkanalyse. Auch wenn man in Nuclino arbeitet, kommen keine weiteren Requests in der Übersicht hinzu.

Dann kommt man schnell zu dem einen Websocket...

b0b6b008-d207-4ff0-88be-dfe2c4f18518.png

Diese Kommunikation muss mit Mojolicious nachgebaut werden. Das schöne an Mojolicious ist, dass es schon alles mitbringt – so auch die Unterstützung für Websockets.

my $ua = Mojo::UserAgent->new(
    cookie_jar         => Mojo::UserAgent::CookieJar->new,
    max_connections    => 200,
    inactivity_timeout => 20,
    request_timeout    => 20,
);

my ($info, @brains) = _get_brains( $ua );
my @promises        = _create_mapping( $ua, $info, \@brains, $home_dir );

Mit der Funktion _get_brains werden die Zip-Dateien der Brains geholt und in $info stehen der Benutzername und weitere Infos. Auch bei _create_mapping arbeiten wir wieder mit Promises. Ein Promise repräsentiert das Ergebnis einer asynchronen Operation. Je nachdem, ob die Operation erfolgreich oder fehlerhaft beendet wurde, wird das Promise entsprechend gekennzeichnet.

In _create_mapping bauen wir die Websocket-Verbindung mit Nuclino auf.

sub _create_mapping {
    my ( $ua, $info, $brains, $home_dir ) = @_;

    my $mapping = {};

    my $promise = Mojo::Promise->new;

    $ua->websocket(
        'wss://api.nuclino.com/syncing' => {
            Via => '1.1 vegur',
            Origin => 'https://app.nuclino.com',
        } => ['v1.proto'] => sub {
        
        # ... hier der Code fuer den Informationsaustausch
    });
}

Ist die Verbindung aufgebaut, müssen wir festlegen, was mit eingehenden Nachrichten passieren soll. Und wenn die Verbindung geschlossen wird, müssen die zusammengetragenen Informationen als JSON-Datei gespeichert wird.

Betrachten wir also nur die Subroutine, die bei websocket als Callback übergeben wird:

            my ($ua, $tx) = @_;

            return if !$tx->isa('Mojo::Transaction::WebSocket');

            $tx->on( message => sub {
                my ($tx, $msg) = @_;
                _handle_message( $tx, $msg, $mapping );
            });

            $tx->on( finish => sub {
                my ($tx) = @_;

                # generate JSON file for mapping
                $home_dir->child('backups', 'mapping.json')->spurt(
                    encode_json $mapping
                );

                $promise->resolve(1);
            });

Trifft eine Nachricht vom Server ein, wird ein message-Event gefeuert. Wir reagieren mit $tx->on( message => sub {...} ); darauf. Was in der Funktion _handle_message passiert, schauen wir uns später an.

Mit $tx->on( finish => sub {...} ); reagieren wir auf das Ende der Verbindung. Da wird einfach nur die JSON-Datei geschrieben und mit $promise->resolve(1) wird gesagt, dass das Promise erfolgreich abgearbeitet wurde.

Im weiteren Verlauf des Callbacks setzen wir die Eingangs-Requests ab, die weiter oben beschrieben sind:

            $tx->send( encode_json +{
                ns => 'sd',
                data => {
                    a => 's',
                    c => 'ot_config',
                    d => 'a16b46be-31a7-11eb-ad70-e338b15b7ae1',
                }
            });
            
            # hier noch die Requests fuer die Kommandos
            # ot_user, ot_user_private, ot_team

            Mojo::IOLoop->timer( 3 => sub {
                for my $brain ( @{$brains} ) {
                    $tx->send( encode_json +{
                        ns => 'sd',
                        data => {
                            a => 's',
                            c => 'ot_brain',
                            d => $brain,
                        }
                    });
                }
            });

Die UUID im ersten Request ist immer die gleiche. Das ist vermutlich die UUID unseres Unternehmensaccounts.

Danach folgen noch drei weitere Requests. Diese können direkt nacheinander abgesetzt werden.

Abschließend folgt noch für jeden brain ein Request. Hier hat es in den Tests nie geklappt, die direkt nach den zuvor genannten Requests abzusetzen. Die genannten vier Requests müssen erst abgearbeitet sein, bevor es weiter geht.

Mit den hier gezeigten Requests werden die Infos zu einem brain geholt. Die Daten kommen als JSON an und sehen folgendermaßen aus:

{
  "ns":"sd",
  "data":{
    "data":{
      "v":2,
      "data":{
        "kind":"PUBLIC",
        "name":"Werkzeuge",
        "teamId":"1f2966e2-321d-11eb-8f00-5b043dffbd53",
        "members":[],
        "createdAt":"2019-07-17T15:40:28.897Z",
        "creatorId":"2a9e9ad8-321d-11eb-a81f-631faf46d6c4",
        "mainCellId":"320c3df2-321d-11eb-9604-fbfbed008d34",
        "defaultView":"TREE",
        "trashCellId":"377bf386-321d-11eb-b969-3fea1f109107",
        "archiveCellId":"3de4e624-321d-11eb-a864-67366681e78f",
        "formerMembers":[],
        "pinnedCellIds":[],
        "defaultMemberRole":"MEMBER"
      },
      "type":"https://nuclino.com/ot-types/json01"
    },
    "a":"s",
    "c":"ot_brain",
    "d":"7091aff1-1513-4e68-ae9f-d6f8936fcf14"
  }
}

Die Funktion _handle_message nimmt die Antworten des Servers auseinander und sammelt die Daten für das Mapping. Die Antworten des Servers für ot_brain enthalten Angaben über die Zellen – also die Seiten des Brains. Für jede dieser Seiten werden wieder Requests abgesetzt.

sub _handle_message {
    my ($tx, $msg, $mapping) = @_;

    my $data;
    eval {
        $data = decode_json( encode_utf8 $msg );
    };

    return if !$data;

    my $command = $data->{data}->{c} || '';

    return if !( first { $command eq $_ }qw(ot_cell ot_brain) );
    
    # ziehe die Informationen aus den JSON-Antworten
    
    for my $cell ( @cell_ids ) {
        $tx->send( encode_json +{
            ns => 'sd',
            data => {
                a => 's',
                c => 'ot_cell',
                d => $cell,
            }
        });
    }

}

Die Ergebnisse der weiter oben gezeigten Kommandos wie ot_user,* ot_user_private*, *ot_config und ot_team* interessieren uns nicht, da dort keine Informationen über die Dateien zu finden sind. Aus diesem Grund werden die hier nicht behandelt.

In den Antworten für das ot_brain stehen dann Informationen, mit denen wir weiterarbeiten können. In mainCellId steht die UUID des Hauptdokuments. Für dieses Dokument holen wir mit ot_cell die näheren Informationen*.*

{
  "ns":"sd",
  "data":{
    "data":{
      "v":18,
      "data":{
        "kind":"MAIN",
        "title":"Main",
        "brainId":"a29de3ff-18a5-4d51-ab9b-a6c3b5d82b6c",
        "sharing":{},
        "childIds":[
          "bb10e948-ba91-4097-83a1-60c9ea6ec17b",
          "4d44737d-e113-4786-bb98-06d8755d2bb7",
          "..."
        ],
        "createdAt":"2019-07-17T14:47:35.743Z",
        "creatorId":"34e53829-cafb-4859-9e7b-0aae34295d04",
        "memberIds":[],
        "updatedAt":"2019-07-17T14:47:35.743Z",
        "activities":[],
        "contentMeta":{},
      },
      "type":"https://nuclino.com/ot-types/json01"
    },
    "a":"s",
    "c":"ot_cell",
    "d":"d56942a8-aa6e-4197-93fd-1f88967dedc6"
  }
} 

Die wichtigen Informationen sind der Typ des Dokuments – MAIN ist das Startdokument eines brains, PARENT ein Knoten und LEAF ein Dokument mit Text –, der Titel und die Kinddokumente, für die dann ebenfalls die Informationen geholt werden.

Was haben wir gelernt? Wir haben die Websocket-Kommunikation zwischen Nuclino und dem Browser analysiert, und wir haben gesehen, dass Mojolicious bei der Umsetzung extrem hilfreich ist, weil die Unterstützung für Websockets direkt mit eingebaut ist.


Permalink:

Perl-Schulungen 2021

07.12.2020 // Renée Bäcker

Nachdem wir uns das Jahr 2020 Zeit genommen haben, um die Perl-Academy etwas umzubauen (mit neuem Design, der Einführung dieses Blogs, mit Gregor als zusätzlicher Trainer, ...), wollen wir heute unseren Plan für 2021 vorstellen.

Wir werden wenige feste Termine für offene Schulungen haben. Wir wollen mehr Firmenschulungen anbieten und offene Schulungen zusätzlich planen, wenn sich Interessenten melden.

Unsere Schulungsthemen werden wir am Lebenszyklus einer Anwendung ausrichten. Auch in agilen Umgebungen hat man immer wieder den Lebenszyklus in klein. Momentan haben wir vier Themen geplant:

Einsteigen werden wir mit User Story Mapping. Kein originäres Perl-Thema, aber eine ganz praktische Vorgehensweise, um eine Anwendung aus Sicht des Benutzers zu planen.

Die mit User Story Mapping geplante Software werden wir mit Mojolicious umsetzen. Dabei werden wir mit einer kleinen Version anfangen um die Grundlagen von Mojolicious kennenzulernen. Anschließend werden wir die Anwendung wachsen lassen, um die weitergehenden Fähigkeiten von Mojolicious nutzen zu können.

Natürlich muss man nicht erst die User-Story-Mapping Schulung besucht haben, um an der Mojolicious-Schulung teilzunehmen.

Das Thema Sicherheit in Perl-Anwendungen spielt natürlich auch bei Mojolicious-Anwendungen ein Thema. Wir haben eine eigene Schulung daraus gemacht, um dem Ganzen genügend Raum zu geben und uns nicht auf Mojolicious zu beschränken.

Als viertes Thema bieten wir Gitlab und Perl an. Die Versionsverwaltung begleitet die Anwendung ein Leben lang. Wir zeigen, was man abseits der reinen Versionsverwaltung mit Gitlab machen kann – von Continuous Integration bis zum Ausliefern der Anwendung.

Interesse an einer der Schulungen? Dann melden Sie sich bei uns!


Permalink:

Gitlab umziehen

04.12.2020 // Renée Bäcker

In verschiedenen Projekten setzen wir ein jeweils selbst gehostetes Gitlab ein. Gitlab bietet viel mehr als nur die Versionskontrolle. Gregor hat vor einiger Zeit schon einmal etwas dazu geschrieben, wie wir bei Perl-Services.de Gitlab benutzen.

Bei einem Projekt stand der Umzug in die Cloud zu AWS an und damit auch das Gitlab, das in dem Projekt genutzt wurde. Für das Projekt gibt es aber nicht alle Möglichkeiten der AWS-Cloud, so dass das Gitlab nicht in gewohnter Umgebung (ein Ubuntu-Linux) fortgeführt werden konnte, sondern auf ein RHEL8-System wechseln musste.

Voraussetzungen

Bevor der Umzug losgeht, muss eine Serverinstanz mit RHEL8 erstellt werden. Nach der Erstellung per SSH mit der Maschine verbinden.

Da RHEL8 kein Docker mehr unterstützt, kommt Podman zum Einsatz. Podman ist eine Container-Engine ähnlich zu Docker. Es können die Befehle von Docker genutzt werden, da Podman einen docker-Alias anlegt. Man bekommt Podman auch, wenn man

yum install docker

nutzt.

Gitlab-Image herunterladen

Wenn man von einem anderen Server migriert, muss man dort erst einmal schauen, welche Version zum Einsatz kommt. Die gleiche Version muss dann auch (erst einmal) auf dem neuen Server laufen. Wenn es neuere Versionen von Gitlab gibt, sollte nach dem Umzug dann noch das Update gemacht werden.

Die entsprechend getaggten Gitlab-Images sind unter https://hub.docker.com/r/gitlab/gitlab-ce/tags zu finden.

Auf dem neuen Server führt man einfach

docker pull gitlab/gitlab-ce:<version>-ce.0 aus.

Verzeichnisse erstellen

Damit die Daten auch persistent auf der EC2-Instanz bleiben, werden beim Starten des Containers Verzeichnisse der Instanz in den Container gemappt. Die müssen vor dem Start des Containers existieren:

$ mkdir -p /srv/gitlab/config
$ mkdir -p /srv/gitlab/data/backups
$ mkdir -p /srv/gitlab/logs

Als systemd-Service einrichten

Um anschließend Gitlab als Service starten und stoppen zu können, muss es entsprechend eingerichtet sein. Dazu in der Datei /etc/sysconfig/gitlab folgendes eintragen:

IMAGE=docker.io/gitlab/gitlab-ce:<version>-ce.0
HOSTNAME=git.domain.tld
NAME=gitlab-ce

Damit sind dann Umgebungsvariablen gesetzt, die in der Service-Datei genutzt werden. Die ist unter /etc/systemd/system/gitlab.service zu finden. In dieser Service-Datei ist beschrieben, wie der Gitlab-Service aussieht:

[Unit]
Description=GitLab Podman container
After=network.target

[Service]
Type=simple
TimeoutStartSec=5m
Restart=always
RestartSec=30s
EnvironmentFile=/etc/sysconfig/gitlab
ExecStartPre=-/usr/bin/podman rm ${NAME}
ExecStart=/usr/bin/podman run \
    --name ${NAME} \
    --hostname ${HOSTNAME} \
    --publish 443:443 \
    --publish 80:80 \
    --publish 8014:22 \
    --volume /srv/gitlab/config:/etc/gitlab:Z \
    --volume /srv/gitlab/logs:/var/log/gitlab:Z \
    --volume /srv/gitlab/data:/var/opt/gitlab:Z \
    ${IMAGE} 
ExecReload=-/usr/bin/podman stop ${NAME} 
ExecReload=-/usr/bin/podman rm ${NAME} 
ExecStop=-/usr/bin/podman stop ${NAME}

[Install]
WantedBy=multi-user.target

Ich gehe hier nicht auf alle Einzelheiten ein. Nur so viel: Wo die Umgebungsvariablen zu finden sind, wird in EnvironmentFile definiert. Dort wir die Datei eingetragen, die im Schritt vorher definiert wurde. Bei den Befehlen zum Starten, Neustarten und Stoppen des Dienstes taucht hier podman auf. Wer Docker einsetzt, muss bei diesen Befehlen dann das podman durch docker ersetzen.

Die Port-Weiterleitungen können auch abweichen. In dem Projekt wurde der Port 22 von Gitlab über den Port 8014 des Servers bekanntgemacht, damit der Server selbst per SSH über den Port 22 ansprechbar bleibt.

Abschließend muss der Service noch aktiviert werden:

systemctl enable gitlab.service

machen, damit das Gitlab bei jedem Systemstart ebenfalls gestartet wird

Backup einspielen

Bevor man das Backup einspielen kann, muss es erstellt werden. Dazu auf der alten Instanz folgendes machen:

$ docker exec -it gitlab /bin/bash/
gitlab-rake gitlab:backup:create

Das erstellt eine .tar-Datei in */srv/gitlab/data/backups *. Diese muss an die gleiche Stelle auf dem neuen Server geschoben werden. Der Dateiname ist nach diesem Muster aufgebaut: <Timestamp>*<YYYY>*<mm>*<dd>*<version>.tar.

In dem Backup sind nicht die Dateien /srv/gitlab/config/gitlab.rb und /srv/gitlab/config/gitlab-secrets.json enthalten. Diese müssen separat auf den neuen Server kopiert werden.

Anschließend müssen auf dem neuen Server ein paar Services von Gitlab gestoppt werden:

$ docker exec -it gitlab /bin/bash
/ gitlab-ctl reconfigure
/ gitlab-ctl start
/ gitlab-ctl stop unicorn
/ gitlab-ctl stop sidekiq

Sind die Services gestoppt, kann das Backup eingespielt werden:

/ gitlab-rake gitlab:backup:restore --trace

Abschließend gitlab neu starten:

/ gitlab-ctl restart


Permalink:

Perl::Critic-Regeln umsetzen

01.12.2020 // Renée Bäcker

Gregor hat vor längerer Zeit das Modul Test::Perl::Critic::Progressive und ich vor kurzem das Modul PPI vorgestellt. In diesem Blogpost zeige ich, wie man mit PPI Perl::Critic-Regeln umsetzen kann, die dann in den Tests verwendet werden.

Nachdem ich eine Anwendung programmiert hatte, hat Gregor den Code angeschaut. Dabei ist er über dieses Stück Code gestolpert und meinte, es sähe schräg aus:

my ($doc) = grep{
    $_->{virtual_path} eq $virt_path
}@{ $app_config->{docs} || [] };

Für mich ist das völlig normal, ich nutze das häufiger. Aber ich gebe zu, dass man das schöner schreiben könnte.

Da man in diesem Beispiel nur an dem ersten Treffer interessiert ist, könnte man statt des grep die Funktion first aus dem Modul List::Util nutzen. Damit würde es dann schon so aussehen:

my $doc = first {
    $_->{virtual_path} eq $virt_path
}@{ $app_config->{docs} || [] };

Natürlich muss man am Anfang noch das Modul laden. Der Unterschied ist nur klein, aber für Einsteiger vielleicht doch einfacher, weil man hier nicht auf den Kontext achten muss. Beim grep gibt es unterschiedliche Ergebnisse, je nachdem ob man das Ergebnis in Skalar- oder im Listenkontext nutzt – einfach mal dieses Skript bei perlbanjo.com ausführen...

Das nächste was man schöner schreiben könnte, ist die Dereferenzierung der Arrayreferenz:

@{ $app_config->{docs} || [] }

Seit der Version 5.20 gibt es das (bis 5.24 experimentelle) Feature postderef . Da sieht die Schreibweise dann etwas schöner aus:

$app_config->{docs}->@*

Auch hier muss man am Anfang des Codes noch etwas einfügen, aber der Lesefluss ist in meinen Augen deutlich besser. Zum Schluss noch ein Leerzeichen zwischen das schließende } des greps und der Dereferenzierung. Insgesamt wäre es dann

my $doc = first {
    $_->{virtual_path} eq $virt_path
} $app_config->{docs}->@*;

Nachdem wir geklärt haben, welchen Code wir beanstanden wollen, und wie er schlussendlich aussehen soll, können wir uns an die Umsetzung der Regeln machen.

In meinen Augen liefert PPI::Dumper einen sehr guten Einstiegspunkt. Einfach den unerwünschten Code in allen möglichen Fassungen in den __DATA__-Bereich des Skriptes packen und ausführen. Damit sieht man, welche PPI-Knoten es gibt und an welchen man ansetzen muss. Der Dump des Perl Document Object Model (POM) in unserem Beispiel sieht auszugsweise folgendermaßen aus:

PPI::Document
  PPI::Token::Whitespace    '\n'
  PPI::Statement::Variable
    PPI::Token::Word    'my'
    PPI::Token::Whitespace      ' '
    PPI::Token::Symbol      '@list'
    PPI::Token::Whitespace      '   '
    PPI::Token::Operator    '='
    PPI::Token::Whitespace      ' '
    PPI::Token::Word    'grep'
    PPI::Token::Whitespace      ' '
    PPI::Structure::Block   { ... }

Bei jeder Perl::Critic-Regel muss man angeben, auf welchen Knoten die Regel angewandt werden soll. In diesem Fall ist das immer ein Knoten vom Typ PPI::Token::Word.

Gehen wir einen Teil nach dem anderen durch. Zuerst wollen wir first statt grep nutzen, wenn auf der linken Seite nur eine einelementige Liste angegeben ist.

Die passenden Beispiele dazu sind:

my @list   = grep { ausdruck() } @liste;           # grep ok
my $list   = grep { ausdruck() } @liste;           # grep ok
my ($list) = grep { ausdruck() } @liste;           # grep not ok
my ($list, $second) = grep { ausdruck() } @liste;  # grep ok
if( grep{ ausdruck() }@liste ) {                   # grep ok
}
# ggf. noch weitere Beispiele

Wenn wir uns den Dump anschauen, merken wir folgendes:

  • Wenn ein PPI::Token::Word mit dem Wert grep als Elternelement ein PPI::Statement::Variable hat, dann ist das potentiell interessant
  • Vergleiche Varianten der Variablenliste:

    PPI::Token::Whitespace      '\n'
    PPI::Statement::Variable
      PPI::Token::Word      'my'
      PPI::Token::Whitespace    ' '
      PPI::Structure::List      ( ... )
        PPI::Statement::Expression
          PPI::Token::Symbol    '$list'
    
    # vs
    
    PPI::Statement::Variable
      PPI::Token::Word      'my'
      PPI::Token::Whitespace    ' '
      PPI::Structure::List      ( ... )
        PPI::Statement::Expression
          PPI::Token::Symbol    '$list'
          PPI::Token::Operator      ','
          PPI::Token::Whitespace    ' '
          PPI::Token::Symbol    '$second'
    

    Es muss also eine Liste mit genau einem PPI::Token::Symbol sein, dessen Sigil ein $ ist.

Schauen wir uns das Grundgerüst für eine Perl::Critic-Regel an:

package Perl::Critic::Policy::PerlAcademy::ProhibitGrepToGetFirstFoundElement;

# ABSTRACT: Use List::Utils 'first' instead of grep if you want to get the first found element

use 5.006001;
use strict;
use warnings;
use Readonly;

use Perl::Critic::Utils qw{ :severities };

use base 'Perl::Critic::Policy';

our $VERSION = '2.02';

#-----------------------------------------------------------------------------

Readonly::Scalar my $DESC => q{Use List::Utils 'first' instead of grep if you want to get the first found element};
Readonly::Scalar my $EXPL => [  ]; 

#-----------------------------------------------------------------------------

sub default_severity     { return $SEVERITY_MEDIUM           }
sub default_themes       { return qw<perl_academy> }
sub applies_to           {
    return qw<
        PPI::Token::Word
    >;
}

Das kann so 1:1 kopiert werden. Der Paketnamen muss angepasst werden sowie die Beschreibungen.

Bei der default_severity muss man sich überlegen, wie wichtig einem diese Regel ist. Regeln können in sogenannte Themes eingeteilt werden.

Mit applies_to legt man eine Liste von Klassennamen fest, auf deren Objekte die Regel angewandt wird. Wir haben oben festgestellt, dass wir auf PPI::Token::Word-Objekte reagieren müssen.

Ob die Regel eingehalten wird, wird dann in der Methode violates geprüft. Ist alles ok, wird undef zurückgegeben, ansonsten ein Objekt, das die Regelmissachtung beschreibt:

sub violates {
    my ( $self, $elem, $doc ) = @_;

    # ... code zur pruefung der regel ...

    return $self->violation( $DESC, $EXPL, $elem );
}

Neben dem Objekt der Regel selbst bekommt man das Element (hier ein Objekt von PPI::Token::Word) und das PPI::Document-Objekt übergeben.

Als erstes prüfen wir, ob es ein grep-Befehl ist:

    # other statements than grep aren't catched
    return if $elem->content ne 'grep';

Dann interessieren wir uns nur für das grep, wenn das Ergebnis nicht in einer Variablen gespeichert wird. Dazu müssen wir in der Hierarchie des POM eine Stufe nach oben gehen:

    my $parent = $elem->parent;

    # grep in boolean or void context isn't checked
    return if !$parent->isa('PPI::Statement::Variable');

Und bei den Variablen muss eine Liste gegeben sein

    my $list = first{ $_->isa('PPI::Structure::List') } $parent->schildren;
    return if !$list;

Die Liste darf nur ein Element haben und das muss ein Scalar sein.

    my $symbols = $list->find('PPI::Token::Symbol');

    return if !$symbols;
    return if 1 != @{ $symbols };

    return if '$' ne substr $symbols->[0], 0, 1;

Sollte das alles zutreffen, ist das ein Regelverstoß:

    return $self->violation( $DESC, $EXPL, $elem );

Diese gesamte Regel ist mittlerweile auch auf CPAN bei meinen Regeln – und zwar als Perl::Critic::Policy::Reneeb::ProhibitGrepToGetFirstFoundElement – zu finden.

Die beiden anderen Punkte zum schöneren Code umzusetzen bleibt dem geneigten Leser überlassen.


Permalink:

Wie setzen wir die Gitlab-CI ein?

26.11.2020 // Gregor Goldbach

In meinem Artikel über die Optimierung von Docker-Images habe ich erwähnt, dass wir die »Gitlab-CI« einsetzen. In diesem Artikel beschreibe ich nun näher, was das eigentlich ist und welche Erfahrungen wir gemacht haben.

Was bedeutet CI?

Mit »CI« wird in der Software-Entwicklung »continuous integration« bezeichnet, also die fortlaufende Integration von Software-Komponenten. Dies ist ein Vorgehen im Team und weniger ein Werkzeug, bei dem Änderungen an der gemeinsamen Code-Basis fortlaufend an einer definierten Stelle zusammengeführt und auf ihre Qualität hin untersucht werden.

Diese Untersuchung besteht in der Regel aus einer Reihe von automatisierten Tests, die Abweichungen von gewünschten Eigenschaften aufzeigen sollen. Hierzu kann auch das Einhalten von Codier-Richtlinien zählen.

Durch die häufige Integration und einem hohen Grad an Automatisierung möchte das Team sicherstellen, dass Fehler und Abweichungen schneller gefunden und behoben werden können.

Die fortlaufende Integration ist also ein Baustein, um qualitätssichernde Maßnahmen im Softwareentwicklungsprozess umzusetzen.

Gitlabs CI-Umsetzung

Das Produkt Gitlab unterstützt fortlaufende Integration durch eine textuelle Beschreibung von »Pipelines«, in denen konfigurierbare Befehle ausgeführt werden.

Nach einem Push von Änderungen in einem Repository wird ein Docker-Container gestartet, in dem dann die beschriebenen Befehle ausgeführt werden.

Das folgende Beispiel zeigt eine hypothetische Distribution Foo::Bar::Baz, die mit Dist::Zilla in Ubuntu gebaut und getestet wird.

image: ubuntu

stages:
  - build

build:
  stage: build
  script:
    - dzil build
    - dzil cover
    - dzil test
  coverage: '/^Total.+\s+(\d+.\d)$/'
  artifacts:
    when: always
    name: "${CI_BUILD_STAGE}_${CI_BUILD_REF_NAME}"
    paths:
      - foo-bar-baz-*.tar.gz

Diese Befehle werden typischerweise das Compilieren und Linken von Software sein, an die sich Testautomatisierung und weitere Prüfungen anschließen.

Wenn alle Befehle erfolgreich ausgeführt wurden, ist der Build erfolgreich. Erfolg oder Misserfolg eines Builds werden dem Entwickler, dessen Änderungen die Pipeline ausgelöst haben, per E-Mail mitgeteilt. Der Zustand eines Builds ist zusätzlich im Gitlab-Projekt sichtbar.

Welche Arten von Pipelines es gibt und wie dies in Gitlabs Oberfläche dargestellt wird, ist in Gitlabs Dokumentation nachzulesen.

Wie nutzen wir die Gitlab-CI?

Eine Pipeline wird wie oben beschrieben nach einem Push der Änderungen gestartet. Bei der Konfiguration dieser Pipelines legen wir auf zwei Aspekte großen Wert: Geschwindigkeit und Reproduzierbarkeit des Builds.

Geschwindigkeit ist für uns wichtig, da wir binnen weniger Minuten Rückmeldung über die Qualität der Änderungen erhalten wollen. Wenn hier etwas bricht, wollen wir den Fehler sofort korrigieren, da diese Behebungen meist einfacher sind als bei großen Änderungen.

Geschwindigkeit erreichen wir durch konfektionierte Docker-Images. Außerdem stimmen wir die Reihenfolge der Tests aufeinander ab und verfolgen beim Schreiben der Tests einen »fail fast«-Ansatz. Wenn ein Build fehlschlägt, bekommen wir so früh Rückmeldung.

Die Reproduzierbarkeit eines Builds ist für uns wichtig, damit wir Builds nachvollziehen können, indem wir die Docker-Images auf beliebigen Systemen bauen. In der Vergangenheit hatte uns Gitlab öfter Fehler in Builds gemeldet, die wir dann lokal auf unseren Entwicklungsrechnern nicht nachvollziehen konnten. Grund hierfür war die Installation von Abhängigkeiten und dadurch entstandene Versionsunterschiede.

Die Reproduzierbarkeit erhalten wir, indem wir so gut es geht die Versionen der Abhängigkeiten angeben und während des Builds keine Komponenten nachinstallieren. Da Installationen entfallen, erhöht sich als Nebenwirkung auch die Build-Geschwindigkeit.

Dist::Zilla

Für uns hat sich Dist::Zilla als sehr hilfreich erwiesen. Einerseits ermöglichen uns die Kommandos dieses Werkzeugs, die Konfiguration einer Pipeline übersichtlich zu halten. Andererseits bietet die Funktionalität von dzil vieles, was wir sinnvoll einsetzen können.

Kommandos, die wir nutzen, sind zum Beispiel »test« für das Ausführen der Tests, »build« zum Erstellen der Distribution und »cover« zum Messen der Testabdeckung.

Wir setzen Dist::Zilla ein, um am Ende eines Builds die Distribution als Artefakt »an den Build zu hängen«. Das von dzil erstellte Archiv wird einem Build zugeordnet; wir können es dann im Browser, in anderen Projekten oder über die API übertragen.

Auch bei der Versionsverwaltung ist Dist::Zilla nützlich: Sein git-Bundle hilft dabei, Branches nach dem Veröffentlichen einer Distribution zu taggen. Somit ist automatisiert und nachvollziehbar im Git-Repository eine Versionshistorie abrufbar.

Zusammenfassung

Das Produkt Gitlab hilft einem Team beim fortlaufenden Integrieren von Software-Komponenten. Entwickler können »Pipelines« über Textdateien beschreiben, in denen Befehle nach Änderungen einer gemeinsamen Code-Basis ausgeführt werden. Wir können damit schnelle Rückmeldungen über Code-Änderungen und reproduzierbare Builds erhalten. Dist::Zilla hilft uns, einen Build übersichtlich zu beschreiben und effizient durchzuführen.

Weiterlesen


Permalink:

Testtreiber für Test::Class::Moose

23.11.2020 // Gregor Goldbach

Test::Class::Moose hilft beim Organisieren von Tests dadurch, dass objektorientiertes Schreiben von Tests ermöglicht wird.

Mit der Klasse Test::Class::Moose::Runner können diese Tests parametrisiert ausgeführt werden.

Die Klasse Test::Class::Moose::CLI unterstützt beim Schreiben eines Testtreibers, um Tests komfortabel auf der Kommandozeile auszuführen.

Organisation von Testsuites

Test::Class::Moose bietet objektorientierte Hilfsmittel, um eine Testsuite zu organisieren.

Tests können über Klassen und Methoden verteilt und mit Tags versehen ein, um sie etwa als langsam oder für bestimmte Funktionalitäten auszuzeichnen. Ein Beispiel:

package TestFor::My::Test::Module;
use Test::Class::Moose;

use My::Module;
 
sub test_construction {
    my $test = shift;
    my $obj  = My::Module->new;
    isa_ok $obj, 'My::Module';
}

sub test_database : Tags( database )            { ... }
sub test_network  : Tests(7) Tags( online api ) { ... }

Der Aufruf dieser Tests erfordert das Laden der Testklassen und den Aufruf der Methoden, die die eigentlichen Tests enthalten.

In der Praxis wird die vollständige Testsuite auf CI-Systemen ausgeführt. Bei der Fehlersuche führen Entwickler:innen in der Regel jedoch nur jene Tests aus, die für die fehlerhafte Komponente relevant sind.

Um diese Testauswahl effizient zu ermöglichen und bei der Fehlersuche flexibel auswählen zu können, ist ein Kommandozeilenwerkzeug hilfreich: der Testtreiber.

Genau diesen liefert Test::Class::Moose::CLI.

Der Testtreiber

Der Testtreiber selbst ist ein Testprogramm wie jedes andere, das mit prove aufgerufen werden kann. Er umfasst in der Minimalfassung nur zwei Zeilen:

use Test::Class::Moose::CLI;

Test::Class::Moose::CLI->new_with_options->run;

Wenn diese in der Datei t/tcm.t abgelegt werden, dann kann er mit prove aufgerufen werden:

> prove -lv t/tcm.t

Es werden dann alle Testklassen geladen, die sich in oder unterhalb des Verzeichnisses t/lib befinden. In alphabetischer Reihenfolge der Paketnamen werden dann die Testmethoden ebenfalls ist alphabetischer Reihenfolge ausgeführt.

Eine lebendige Testsuite hat üblicherweise eine Größe, die eine Ausführung aller Tests bei der Fehlersuche unpraktisch erscheinen lässt. Entwickler:innen sind bei der Fehlersuche typischerweise vor allem daran interessiert, eine bestimmte Menge von Tests schnell auszuführen.

Die Menge der ausgeführten Tests kann mit diesem einfachen Testtreiber über einige Parameter mitgeteilt werden. Sollen nur die Tests einer bestimmten Testklasse aufgerufen werden, so kann diese über das Argument --classes angegeben werden:

> prove -lv t/tcm.t :: --classes Foo

Diese Einschränkung funktioniert auch für Methoden:

> prove -lv t/tcm.t :: --methods Bar

Es gibt auch einen Parameter für die Einschränkung nach den eingangs erwähnten Tags:

> prove -lv t/tcm.t :: --tags Baz

Damit würden alle Methoden in allen Testklassen ausgeführt, die mit dem Tag Baz versehen sind.

Die erwähnten Optionen können mehrfach angegeben und mit einem vorangestellten exclude- negiert werden:

> prove -lv t/tcm.t :: --classes Foo --classes Foo2 --exclude-classes NoFoo \
  --tags fast --exclude-tags db

Neben der Menge der ausgeführten Tests kann auch die Reihenfolge ihrer Ausführung geändert werden. Die Vorgabe der Ausführung nach alphabetischer Sortierung kann durch eine zufällige Reihenfolge ersetzt werden. Sinnvoll kann dies sein, um eine Stichprobe zu ziehen, ob die Testmethoden isoliert voneinander arbeiten – wenn hier ein Test fehlschlägt, dann wird ein vermeintlicher lokaler Zustand aus einer Testmethode in einer anderen Testmethode verwendet.

Im folgenden Beispiel werden alle Testmethoden aller Testklassen in jeweils in zufälliger Reihenfolge ausgeführt:

> prove -lv t/tcm.t :: –randomize–classes –randomize-methods

Beide Optionen sind auch einzeln verwendbar.

Die hier vorgestellten Optionen sind nur ein Teil der vorhandenen, die der Dokumentation von Test::Class::Moose::CLI beschrieben sind.

Zusammenfassung

Gerade während der Fehlersuche ist ein komfortabler Aufruf von Tests hilfreich, um schnell Rückmeldung von den Tests zu erhalten.

Für die auf Test::Class::Moose basierenden Tests bietet das vorgestellte Modul eine Grundlage für einen eigenen Testtreiber.

Bereits über den vorgestellten minimalen Treiber erhalten Entwickler:innen eine flexible Möglichkeit, die Menge und Reihenfolge der auszuführenden Tests zu beeinflussen.


Permalink:

Perl-Schulungen vor dem Deutschen Perl-/Raku-Workshop 2021 in Leipzig

10.11.2020 // Renée Bäcker

Auch während der aktuell hohen Infektionszahlen in der Corona-Pandemie schauen wir nach vorne. Nach aktuellem Stand findet der Deutsche Perl-/Raku-Workshop 2021 Ende März in Leipzig statt (sollte die Corona-Situation das nicht hergeben, wird da mit Sicherheit reagiert).

Wir wollen den Workshop zum Anlass nehmen, am Tag vorher (23. März 2021) zwei Halbtagesschulungen anzubieten:

Den Tag beginnen wird Gregor mit Gitlab und Perl. In dem Kurs, der von 08:00 Uhr bis 12:00 Uhr stattfinden wird, geht es um die Entwicklung von Perl-Distributionen mit Hilfe der Plattform Gitlab. Gregor wird anhand einer CPAN-Distribution kurz die hierfür relevanten integrierten Komponenten der Plattform vorstellen und insbesondere auf die continuous integration eingehen. Ein Schwerpunkt liegt hier auf der schnellen Rückmeldung an Entwickler nach einem Commit.

Am Nachmittag (13:30 Uhr bis 17:30 Uhr) geht es dann um REST-APIs mit Mojolicious. Ich werde hierbei kurz auf REST an sich eingehen, bevor eine Schnittstelle definiert und dann als Mojolicious-Anwendung mit Leben gefüllt wird. Dabei werden dann auch Themen wie Sicherheit etc. angesprochen. Zum Abschluss wird die Schnittstelle noch getestet.

Als Veranstaltungsort ist das Hotel Michaelis geplant und die Teilnehmerzahl ist auf 10 Personen pro Schulung beschränkt.

Wer Interesse an einer der Schulungen hat, kann sich gerne bei uns melden. Die Teilnahme an einer Schulung kostet 200,00 € netto (238,00 € inkl. MwSt), ein Kombiticket für beide Schulungen kostet 350,00 € netto (416,50 € inkl. MwSt).

Wir werden natürlich die Entwicklungen bzgl. Corona weiter im Auge behalten. Sollte eine Präsenzveranstaltung nicht möglich sein, werden wir die Schulungen als Online-Veranstaltung anbieten.


Permalink:

Modul des Monats: PPI

21.10.2020 // Renée Bäcker

Only perl can parse Perl

Dieses Zitat von Tom Christiansen gilt in Teilen immer noch. Perl (die Sprache) ist eigentlich alles das, was perl (der Interpreter) sauber ausführen kann. Dass das nicht nur der Code mit der Syntax ist, die man so hinlänglich sieht, kann man an etlichen Acme::-Modulen sehen. So kann man wirklich sauberen Code mit Acme::Bleach schreiben. Das Modul wandelt normalen Perl-Code in Whitespaces um – und das Programm läuft immer noch. Ein weiteres Beispiel: Zu meinen Ausbildungszeiten in der Bioinformatik habe ich (nicht produktiven) Code mit Acme::DoubleHelix in eine Doppelhelix-Darstellung umgewandelt.

Um diese Darstellung von Code geht es aber nicht, wenn wir etwas mit PPI machen. Das Modul dient der statischen Analyse von Perl-Code. Zum Beispiel als Backend für Perl::Critic und das von Gregor letztens vorgestellte Test::Perl::Critic::Progressive. Da PPI eine statische Analyse durchführt, wird der Code nicht ausgeführt. Deshalb können manche Konstrukte aber nicht tiefergehend betrachtet werden:

require $module;

Welches Modul hier geladen wird, kann PPI nicht feststellen. Für viele Anwendungsbereiche ist das aber auch irrelevant. Es ermöglicht aber viele Anwendungen, ohne dass man Perl-Code ausführen muss oder selbst mit mehr oder weniger guten regulären Ausdrücken im Code etwas suchen muss.

Aber nicht nur wegen Perl::Critic ist PPI unser Modul des Monats. Es vereinfacht auch unsere Arbeit bei einigen Anwendungen.

Zum einen bei der Bereitstellung der Perl-API-Dokumentation der ((OTRS)) Community Edition unter https://otrs.perl-services.de aber auch bei der Anwendung zur Messung der Modul-Verbreitung unter https://usage.perl-academy.de .

Bei der OTRS-Dokumentation schauen wir im Code nach, ob es überhaupt POD in der Datei gibt und schmeißt den Rest quasi weg. Damit wird es einfacher, Teile der Dokumentation auseinanderzunehmen, ohne dass der restliche Code in die Quere kommt.

So sieht der entsprechende Code aus:

my @perl_files = $archive->membersMatching('\.(?:pm|pod)$');

FILE:
for my $file ( @perl_files ) {
    my $path = $file->fileName;

    next FILE if $path =~ m{cpan-lib};
    next FILE if $path !~ m{Kernel};

    my $code = $file->contents;
    my $doc  = PPI::Document->new( \$code );
    my $pod  = $doc->find( 'PPI::Token::Pod' );

    next FILE if !$pod;

    my $pod_string = join "\n\n", map{ $_->content }@{ $pod };
    my $package    = $doc->find_first('PPI::Statement::Package');

    $pod_string =~ m{
         ^=head\d+ \s+ DESCRIPTION \s+
         (?<description>.*?) \s+
         ^=(?:head|cut)
    }xms;

    my $description = $+{description} || '';
}

In $archive steckt ein Objekt von Archive::Zip und über das holen wir alle Perl-Module und POD-Dateien, die in der Zip-Datei stecken. Wir holen immer die Zip-Datei, damit wir nicht zig Git-Klone bei uns rumfliegen haben und wir die vielleicht gar nicht mehr brauchen.

Von jeder dieser Dateien holen wir mit ->contents den Inhalt der Datei. Mit PPI::Document->new( \\$code ) erzeugen wir dann das Objekt von PPI::Document und durch die Skalarreferenz weiß PPI, dass nicht eine Datei geparst werden soll, sondern der Inhalt der Skalarvariablen. Soll eine Datei geparst werden, nimmt man einfach PPI::Document->new( $path_to_file ) .

Anschließend suchen wir alle POD-Teile in der Datei (find), und wenn gar kein POD enthalten ist, brauchen wir gar nicht weiterzumachen. Der Methode find muss man den Paketnamen übergeben, nach dessen Objekten man sucht. Welche Klassen es gibt ist, wird in der PPI-Dokumentation gezeigt.

Da wir auch noch den Paketnamen brauchen, der im Perl-Code zu finden ist, suchen wir das erste Element der Klasse PPI::Statement::Package.

Somit haben wir dann alles, um das HTML aus POD zu generieren.

Die zweite Anwendung nutzt PPI, um cpanfiles zu parsen. Warum wir nicht das Modul Module::CPANfile nutzen? Wenn man sich das anschaut, lädt es den Perl-Code mit eval. Und da wir keine Kontrolle darüber haben, was die Besucher in die Dateien schreiben, die hochgeladen werden, nehmen wir lieber einen Parser zur statischen Analyse.

Schauen wir uns also mal an, was PPI aus einem cpanfile macht. Das cpanfile hat diesen Inhalt:

on 'test' => sub {
    requires 'Perl::Critic::RENEEB' => '2.01';
    requires "Proc::Background"     => 0;
    requires 'Test::BDD::Cucumber';
};

on 'runtime' => sub {
    requires 'Class::Unload';
};

on 'develop' => sub {
    requires 'CryptX' => '0.64';
    requires 'DBIx::Class::DeploymentHandler';
    requires q~Dist::Zilla~;
    requires MySQL::Workbench::DBIC => '1.13';
};

Um uns anzuschauen, wie das Perl Document Object Tree dazu aussieht, nutzen wir das folgende Skript (Perl::Critichat ein etwas mächtigeres Skript im Repository, das aber leider nicht installiert wird):

#!/usr/bin/perl
  
use strict;
use warnings;
use PPI;
use PPI::Dumper;
use Mojo::File qw(curfile);

curfile->sibling('examples')->list->first( sub {
    my $code = $_->slurp;
    my $doc  = PPI::Document->new( \$code );
    PPI::Dumper->new( $doc )->print and return;
});

Das erzeugt dann folgende Ausgabe:

PPI::Document
  PPI::Statement
    PPI::Token::Word    'on'
    PPI::Token::Whitespace      ' '
    PPI::Token::Quote::Single   ''test''
    PPI::Token::Whitespace      ' '
    PPI::Token::Operator    '=>'
    PPI::Token::Whitespace      ' '
    PPI::Token::Word    'sub'
    PPI::Token::Whitespace      ' '
    PPI::Structure::Block   { ... }
      PPI::Token::Whitespace    '\n'
      PPI::Token::Whitespace    '    '
      PPI::Statement
        PPI::Token::Word    'requires'
        PPI::Token::Whitespace      ' '
        PPI::Token::Quote::Single   ''Perl::Critic::RENEEB''
        PPI::Token::Whitespace      ' '
        PPI::Token::Operator    '=>'
        PPI::Token::Whitespace      ' '
        PPI::Token::Quote::Single   ''2.01''
        PPI::Token::Structure   ';'
      PPI::Token::Whitespace    '\n'
      PPI::Token::Whitespace    '    '
      PPI::Statement
        PPI::Token::Word    'requires'
        PPI::Token::Whitespace      ' '
        PPI::Token::Quote::Double   '"Proc::Background"'
        PPI::Token::Whitespace      '     '
        PPI::Token::Operator    '=>'
        PPI::Token::Whitespace      ' '
        PPI::Token::Number      '0'
        PPI::Token::Structure   ';'
      PPI::Token::Whitespace    '\n'
[...]

Wir wollen einfach die Modulnamen daraus haben, also der erste String nach dem Literal requires. An dem Dump kann man gut sehen, dass das Literal immer ein Objekt der Klasse PPI::Token::Word ist. Aber nicht jedes Objekt der Klasse enthält das Literal requires. Wir sehen zum Beispiel auch sub. Das müssen wir berücksichtigen. Nach dem Literal kommen beliebige Whitespaces, die uns aber nicht interessieren. PPI kennt da das Prinzip der significant siblings/children. Da in dem Baum die Elemente von requires und der Modulname auf einer Ebene sind, interessieren wir uns für das nächste signifikate Geschwister.

So sieht der Code dann in der Anwendung aus:

            my $code = $file->slurp;
            my $doc  = PPI::Document->new( \$code );

            my $requires = $doc->find(
                sub { $_[1]->isa('PPI::Token::Word') and $_[1]->content eq 'requires' }
            );

            if ( !$requires ) {
                $file->remove;
                return;
            }

            REQUIRED:
            for my $required ( @{ $requires || [] } ) {
                my $value = $required->snext_sibling;
                
                my $can_string = $value->can('string') ? 1 : 0;
                my $prereq     = $can_string ?
                    $value->string :
                    $value->content;
                
                save_prereq( $prereq );
            }

Der Anfang ist ähnlich zu oben. Wir lesen die Datei ein und erzeugen ein Objekt von PPI::Document. Während wir oben der Methode find nur die Klasse angegeben haben, deren Objekte wir alle haben wollen, möchten wir hier die Suche etwas einschränken. Nämlich alle PPI::Token::Word-Objekte, deren Inhalt required ist. Übergibt man eine anonyme Subroutine an find, wird für jedes Element unterhalb des zu durchsuchenden Knoten diese Subroutine aufgerufen.

Als Parameter werden zwei Parameter übergeben. Zum einen das Element auf dem die Suche ausgeführt wird und zum anderen das Element, das geprüft wird.

Die Methode content liefert den Code 1:1.

Für alle gefundenen requires bekommen wir die Objekte der Klasse PPI::Token::Word. Für jedes dieser Objekte wollen wir das erste signifikante Geschwister. Mit next_sibling würde man die Whitespaces bekommen, die interessieren uns aber nicht. Aus diesem Grund müssen wir snext_sibling verwenden.

Schauen wir noch mal kurz auf die verschiedenen Varianten der Modulangaben:

requires 'Perl::Critic::RENEEB' => '2.01';
requires "Proc::Background"     => 0;
requires q~Dist::Zilla~;
requires MySQL::Workbench::DBIC => '1.13';

... und die dazugehörigen PPI-Elemente:

PPI::Token::Quote::Single   ''Perl::Critic::RENEEB''
PPI::Token::Quote::Double   '"Proc::Background"'
PPI::Token::Quote::Literal  'q~Dist::Zilla~'
PPI::Token::Word            'MySQL::Workbench::DBIC'

Da die Whitespace-Knoten übergangen werden bekommen wir einen der hier gezeigten Knoten. Mit der Methode content bekommen wir den Wert wie er hier zu sehen ist, also inklusive der Anführungszeichen bzw. des q\~\~.

Wir müssen uns also auf die unterschiedlichen Methoden stützen, die die Objekte mitliefern. Bei den ganzen Quote::\*-Klassen kann die Methode string genutzt werden, bei PPI::Token::Word die Methode content.

Noch kurz zu den s...-Methoden: Als significant werden alle Teile bezeichnet, die für die Ausführung des Codes wichtig sind. Kommentare, POD-Dokumenation, __END__-Bereiche und Whitespaces gehören nicht dazu.

Die Skripte und Beispiele habe ich auch wieder ins Git-Repository gepackt.


Permalink:

Optimierung von Docker-Images

14.10.2020 // Gregor Goldbach

Wenn man als Entwickler mit der Erstellung von Docker-Images anfängt, dann ist das Image zunächst auf Funktionalität optimiert. Mit fortschreitender Entwicklung wird eine schnelle Rückmeldung über das Build-Ergebnis an die Entwickler wichtiger. Zudem soll ein Build reproduzierbar sein, damit von der CI-Umgebung gemeldete Fehler nachvollzogen und Änderungen für den Betrieb einplant werden können. Dieser Artikel zeigt, worauf man bei achten sollte, damit das klappt.

Zuerst: Funktionalität

Wir nutzen Gitlab und haben uns zu Beginn der Nutzung dieses Dienstes darauf konzentriert, überhaupt einen Build nach einem Commit durchlaufen zu lassen. Das ist manchmal gar nicht so einfach, da diverse Abhängigkeiten benötigt werden, die vor Ausführung von Tests in einem laufenden Container installiert werden müssen.

Wir bei Perl-Services haben uns zu Beginn auf die CI-Stufe von Gitlab verlassen. Da es hier aber mitunter etwas dauern kann, bis ein Build nach einem Commit startet, haben wir schnell gemerkt, dass lokales Bauen von Images sinnvoller ist. Dafür haben wir dann ein Makefile erstellt:

#!/bin/make -f
#
# Makefile pointers...
# Self-documenting:
#    https://marmelab.com/blog/2016/02/29/auto-documented-makefile.html
# Argument passing:
#    https://stackoverflow.com/questions/2826029/passing-additional-variables-from-command-line-to-make

#
# To add a new option, follow the format below, e.g.:
#     make command: ## Documentation of command
#             ./the-command-to-run.sh

# Default to displaying the help
.DEFAULT_GOAL := help

.PHONY: help

REGISTRY=registry.gitlab.com
IMAGE_NAME=perlservices/groupname/projectname-docker
IMAGE_TAG=latest
FULL_IMAGE_NAME=${REGISTRY}/${IMAGE_NAME}:${IMAGE_TAG}

# Displays all the make options and their descriptions
help:
    @grep -E '^[a-zA-Z_-]+:.*?## .*$$' $(MAKEFILE_LIST) | sort | awk 'BEGIN {FS = ":.*?## "}; {printf "\033[36m%-30s\033[0m %s\n", $$1, $$2}'

build: ## Build Docker image
    docker build -t ${FULL_IMAGE_NAME} .

shell: ## Start a container from the image built and run a shell in it
    docker run --rm -it --entrypoint /bin/bash \
        -v $$PWD/src:/src \
        -p 8080:8080 \
        ${FULL_IMAGE_NAME}

Dieses Makefile erstellt beim Aufruf von make build ein Docker-Image anhand des im gleichen Verzeichnisses liegenden Dockerfiles. Der Aufruf von make shell startet einen Container mit diesem Image und öffnet eine Shell darin, wobei hier das lokale Verzeichnis src im Container unter /src zur Verfügung steht.

Mit Hilfe dieses Makefiles können wir recht einfach ein Docker-Image erstellen und dieses lokal weiterentwickeln.

Schnelle Rückmeldung durch kurze Durchlaufzeit

Damit eine Perl-Distribution im Rahmen eines Docker-Images erstellt werden kann, werden viele Bausteine benötigt.

Einerseits benötigen wir auf Systemebene einige Werkzeuge. Dazu gehört zum Beispiel curl, um andere Builds auf Gitlab anzustoßen. Diese installieren wir über den Paketmanager des Betriebssystems.

Anderseits brauchen wir auf Anwendungsebene Module, die wir installieren müssen. Wenn sie in der geeigneten Version als Paket des Betriebssystems vorliegen, installieren wir sie ebenfalls mit dem Paketmanager des Betriebssystems. Wenn dies nicht der Fall ist, installieren wir sie von CPAN.

Diese Installationen dauern entsprechend lange und greifen auf externe Quellen zu. Dadurch dauert der Build lange und kann schlimmstenfalls fehlschlagen.

Daher haben wir hier in zwei Schritten optimiert: Wir erstellen für eine zu entwickelnde Perl-Distribution (oder Anwendung) ein spezifisches Image, das alle benötigten Abhängigkeiten enthält.

Im Dockerfile installieren wir zunächst mit apt-get install die benötigten Pakete des Betriebssystems:

FROM registry.gitlab.com/perlservices/groupname/projectname-docker:latest

RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
  lsb-core \
  wget

# Add PostgreSQL repo for the matching release of the OS
RUN wget --quiet -O - https://www.postgresql.org/media/keys/ACCC4CF8.asc | apt-key add -
RUN echo "deb http://apt.postgresql.org/pub/repos/apt/ `lsb_release -cs`-pgdg main" | tee  /etc/apt/sources.list.d/pgdg.list

RUN apt-get update && DEBIAN_FRONTEND=noninteractive apt-get install -y \
  postgresql \
  postgresql-client \
  git \
  apache2 \
  curl \
  phppgadmin \
  php-pgsql \
  cpanminus \
  libdbd-pg-perl \
  libnet-ssleay-perl \
  libxml-parser-perl \
  gosu \
  ...

Die Perl-Abhängigkeiten legen wir in einem cpanfile fest:

...
requires 'Mojolicious' => 8;
requires 'Mojolicious::Plugin::Bcrypt' => 0;
requires 'Mojolicious::Plugin::Status' => 0;
requires 'Moo' => 0;
requires 'MySQL::Workbench::DBIC', '>= 1.13';
requires 'MySQL::Workbench::Parser', '>= 1.06';
...

Das so erstellte Image verwenden wir dann in der .gitlab-ci.yaml unseres Projektes. So können dann sofort nach einem Commit in der CI-Stufe die konfigurierten Befehle ausgeführt werden, denn alle Abhängigkeiten sind bereits im Image vorhanden.

Reproduzierbare Builds durch genaue Versionsangaben

Gerade zu Beginn der Arbeit mit den oben beschriebenen projektspezifischen Docker-Images haben wir öfter Probleme mit der Nachvollziehbarkeit von Fehlern im Build auf Gitlab gehabt. Ursache dafür war, dass sich Abhängigkeiten in jedem Build geändert haben.

Beispiele für diese Änderungen:

  • Eine Perl-Distribution wird auf CPAN zwischen zwei Builds aktualisiert.
  • Lokal ist eine indirekte Abhängigkeit in einer anderen Version installiert.

Es wird dann unter Umständen auf Gitlab ein Fehler im Build angezeigt, der lokal beim Entwickler nicht mehr oder anders auftritt.

Durch das Erstellen von projektspezifischen Docker-Images werden schon viele Abhängigkeiten festgezurrt, so dass hier weitestgehend reproduzierbare Builds umgesetzt werden konnten.

Eine wesentliche Abhängigkeit ist jedoch noch nicht festgezurrt: Die des grundlegenden Images für alle Builds – Das verwendete Betriebssystem.

Vielfach wird in Beispielen für ein Dockerfile entweder kein Tag bei einem verwendeten Image angegeben oder eines mit dem Namen »latest«. Beide führen dazu, dass jeweils die letzte Fassung eines Images verwendet wird:

FROM debian:latest

Im schlimmsten Fall kann es dadurch dazu kommen, dass zwischen zwei Builds ein Versionssprung des Betriebssystems stattfindet und alle abhängigen Images neu gebaut werden. In der Regel läuft dies nicht ohne Probleme ab und zieht weitere Arbeiten nach sich.

Die dann auftretenden Probleme im Build können im günstigsten Fall eine kurze Verzögerung bedeuten, im schlimmsten Fall ungeplante Wartungsarbeiten nach sich ziehen.

Außerdem bedeuten gerade bei Betriebssystemen neue Versionen größere Änderungen im Betrieb, die sorgfältig vorbereitet und eingeplant werden müssen.

Diese Art von Überraschung kann umgangen werden, indem in Dockerfiles bei jedem verwendeten Image stets ein Tag mit angegeben wird, das eine feste Version spezifiziert.

Es sollte also auf Angaben wie »rolling« und »latest« verzichtet werden.

FROM ubuntu:20.04

Zusammenfassung

Während Entwickler zunächst auf Funktionalität bedacht sind, wenn sie in CI-Umgebungen mit dem Erstellen von Docker-Images beginnen, zeigt sich sehr schnell in der täglichen Arbeit, dass weitere Faktoren wichtig sind. Schnelle Rückmeldung durch kurze Durchlaufzeiten und stabiler Betrieb durch reproduzierbare Builds werden mit zunehmender Zeit wichtiger.

Dieser Artikel hat beschrieben, wie durch projektspezifische Images die Durchlaufzeit verringert werden kann. Außerdem wurde gezeigt, wie durch das ausdrückliche Konfigurieren von Softwareversionen planvolle Updates ohne große Überraschungen im Betrieb möglich werden.


Permalink:

Wie wir unsere Apps betreiben...

05.10.2020 // Renée Bäcker

Wir haben bei uns etliche Mojolicious-Anwendungen laufen. Dieses Blog, Perl-Academy.de sind Anwendungen und bei OPMToolbox.de sind es mehrere Anwendungen.

Die liegen teilweise auf dem gleichen Server. Jetzt stellt sich vielleicht die Frage, wie wir das dann betreiben. Die Antwort ist einfach: In der Regel gibt es für jede Anwendung einen eigenen User auf dem Server. Der startet die Anwendung mit hypnotoad. Und es gibt einen nginx, der als Reverse Proxy dient.

Installation der Anwendung

Warum jeweils ein eigener User? Warum alles hinter dem nginx?

Es gibt immer einen eigenen User, weil wir nicht alles mit root oder einem anderen User laufen lassen möchten. Und es hat den Vorteil, dass wir bei jedem User eine eigene Perl-Umgebung aufbauen können. Das heißt, dass wir mit perlbrew mindestens die Perl-Version installieren, mit der die Anwendung entwickelt wurde und auch die Module installieren, die die Anwendung braucht.

Das sieht dann so aus

$ useradd -m -s /bin/bash academy-blog
$ su - academy-blog
$ wget -O - https://install.perlbrew.pl | bash
$ source perl5/perlbrew/etc/bashrc
$ perlbrew install 5.30.2
$ perlbrew use 5.30.2
$ wget -O - https://cpanmin.us | perl - App::cpanminus
$ git clone <academy-blog> blog
$ cd blog
$ cpanm --installdeps .
$ hypnotoad blog

So muss ich auch nicht aufpassen, ob eine neue Mojolicious-Version eine Funktion rausgeschmissen hat oder eine andere Inkompatibilität mit sich bringt. So lange es läuft und an der Anwendung nichts geändert wird, kann die Umgebung so bleiben wie sie ist.

Eine andere Anwendung beeinflusst diese nicht. Egal, ob die andere Anwendung mit einer neuere Mojolicious-Version entwickelt wurde oder es vielleicht auch Module gibt, die sich gegenseitig ausschließen.

Natürlich bringt das unter Umständen mehr Aufwand mit sich, wenn in Modulen Sicherheitslücken auftauchen und dann eben mehrere Installationen angepasst werden müssen. Aber das kommt zum Glück nicht häufig vor.

Damit der User immer gleich das richtige Perl nutzt, nehmen wir noch eine kleine Änderung in der .bashrc vor: Wir laden dort perlbrew und die richtige Perl-Version:

source /home/academy-blog/perl5/perlbrew/etc/bashrc
perlbrew use 5.30.2

Wie wir sicherstellen, dass die Anwendung auch nach einem Serverneustart automatisch starten, zeige ich in einem späteren Blogpost.

Warum keine Container wie z.B. Docker? Weil wir (noch) nicht dazu gekommen sind, alles in Docker-Container zu packen. Das wird langfristig unser Ziel sein. Sobald wir soweit sind, berichten wir hier auch darüber.

Wenn alles installiert ist und die Anwendung läuft, ist sie von außen noch nicht erreichbar, weil wir die Anwendung immer nur auf 127.0.0.1:#port lauschen lassen. Es wäre ja auch blöd, wenn die Besucher*innen bei jeder Anwendung auch den Port kennen müssen.

Aus diesem Grund nutzen wir den nginx als Reverse Proxy. Außerdem ist die Nutzung von SSL damit ziemlich einfach.

nginx

Als erstes installieren wir den nginx

$ apt install nginx

Nach der Installation von nginx, packen wir für jede Anwendung eine eigene Konfigurationsdatei in den Ordner /etc/nginx/conf.d.\ Hier ein Beispiel:

upstream academy-blog {
  server 127.0.0.1:8080;
}

server {
  listen 80;
  server_name blog.perl-academy.de;

  location /.well-known/acme-challenge {
    root /home/academy-blog/letsencrypt/challenge/;
  }

  location / {
    return 301 https://blog.perl-academy.de$request_uri;
  }
}

server {
  listen 443 ssl;
  server_name perl-academy.de www.perl-academy.de;

  ssl_certificate /home/academy-blog/letsencrypt/live/blog.perl-academy.de/fullchain.pem
  ssl_certificate_key /home/academy-blog/letsencrypt/live/blog.perl-academy.de/privkey.pem;

  root /home/academy-blog/web/public/;
  try_files $uri @academy_app;

  location @academy_app {
    proxy_read_timeout 300;
    proxy_pass http://academy-blog;
    proxy_set_header Host $host;
    proxy_set_header X-Forwarded-For $proxy_add_x_forwarded_for;
    proxy_set_header X-Forwarded-HTTPS 0;
  }
}

Der upstream-Block bestimmt einen anderen Server, an den Anfragen weitergeleitet werden können. Hier nutzen wir einen sprechenden Namen. Es ist zu sehen, dass hypnotoad hier auf Port 8080 lauscht.

Anschließend kommt ein server-Block, der Anfragen auf Port 80 (http) behandelt. Wir legen den Servernamen fest. Es werden also Anfragen auf Port 80 für blog.perl-academy.de behandelt. Innerhalb dieses Blocks gibt es zwei location-Blöcke. Der erste ist wichtig, um später bequem LetsEncrypt-Zertifikate installieren zu können. Der zweit leitet HTTP-Anfragen auf HTTPS um.

Der zweite server-Block sorgt dafür, dass nginx auf Port 443 lauscht und SSL aktiviert ist. So lange die LetsEncrypt-Zertifikate nicht da sind, sollte dieser server-Block deaktiviert/auskommentiert werden.

Wir setzen den root der Dateien auf den public-Ordner der Anwendung. Im Zusammenspiel mit dem try_files sorgen wir dafür, dass statische Dateien nicht über die Mojolicious-Anwendung ausgeliefert werden, sondern direkt vom nginx. try_files prüft, ob eine Datei (die dann in $uri steht) existiert und liefert sie dann aus. Existiert sie nicht, greift der benamte Fallback (hier: @academy_app). Diesen benamten Fallback kann man sich wie eine Subroutine vorstellen. Der Fallback ist dann darauf definiert mit dem location-Block

Das Entscheidende ist die Zeile mit proxy_pass. Die bedeutet, das die Anfragen weitergeleitet werden. Hier taucht auch wieder der Name auf, den wir weiter oben bei upstream definiert haben.

SSL mit LetsEncrypt

Nachdem der nginx läuft, gehen wir den nächsten Schritt an: SSL-Verschlüsselung. Am einfachsten ist es, LetsEncrypt-Zertifikate zu nutzen. Dazu müssen wir certbot installieren:

$ apt install certbot

Anschließend können wir als User die SSL-Zertifikate generieren lassen:

$ su - academy-blog
$ mkdir -p letsencrypt/challenge
$ certbot certonly --config-dir /home/academy-blog/letsencrypt \
    --work-dir /home/academy-blog/letsencrypt \
    --logs-dir /home/academy-blog/letsencrypt \
    -d blog.perl-academy.de

Das Programm führt dann durch die Konfiguration. Da wir in der nginx-Konfiguration schon angegeben haben, wo an welcher Stelle LetsEncrypt auf Dateien zugreifen kann. An diese Stelle soll certbot Dateien packen:

How would you like to authenticate with the ACME CA?
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
1: Spin up a temporary webserver (standalone)
2: Place files in webroot directory (webroot)
- - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -
Select the appropriate number [1-2] then [enter] (press 'c' to cancel): 2
Plugins selected: Authenticator webroot, Installer None
Enter email address (used for urgent renewal and security notices) (Enter 'c' to
cancel): xxxx@perl-services.de

Man muss noch den Terms of Service zustimmen und anschließend noch das Verzeichnis, das über nginx erreichbar ist, angeben und dann sollte das Zertifikat erzeugt werden.

Läuft alles durch, kann der server-Block für das SSL in der nginx-Konfiguration wieder aktiviert werden.

Da die LetsEncrypt-Zertifikate nur jeweils 3 Monate gültig sind, müssen diese regelmäßig erneuert werden. Hier empfiehlt es sich, einen Cronjob einzurichten:

$ crontab -e

Und dort

0 5 15,30 * * certbot renew --config-dir ... --work-dir ... --logs-dir ...

eintragen.

Zusammenfassung

Für jede Anwendung nutzen wir einen eigenen User, damit wir komplett eigenständige Umgebungen haben. Die Anwendungen sind hinter\ einem nginx als Reverse Proxy. Für die SSL-Verschlüsselung nutzen wir certbot. In einem Bild zusammengefasst, sieht\ das dann so aus:

84cda14d-dc0c-45b4-87ec-624b60a73a64.png

Sollten Sie noch Fragen oder Anregungen haben, melden Sie sich einfach.


Permalink:

Start 1 2 3 4