seeseekey.net - Invictus Deus Ex Machina

Möchte man die installierte Standard-Firewall unter Cent OS 7 deaktivieren, so muss man sich am Dienst firewalld zu schaffen machen. Dieser kann dabei mit dem Kommando:

systemctl stop firewalld

gestoppt werden. Anschließend kann der Dienst mittels:

systemctl disable firewalld

dauerhaft deaktiviert werden. Mit dem Kommando:

firewall-cmd --state

kann nun überprüft werden ob der Dienst wirklich deaktiviert wurde. Wenn dies der Fall zeigt das Kommando die Ausschrift not running an.

Wenn man unter Java eine JSON-Datei schreiben möchte, so kann man dies natürlich von Hand tun. Einfacher und effizienter ist es allerdings wenn man das ganze mit der Bibliothek GSON erledigt. Dabei handelt sich um eine von Google entwickelte Bibliothek, welche ursprünglich für den internen Gebrauch bei Google gedacht war. Mit dieser ist neben vielen anderen Dingen unter anderem auch die Serialisierung von Java-Objekten in JSON möglich. Möchte man eine JSON-Datei manuell schreiben so nutzt man den von der Bibliothek bereitgestellten JsonWriter:

JsonWriter writer = new JsonWriter(new OutputStreamWriter(new FileOutputStream(new File("test.json")), StandardCharsets.UTF_8));

writer.setIndent("  "); // definiert die Einrückung

writer.beginObject();
writer.name("test");
writer.value("123");
writer.endObject();

writer.close();

Im ersten Beispiel wird ein einfaches Objekt in eine JSON-Datei geschrieben, was in der Datei schlussendlich so aussieht:

{
  "test": "123"
}

Natürlich ist es auch möglich beliebig viele Objekte in eine Datei zu schreiben und Arrays zu nutzen:

JsonWriter writer = new JsonWriter(new OutputStreamWriter(new FileOutputStream(new File("C:\\Temp\\test.json")), StandardCharsets.UTF_8));

writer.setIndent("  "); // definiert die Einrückung

writer.beginObject();
writer.name("persons");

writer.beginArray();

writer.beginObject();
writer.name("firstname");
writer.value("Hans");
writer.name("lastname");
writer.value("Meiser");
writer.endObject();

writer.beginObject();
writer.name("firstname");
writer.value("Luna");
writer.name("lastname");
writer.value("Bottom");
writer.endObject();

writer.endArray();

writer.endObject();

writer.close();

Heraus kommt dabei eine JSON Datei welche so aussieht:

{
  "persons": [
    {
      "firstname": "Hans",
      "lastname": "Meiser"
    },
    {
      "firstname": "Luna",
      "lastname": "Bottom"
    }
  ]
}

Zu finden ist die Bibliothek auf GitHub. Lizenziert ist die GSON-Bibliothek unter der Apache Lizenz und damit freie Software.

Wenn man JSON-Dateien erzeugt, kann es passieren das man bei der Erzeugung Fehler erzeugt. Zur Überprüfung solcher JSON-Daten kann man einen Validator nutzen, wie ihn jsonlint.com zur Verfügung stellt. Dort wird der JSON-Quelltext eingefügt und kann anschließend problemlos validiert werden. Bei Fehlern in der JSON-Datei, wird angezeigt wo diese entstehen und können damit beseitigt werden.

jsonlint.com

Der Quelltext von JSONLint kann auf GitHub bezogen werden. Er ist dabei unter der MIT-Lizenz lizenziert und damit freie Software.

Manchmal kommt es vor das man eine Java Applikation geschrieben hat, welche aus irgendeinem Grund mehr Speicher verbraucht als sie sollte. Im schlimmsten Fall führt dies zu einem OutOfMemory-Error. Möchte man dem Übeltäter auf die Spur kommen, kann man im ersten Schritt einen Heap Dump bei einem OutOfMemory-Error vornehmen. Dazu fügt man den VM Optionen der JVM den Parameter:

-XX:+HeapDumpOnOutOfMemoryError

hinzu. Dieser Parameter sorgt dafür, das im Falle eines OutOfMemory-Error, ein Dump des Heaps auf der Festplatte landet. Das Problem an diesem Dump ist allerdings, das er sich händisch schlecht auswerten lässt. Abhilfe schafft hier das freie Werkzeug Eclipse Memory Analyser.

Eclipse Memory Analyser

