Donnerstag, Mai 30, 2019

Groovy Maven POM Checker

Für das Releasen eines Maven Projekts gibt es das Maven Release-Plugin. Also kein Grund das Rad neu zu erfinden?

Richtig. Naja. Also für eine kleine Übung mit Groovy ist das Thema perfekt. Technisch interessieren mich hier die folgenden Dinge:

  • Wie bekomme ich farbige Ausgaben auf die Konsole?
  • Wie leicht kann ich XML Dokumente mit Groovy einlesen?
  • Wie greife ich auf andere Command-Line Werkzeuge zu?

Das Ergebnis findet sich in meinem Repository auf GitHub: validate-pom.groovy.

Gleich zu Beginn definiere ich mir ein paar Helfer-Methoden, die die Konsolenausgaben bunt anpinseln. Die Farbgebung funktioniert übrigens nur in einer Cygwin Konsole. Unter Linux habe ich das bisher nicht ausprobiert. Mit einer Powershell funktioniert das jedenfalls nicht. Z.B.:

def red() {
    print "\033[31;1m"
}

In Zeile 38 öffne ich die pom.xml und suche nach allen SNAPSHOT Abhängigkeiten. Falls eine SNAPSHOT Abhängigkeit gefunden wird, wird diese mit gelben Textzeichen ausgegeben.

pom.dependencies.dependency.each { dependency ->
    if (dependency.version.toString().contains('SNAPSHOT')) {
        yellow()
        enableWarning = true
    }
    println "    ${dependency.groupId}:${dependency.artifactId}:${dependency.version}"
    reset()
}

Als nächstes wird die changes.xml untersucht. Ich untersuche das letzte release Element, ob dort das aktuelle Datum drin steht.

def changesXmlAsFile = new File("./src/changes/changes.xml")
def changesXml = new XmlSlurper().parse(changesXmlAsFile)
def lastReleaseElement = changesXml.body.release[0]
def today = new Date().format('yyyy-MM-dd')
if (lastReleaseElement.@date.toString().contains('??-??')) {
    enableWarning = true
    yellow()
    println "    Release date is undefined: ${lastReleaseElement.@date.toString()}"
    reset()
} else if (!lastReleaseElement.@date.toString().contains(today)) {
    enableWarning = true
    yellow();
    println "    Release date is not today: ${lastReleaseElement.@date.toString()}"
    reset()
} else {
    ok()
}

Im letzten Schritt wird git aufgerufen und geprüft, ob un-commited changes vorliegen.

def sout = new StringBuilder()
def serr = new StringBuilder()
def proc = 'git status'.execute()
proc.consumeProcessOutput(sout, serr)
proc.waitForOrKill(1000)
println ""
println "Git repository:"
if (sout.toString().contains('git add')) {
    enableWarning = true
    yellow()
    println "    Uncommited changes! Check with git status."
} else {
    ok()
}

Ist das nicht der Fall, dann ist alles in Ordnung. Das Skript lässt sich natürlich wunderbar mit weiteren Funktionen erweitern. Wie oben bereits im Link angegeben, liegt das Skript in einem GIT Repository auf GitHub. In meiner Arbeitsumgebung habe ich das Projekt reingeclont. Im Anschluss passe ich die .bashrc an und lege einen alias auf das Skript. Z.B.:

alias pomcheck='groovy path.to.script/validate-pom.groovy

Fertig.

Freitag, Mai 03, 2019

Spring RestController und Exception Handling

Wer das erste mal einen klassischen Rest-Service mit Spring schreibt, also einen @RestController implementiert, der JSON (application/json; charset=utf-8) als Reponse ausliefert, kommt irgendwann auf die Idee, ebenfalls Fehlerzustände als JSON Response mit einem passenden HttpStatus Code auszuliefern.

Per Default erhält der Client den HTTP-Statuscode 500, wenn innerhalb des @RestController eine Exception geworfen wird. Das Ganze eingebettet in der Standardfehlerseite des Webservers. Als Antwort auf einen Restservice denkbar ungeeignet.

Eventuell möchte man einen Request auf die fachliche Korrektheit seiner Parameter überprüfen. Falls die Prüfung negativ ausfällt, sollen spezielle Http Status Codes (siehe Wikipedia HTTP StatusCodes) ausgeliefert werden. Z.B. könnte sich der Statuscode 400 BAD REQUEST oder 422 UNPROCESSABLE ENTITY für das Beispiel anbieten.