Mit diesem ist es möglich den Heap Dump einzulesen und anschließend unter Zuhilfenahme der Analysefunktion dem Memory Leak auf die die Spur zu kommen. Bezogen werden kann das Tool über die offizielle Webseite. Lizenziert ist der Memory Analyser unter der Eclipse Public License und damit freie Software.

Wenn man mittels Eclipse in Java entwickelt, so kann man mit der Tastenkombination Strg + Space den Content Assistant aktivieren. Ich persönlich bevorzuge es wenn dieser an so vielen Stellen wie möglich aktiviert wird, da dies die Entwicklung aus meiner Sicht wesentlich komfortabler macht.

Die Auto Activation Optionen

Dazu müssen die Einstellungen unter Window -> Preferences -> Java -> Editor -> Content Assist aufgerufen werden. Dort gibt es den Punkt Auto Activation. In das Feld Auto activation triggers for Java trägt man nun:

.abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ

ein und bestätigt das Ganze. Damit wird der Content Assistant immer aktiviert, was die Entwicklung beschleunigt, da man schneller an entsprechende Vorschläge kommt.

Die Methodensignatur der Standardeinsprungsmethode sieht unter Java wie folgt aus:

public static void main(String[] args)

Übergeben wird hierbei ein String-Array welches die Argumente der Befehlszeile enthält. Möchte man diese auswerten, kann man das natürlich von Hand machen. Alternativ kann man eine Bibliothek nutzen, welche einem diese Arbeit abnimmt. Eine dieser Bibliotheken ist JewelCli. JewelCli arbeitet auf Basis von Annotationen. Im ersten Schritt muss dazu ein Interface definiert werden:

public interface CommandLineOptions {
    @Unparsed
    List getFiles();

    @Option
    boolean isRecursive();

    @Option(defaultValue="localhost")
    String getDatabase();

    @Option(helpRequest = true)
    boolean getHelp();
}

In diesem Interface werden die verfügbaren Optionen über Annotationen definiert. So werden in den ersten zwei Zeilen die Unparsed-Optionen definiert. Das sind Optionen ohne Schlüssel, welche dann z.B. als Dateinamen interpretiert werden können. Die zweite Option welche im Interface definiert wird ist ein Schalter. So kann später in der Befehlszeile der Wert -recursive definiert werden, was sich auf den Wert der Rückgabe von isRecursive() auswirkt. Bei der dritten Option wird ein String übergeben welcher in der Befehlszeile mittels –database db.example.com definiert werden kann. Der Parameter ist dabei optional, so wird der Wert localhost angenommen, wenn der Wert nicht über die Befehlszeile definiert wurde. Die letzte Option dient der Implementation der Hilfe-Funktionalität. Wird der Parameter angegeben, so erzeugt JewelCli automatische die entsprechende Hilfsausgabe für die definierten Parameter. Daneben gibt es noch eine Reihe weiterer Nutzungsmöglichkeiten. Wenn das Interface definiert ist, ist der Großteil der Arbeit abgeschlossen. Nun muss die Auswertung der Parameter angestoßen werden:

CommandLineOptions result;

try {
    result = CliFactory.parseArguments(CommandLineOptions.class, args);
}
catch (ArgumentValidationException e)
{
    System.out.println(e.getMessage());
    return;
}

Dazu wird die Methode parseArguments der Klasse CliFactory genutzt, welche die Argumente unter Nutzung des definierten Interfaces auswertet. Schlägt dies fehl wird eine Exception ausgelöst und die Nachricht dieser auf der Konsole ausgegeben. Der Quelltext von JewelCli kann unter anderen auf GitHub bezogen werden. Lizenziert ist die Bibliothek unter der Apache-Lizenz und damit freie Software.

Wenn man unter Eclipse in Java entwickelt, so möchte man natürlich das dieser Code formatiert wird. Dafür gibt es je nach System die Kombination Strg + Shift + F oder unter Mac OS X die Kombination Command + Shift + F. Damit wird der aktuell geöffnete Quelltext formatiert.

Die Save Actions in den Eclipse Einstellungen

Alternativ kann Eclipse so eingestellt werden, das der Quelltext beim Speichern neu formatiert wird, was auf Dauer natürlich praktischer ist. Dazu müssen die Einstellungen unter Window -> Preferences -> Java -> Editor-> SaveActions aufgerufen werden. Dort kann die automatische Formatierung der Quellcodes beim Speichern aktiviert werden.