Wie sieht eine Implementierung dazu aus? Auf GitHub habe ich ein Beispielprojekt angelegt. Der Webservice nimmt Benutzer Registrierungen entgegen und vermerkt, ob der Benutzer dem Speichern von Cookies zugestimmt hat. Die Klasse de.awtools.registration.CookieController ist z.B. ein einfacher @RestController. Mit Spring hat man drei Möglichkeiten das beschriebene Problem zu lösen. Ich habe mich hier für die Lösung mit einem @ControllerAdvice entschieden. Das hat den Vorteil, dass dieser Advice für alle meine @RestController gilt. Der ControllerAdvice sieht folgendermaßen aus:

package de.awtools.registration.config;

import org.springframework.http.HttpHeaders;
import org.springframework.http.HttpStatus;
import org.springframework.http.MediaType;
import org.springframework.http.ResponseEntity;
import org.springframework.web.bind.annotation.ControllerAdvice;
import org.springframework.web.bind.annotation.ExceptionHandler;
import org.springframework.web.context.request.WebRequest;
import org.springframework.web.servlet.mvc.method.annotation.ResponseEntityExceptionHandler;

import de.awtools.registration.RequestValidationException;

@ControllerAdvice
public class GlobalExceptionAdvice extends ResponseEntityExceptionHandler {

    @ExceptionHandler(value = { RequestValidationException.class })
    protected ResponseEntity<Object> handleConflict(Exception ex,
            WebRequest request) {

        String bodyOfResponse = "Unknown";
        if (ex instanceof RequestValidationException) {
            RequestValidationException rvex = (RequestValidationException) ex;
            bodyOfResponse = new StringBuilder().append('{')
                    .append("\"message\": \"")
                    .append(rvex.getValidation().getValidationCode().toString())
                    .append("\"").append('}').toString();
        }

        HttpHeaders headers = new HttpHeaders();
        headers.setContentType(MediaType.APPLICATION_JSON_UTF8);

        return handleExceptionInternal(ex, bodyOfResponse,
                headers, HttpStatus.BAD_REQUEST, request);
    }

}

Hier werden alle Exceptions vom Typ RequestValidationException gefangen und ausgewertet. D.h. der Http-Statuscode 400 wird ausgeliefert und die Exception, bzw. die Nachricht aus der Exception, wird in ein einfaches JSON Objekt verpackt.

Weitere Beispiele und Erklärungen:

Samstag, Februar 23, 2019

Visual Studio Code Top Ten Extensions

Hier meine Top-Ten der wichtigsten Extensions für Visual Code:

  1. JSON Quicktype: Erstellt aus einem JSON Objekt, je nach ausgewählter Zielsprache, eine entsprechende Klassenstruktur. Im Prinzip wird versucht die Vorteile der statischen Generierung, wie man sie von einer WSDL Beschreibung her kennt, in die dynamische Welt der JSON Objekte zu transportieren. Insbesondere wenn eine typisierte Sprache wie Typescript oder Java verwendet wird, offenbaren sich die Vorteile, da eine IDE helfend eingreifen kann, in dem sie Eigenschaften bzw. Pfade zu Eigenschaften vorschlagen kann. Die Extension findet man hier: JSON Quicktype
  2. Visual Code kommt von Haus aus mit einer guten GIT Unterstützung daher. Dennoch gibt es einige sehr interssante Extensions zu dem Thema: Git History Diff
  3. Git Lens bietet Hover-Effekte an, um zu sehen, wer was in welcher Zeile geändert hat. Git Lens Supercharged
  4. Der Rest-Client war im letzten Post ein Thema. Rest-Client
  5. Indent Rainbow markiert farblichen Einrückungen. Interessant bei ‘klammerlosen’ Sprachen wie Python oder CSSS. Indent Rainbow
  6. TODO Highlight markiert TODO und FIXME Marker. TODO Highlight
  7. TODO Tree funktioniert ähnlich die TODO Highlight. TODO Tree
  8. Auto Close Tag. Schliessen oder umbenennen von Tags. Auto Close Tag
  9. Jetzt wird es schwierig. Vielleicht ist es eine gute Idee, Visual Code mit Extensions nicht zu überfrachten. Ob es eine kritische Anzahl von installierten Extensions gibt?
  10. Ab diesem Punkt schreibe ich selber meine Extensions. Möglicherweise bekomme ich dann ein Gefühl, wie sich Extensions im allgemeinen auf die IDE auswirken: Visual Code: Your First Extension

Bonus Runde:

  • Visual Code als GIT Editor einrichten. Vorher ist zu prüfen, ob code --help per Kommandozeile aufgerufen werden kann.

    git config --global core.editor "code --wait"
    
  • Visual Code als GIT Diff Tool einrichten:

    [diff]
        tool = default-difftool
    [difftool "default-difftool"]
        cmd = code --wait --diff $LOCAL $REMOTE
    

Sonntag, Februar 17, 2019

Visual Studio Code als Rest Client verwenden

  1. Visual Studio Code installieren. Visual Studio Code
  2. Die Erweiterung Rest-Client installieren.
  3. Einen bliebigen Workspace Folder anlegen und dort eine Datei anlegen, z.B. opendligadb.rest. Anhand der Dateiendung erkennt das Plugin, dass es für diese Datei zuständig ist und bietet im Editor ein paar Utilities an, z.B. das ‘Send Request’. Neben der Endung .rest wird auch .http von der Extension akzeptiert.
  4. Folgende Zeilen Code per Copy&Paste übernehmen und mit Ctrl-Alt R ausführen:
    POST http://www.openligadb.de/api/getmatchdata/bl1/2016/8 HTTP/1.1
    Accept: content-type: application/json
    
    oder falls eine Response im XML Format gewünscht ist (Fachbegriff Content Negotiation):
    POST http://www.openligadb.de/api/getmatchdata/bl1/2016/8 HTTP/1.1
    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
    
  5. Es geht ein Stück weit einfacher. https://example.com/comments/1 hinschreiben und Ctrl-Alt R eingeben. Nach der Ausführung des obigen Kommandos seht ihr die Fussballergebnisse von 2016 für den 8. Spieltag der Fussball Bundesliga.
  6. Mit # wird eine Kommentarzeile eingeleitet und es kann als Trennersymbol zwischen den verschiedenen Requests dienen. Beispiel:
    ### Request JSON response
    
    POST http://www.openligadb.de/api/getmatchdata/bl1/2016/8 HTTP/1.1
    Accept: content-type: application/json
    
    #### Request XML Response
    
    POST http://www.openligadb.de/api/getmatchdata/bl1/2016/8 HTTP/1.1
    Accept: text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8
    

Samstag, Februar 09, 2019

Docker Jenkins Update

Jenkins im Docker Container starten

  • Ein Verzeichnis auf dem lokalen Rechner anlegen. Ich gehe davon aus, dass auf einer Bash-Shell gearbeitet wird.
    mkdir -p $HOME/jenkins
    
  • Das Jenkins Image starten. Bei der Portnummer vergesse ich immer wieder, welche Zahl für welchen Host steht. Die erste Zahl bezeichnet den Port auf dem Docker Host. Die zweite Zahl nach dem Doppelpunkt den Port im Container.
    docker container run --name jenkins \
      -p 8080:8080 -p 50000:50000 \
      -v $HOME/jenkins:/var/jenkins_home \
      -d \
      jenkins
    
  • Das Passwort aufschreiben, welches jetzt angezeigt wird.
  • Browser öffnen mit der passenden IP Adresse. Bei mir läuft Docker in der Virtual Box auf einem Windows Pro Rechner. D.h. der Docker läuft in der Regel unter der IP Adresse 192.68.99.100.
    http://192.168.99.100:8080
    

Jenkins im Docker Container aktualisieren

  • Rechts oben im Browser seht ihr vielleicht eine rot unterlegte Zahl. Diese signalisiert, Jenkins möchte aktualisiert werden. Die Adresse des Download Links kopiert ihr.
  • Einloggen in den Docker Jenkins Container.
    docker container exec -u 0 -it jenkins bash
    
  • Das Update herunterladen. Dazu die kopierte Adresse aus dem vorletzten Schritt auf der Kommandozeile eingeben.
    wget http://updates.jenkins-ci.org/download/war/2.150.2/jenkins.war
    
  • Diese Datei an den richtigen Ort verschieben.
    mv ./jenkins.war /usr/share/jenkins
    
  • Berechtigung ändern.
    chown jenkins:jenkins /usr/share/jenkins/jenkins.war
    
  • Container verlassen und neu starten.
    exit
    docker container restart jenkins
    

Quelle Docker/Jenkins

Donnerstag, Februar 07, 2019

Kommunikation

Kommunikation

5 wichtige Wörter für die Kommunikation:
  • Weil
  • Danke
  • Ich verstehe dich
  • gerne
  • Wir
Gelernt in einem Video aus der Redefabrik: Youtube.

AssertJ und java.util.List

AssertJ hat eine praktische Möglichkeit, Listen in JUnit Tests abzuprüfen. Insbesondere, wenn in der Liste komplexe Objekte abgelegt sind, s...