Nutzt man die freie Git-Hosting-Lösung Gogs, so kommt man regelmäßig in den Genuss von Updates. Möchte man das Upgrade einspielen, so gibt es einige Dinge zu beachten. Im ersten Schritt sollte der Dienst auf dem Server natürlich beendet werden:

service gogs stop

Anschließend wird in den Kontext des Nutzers gewechselt unter welchem Gogs betrieben wird:

su git
cd

Der nächste Schritt ist der Download der neuen Version, sowie die Verschiebung der alten Version und das Kopieren der Konfigurationsdatei von der alten zur neuen Version:

mv gogs gogs_old
wget https://github.com/gogits/gogs/releases/download/v0.8.10/linux_amd64.zip
unzip linux_amd64.zip 
cp -R gogs_old/custom gogs
cp -R gogs_old/data gogs
cp -R gogs_old/log gogs

Danach wird in den Gogs Ordner gewechselt und Gogs manuell gestartet.

cd gogs
./gogs web

Bei diesem Start wird die Migration der Datenbank durchgeführt. Anschließend kann Gogs wie gehabt genutzt werden. Die heruntergeladene Datei sowie der Ordner gogs_old können anschließend entfernt werden.

Zur Entwicklung von Anwendungen nutze ich im Normalfall die Programmiersprache C#. In dieser gibt es sogenannte Signed und Unsigned-Datentypen. Im Deutschen würde man dazu vorzeichenbehaftete und vorzeichenlose Typen sagen. Bei einem vorzeichenbehafteten Typ wird die Hälfte des Wertebereiches für die Darstellung negativer Zahlen und die andere Hälfte für die Darstellung positiver Zahlen genutzt. Dies führt allerdings dazu das man die Hälfte des positiven Wertebereiches einbüßt. So gibt es für den UInt32 und den Int32 unter C# bzw. der CLR folgende Wertebereiche:

UInt32    0 bis 4.294.967.295
Int32    −2.147.483.648 bis 2.147.483.647

An dieser Stelle spielen vorzeichenlose Datentypen ihre Stärke aus, da sie über einen größeren Wertebereich für positive Zahlen verfügen – bei gleichem Speicherverbrauch. So ist die Nutzung vorzeichenloser Datentypen immer dann interessant, wenn man größere positive Zahlen speichern möchte. Wenn man sich nun die Datentypen bei Java anschaut, so wird man feststellen, das es unter Java keine vorzeichenlosen Typen (mit der Ausnahme des 16 Bit großen Typs char) gibt. Möchte man nun z.B. die Werte von 0 bis 255 speichern, was bei der Verarbeitung von Daten aus bestimmten Dateiformaten vorkommt, müsste man in Java hierfür einen short (16 Bit) anstatt eines byte (8 Bit) nutzen, da selbst das byte unter Java vorzeichenbehaftet ist und nur den Bereich von -128 bis 127 abbilden kann. Möchte man diesen zusätzlichen Speicherplatz nicht hergeben, so gibt es auch unter Java eine Möglichkeit größere Werte in einem byte zu speichern:

byte unsigned = (byte)200;
int value = (int)unsigned^-256;

In der ersten Zeile wird die Zahl 200 gecastet und der Variable unsigned zugewiesen. Das Bitmuster in der Variable entspricht dann der Zahl 200. Da der Typ allerdings als vorzeichenbehaftet interpretiert wird, würde ein:

System.out.println(unsigned);

zur Ausgabe der Zahl -56 führen. Möchten wir den Wert der Variable vorzeichenlos ermitteln, muss eine XOR-Operation mit -256 ausgeführt werden, welche schließlich zum Ergebnis 200 führt.

Unter Umständen kann es vorkommen, das man viele Videodateien bearbeiten muss, welche in Halbbildern vorliegen. Möchte man diese nun in progressives Material (nur Vollbilder) umkodieren, so kann das freie Tool ffmpeg sehr hilfreich sein. Auf der Konsole sieht die einfachste Variante des deinterlacing dabei so aus:

ffmpeg -i InputFile -vf yadif OutputFile

Möchte man die Datei bei dem deinterlacen gleich umkodieren, so ist dies mit ffmpeg in einem Rutsch möglich:

ffmpeg -i InputFile.mp4 -c:v libx264 -preset slow -crf 18 -c:a copy -vf yadif OutputFile.mkv

In diesem Fall wird das Eingangsvideo in H.264 umkodiert und gleichzeitig das Material deinterlaced. Je nach Video nimmt der Vorgang etliche Minuten bis Stunden in Anspruch.