Mit der Option -a führt rsync den Abgleich im „Archive Mode” durch, d.h. Symlinks, Devices, Permissions, Ownerschaft usw. werden auf die Zielmaschine transferiert.

Was aber, wenn gewisse Unterschiede erforderlich sind, z.B. die Ownerschaft einiger Dateien verschieden sein muss, weil der Owner oder die Group auf der Zielmaschine anders heißen?

Beispiel: Die Group des HTTP-Servers heißt auf der einen Maschine „www-data” während sie auf der anderen Maschine „apache” heißt. Über die Group bekommt der HTTP-Server Rechte auf bestimmten Dateien eingeräumt, sie muss also passend zur Maschine gesetzt sein.

Solche Differenzen kann rsync nicht auflösen und bietet auch keine Option hierfür. Es lässt sich aber mit einem nachgeschalteten Shell-Skript erreichen, das via ssh auf der Zielmaschine ausgeführt wird:

rsync -az --delete -e ssh DIR1/ USER@HOST:DIR2
ssh USER@HOST CMD

Wird CMD in DIR1 abgelegt, wird es durch den rsync-Aufruf mit verwaltet, also automatisch auf dem neusten Stand gehalten.

Overlays sind Bilder, die von Google Earth auf einen Bereich der Erdoberfläche (GroundOverlays) oder statisch ins Anwendungsfenster (ScreenOverlays) projeziert werden.

Zu den Bildern gehört eine Spezifikation in KML (Keyhole Markup Language), die die Bilder beschreibt und festlegt, wie Google Earth mit ihnen verfahren soll. KML ist XML-basiert und wird in einer Datei mit der Extension .kml gespeichert.

Die kml-Datei und die Bild-Dateien können zusammen in Form einer einzelnen kmz-Datei an Google Earth übergeben werden. Die kmz-Datei ist eine ZIP-Datei, die die genannten Dateien enthält.

Die kmz-Datei wird entweder über "File/Open" geladen oder als Parameter beim Aufruf von Google Earth angegeben.

Beispiel

KML-Datei

Obige KML-Spezifiktion beschreibt ein Bild, das auf die Erdoberfläche projeziert wird (Element GroundOverlay) und ein Bild, das statisch in der oberen linken Ecke des Fensters dargestellt wird (Element ScreenOverlay). Die beteiligten Hauptelemente sind: Document, GroundOverlay, ScreenOverlay.

Für die Platzhalter __NAME__, __DESCRIPTION__ usw. müssen konkrete Werte eingesetzt werden.

__NAME__

Bezeichnung des Orts (Google-Terminus: Place). Diese Bezeichnung erscheint auf der linken Seite im Fenster und kann direkt ausgewählt werden.

__DESCRIPTION__

Beschreibung zum Ort.

__FILE__

Dateiname des Bildes, das auf die Erdoberfläche projeziert wird.

__NORTH__, __SOUTH__, __EAST__, __WEST__

Quadrupel von dezimalen Gradzahlen, die die geografische Region definieren.

__LEGEND_FILE__

Dateiname des statischen Bildes (das wir hier als "Legende" bezeichnen).

MIME Type

Wird die kmz-Datei von einem HTTP-Server ausgeliefert, sollte dieser den MIME-Type kennen:

application/vnd.google-earth.kmz kmz

Im Browser kann Google-Earth als Helper-Applikation vereinbart werden. Beim Eintreffen einer kmz-Datei wird Google Earth dann automatisch gestartet und positioniert an den betreffenden Ort. Die Angaben für den Browser sind:

Applikation

http://ferrydata.gkss.de/index.cgi?seite=map_plot

Vielleicht trivial, aber mir war die Antwort bislang nicht klar: Wie gebe ich eine Gleitkomma-Zahl aus, ohne dass Stellen wegfallen oder überflüssige Nullen am Ende erscheinen?

Bei der Ausgabe von Gleitkommazahlen habe ich bislang automatisch zu printf/sprintf und %f gegriffen, aber das Format-Element %f formatiert die Zahlen ja immer auf eine feste Anzahl an Stellen und rundet auf die letzte Stelle. Z.B.

my $x = 0.123456789;
printf "%f",$x;

ergibt

0.123457

(%f formatiert/rundet per Default auf 6 Nachkommastellen)

Natürlich kann ich die Anzahl der Stellen groß wählen, aber dann bekomme ich u.U. zusätzliche Stellen, wenn die betreffende Zahl binär nur näherungsweise dargestellt werden kann:

my $x = 0.123456789;
printf "%.20f",$x;

ergibt

0.12345678899999999734

Andererseits erhalte ich am Ende überflüssige Nullen bei Zahlen, die dezimal weniger als die vorgegebenen Stellen besitzen:

my $x = 0.5;
printf "%.20f",$x;

ergibt

0.50000000000000000000

Was tun?

Die Lösung ist (anscheinend) einfach: Ich gebe die Zahl nicht als Zahl sondern als String aus! D.h. im Falle von printf/sprintf mit Format-Element %s!

Damit erhalte ich, was ich will. Die Zahl mit allen Stellen und nicht mehr

my $x = 0.123456789;
printf "%s",$x;

0.123456789

und ohne überflüssige Nullen

my $x = 0.5;
printf "%s",$x;

0.5

Bei näherer Überlegung leuchtet das ein, da Perl intern neben der (binären) numerischen Repräsentation eine Stringrepräsentation des Werts speichert, welche anfänglich genau der Zeichenfolge bei der Zuweisung entspricht.

Schlussfolgerung: Programme, die nicht rechnen, sondern Gleitkommazahlen nur einlesen und wieder ausgeben, sollten, um Verfälschungen auszuschließen, diese bei der Ausgabe grundsätzlich als Strings und nicht als Zahlen behandeln.

In Mailto-URLs

Statt den Mailto-URL per href zu setzen, wird der mailto-URL zum Zeitpunkt des Klicks via JavaScript generiert.

Nicht gut:

<a href="mailto:rudi.ratlos@host.dom">...</a>

Besser:

<a href="#" onclick="this.href = 'mailto:rudi.ratlos'+'&#64;'+'host.dom'">...<a/>

Dies setzt natürlich JavaScript voraus. Aber schreibt heutzutage noch jemand Web-Anwendungen ohne JavaScript?

Im Text

Statt die Email-Adresse im Klartext hinzuschreiben, wird das @-Zeichen ausgetauscht: entweder durch ein HTML-Entity, eine Zeichenkette wie "<AT>" oder eine Grafik:

Nicht gut:

rudi.ratlos@host.dom

Besser:

rudi.ratlos@host.dom

Noch besser, mit Text:

rudi.ratlos<AT>host.dom

Mit Grafik:

rudi.ratlos<img src="at.png" alt="AT" ... />host.dom

Bei einer Grafik besteht das Problem, dass diese vom Aussehen statisch ist, das Aussehen des umgebenden Textes u.U. nicht immer gleich ist, z.B. in unterschiedlichen Browsern oder durch Farbänderung beim Überfahren eines Links.

Eine einfache (eventuell nicht besonders wirksame) Methode, um Email-Adressen in HTML-Seiten unkenntlich zu machen, um sie vor Spammern zu verbergen, ist, sie in Entity-Schreibweise zu wandeln. Das folgende Perl-Skript wandelt einen beliebigen String in Entity-Schreibweise:

Beispiel:

$ ./str-to-entity 'rudi.ratlos@...'
rudi.ratlos@...

Clientseitig

$ echo "ServerAliveInterval 120" >> /etc/ssh/ssh_config

Wenn der Server 120 Sekunden kein Paket gesendet hat, sendet der Client ein Dummy-Paket zum Server.

Serverseitig

$ echo "ClientAliveInterval 120" >> /etc/ssh/sshd_config
$ /etc/init.d/ssh reload

Wenn der Client 120 Sekunden kein Paket gesendet hat, sendet der Server ein Dummy-Paket zum Client.

Ein automatisches Login führt SSH durch, wenn auf der Zielmaschine der Öffentliche Schlüssel des eigenen Accounts hinterlegt ist. Der Öffentliche Schlüssel wird auf der Zielmaschine zum Zielaccount hinzugefügt mittels:

$ cat id_rsa.pub >>.ssh/authorized_keys2

Information zur Schlüsselgenerierung: http://www.supportnet.de/faqsthread/806

TIMESTAMP WITHOUT TIME ZONE nach EPOCH

Umwandlung eines TIMESTAMP WITHOUT TIME ZONE in Unix-Epoch (Sekunden seit 1.1.1970 0 Uhr) in einer Anwendung, die mit UTC-Zeiten arbeitet:

sql> SELECT EXTRACT(EPOCH FROM TIMESTAMP '1970-01-01 00:00:00' AT TIME ZONE 'UTC') AS t;
 t 
---
 0

Entscheidend ist hier der Zusatz "AT TIME ZONE 'UTC'", denn ein TIMESTAMP WITHOUT TIME ZONE wird als Zeit der lokalen Zeitzone interpretiert - nicht etwa UTC! Ohne den Zusatz ist das Resultat um dem Offset der lokalen Zeitzone verschoben - böse Falle. Hier das Ergebnis im Falle von MEZ (+0100):

sql> SELECT EXTRACT(EPOCH FROM TIMESTAMP '1970-01-01 00:00:00') AS t;
   t   
-------
 -3600

Erläuterungen

• EXTRACT(EPOCH FROM t) extrahiert die Epoch-Sekunden vom Zeit-Wert t.
• TIMESTAMP '1970-01-01 00:00:00' ist die Zeitangabe t.
• AT TIME ZONE 'UTC' interpretiert die Zeitangabe t hinsichtlich Zeitzone UTC.

EPOCH nach TIMESTAMP WITHOUT TIMEZONE

Umwandlung von Epoch-Sekunden in einen TIMESTAMP WITHOUT TIMEZONE (die0 steht für den Epoch-Wert):

sql> gkss=# SELECT TIMESTAMP 'epoch' + 0 * INTERVAL '1 second' AS t;
         t    
---------------------
 1970-01-01 00:00:00

Erläuterungen

• TIMESTAMP 'epoch' bzeichnet den Anfang der Zeitrechnung (1.1.1970 0 Uhr).
• 0 * INTERVAL '1 second' ist der Zeitoffset in Sekunden, der hinzuaddiert wird. Er kann auch negativ sein.
• Das Resultat ist ein Timestamp.

Verzeichnisbaum spiegeln (local => remote)

$ rsync -avz --delete dir1/ user@host:dir2

Der trailing Slash bei dir1/ ist wichtig, da sonst dir1 in dir dir2 hineinkopiert wird. Die Verzeichnisse können unterschiedlich heißen.

Bei Angabe der Option -n wird die Ausführung nur simuliert.

Via ssh

$ rsync -e ssh -avz --delete dir1/ user@host:dir2

Via ssh mit speziellem Port

$ rsync --rsh='ssh -p port' -avz --delete dir1/ user@host:dir2

Für den Umgang mit Symlinks stellt Perl eine Reihe von Builtins zur Verfügung, die nicht unbedingt offensichtlich sind. Hier eine kurze Übersicht:

$bool = -l $path

Test auf Symlink.

@stat = lstat $path

Dateisystem-Eigenschaften des Symlink.

$destPath = readlink $path

Ziel des Symlink.

$bool = symlink $path,$destPath

Erstelle Symlink $path mit Ziel $destPath. Liefert 0 im Fehlerfall.

Wie ermittele ich, welche Perl-Module über das Grundsystem hinaus installiert wurden?

Die Antwort liefert das Kommando:

$ perldoc perllocal

Das Ergebnis ist ein formatiertes POD-Dokument, das die Installationshistorie aller per make install oder ./Build install installierten Module aufführt.

Das Dokument wird mit der Installation des ersten Moduls angelegt. Unmittelbar nach Installation des Core-Systems ist es noch nicht vorhanden, da noch kein zusätzliches Modul installiert wurde.

Mit jeder Modul-Installation wird ein Eintrag am Ende hinzugefügt. Wird ein Modul mehrfach installiert, taucht es mehrfach auf.

Programm

Liefere die Namen der zusätzlich installierten Module, alphabetisch sortiert, ohne Doubletten:

 1 #!/usr/bin/env perl
 2 
 3 use strict;
 4 use warnings;
 5 
 6 my %mod;
 7 my $cmd = 'perldoc -u perllocal';
 8 open(my $fh,'-|',$cmd) or die "ERROR: open failed ($!)";
 9 while (<$fh>) {
10     if (/^=head2.*\|(.*)>/) {
11         $mod{$1} = 1;
12     }
13 }
14 close($fh) or die qq|ERROR: Command failed: "$cmd" (Exit Code: $?)\n|;
15 
16 for my $mod (sort keys %mod) {
17     print "$mod\n";
18 }
19 
20 # eof

Sammlung von mehreren tausend qualitativ hochwertigen Desktop- und Web-Icons: http://www.iconarchive.com/

Fugue Icons: http://p.yusukekamiyamane.com/

Farbe transparent machen

Menüpunkt: "Colors/Color to Alpha..."

$ tcs -f 8859-1 INPUT >OUTPUT

Der Speicherbedarf von einzelnen Perl-Variablen und komplexeren Datenstrukturen lässt sich mit Devel::Size ermitteln. Hier die Werte für Perl 5.10 auf einem 32-Bit System.

(Eine andere Betrachtung - Messung des verbrauchten virtuellen Speichers bei großen Datenstrukturen - hat Peter J. Holzer angestellt: http://www.hjp.at/programming/perl/memory/)

Skalare

Perl alloziert bei Strings jeweils 4 Bytes im Voraus, vermutlich um jedes UTF-8 Zeichen speichern zu können. Obige Berechnung geht von 1-Byte-Zeichen aus. Enthält der String UTF-8 Zeichen mit 2, 3 oder 4 Byte, vergrößert sich der Platzbedarf entsprechend.

Arrays

Perl vergrößert ein Array schrittweise auf 4, 8, 16, 32, 64, ... Elemente. D.h. wird das 4. Element zugewiesen, vergößert Perl intern schon auf 8 Elemente usw. Für jedes Element alloziert Perl einen Pointer (4 Bytes). Die angegebene Größe ist der Netto-Speicherbedarf des Array, d.h. der Speicherbedarf der (skalaren) Werte kommt noch hinzu.

Hashes

Perl vergrößert einen Hash schrittweise auf 8, 16, 32, 64, ... Elemente. D.h. wird das 8. Element zugewiesen, vergößert Perl intern auf 16 Elemente usw. Für jeden Key alloziert Perl vorab einen Pointer (4 Bytes). Zusätzlich kommt mit zunehmender Anzahl Buckets ein wachsender Overhead von 9, 10, 11, ... Bytes je Key hinzu. Die Größe des Key geht auch mit ein. Bei der Messung unten ist der Key der String "EintragNNNN", also 11 Zeichen lang. Die angegebene Größe ist der Netto-Speicherbedarf des Hash, d.h. der Speicherbedarf der Werte kommt noch hinzu.

Messung

Perl Version: 5.010000
Skalar ohne Wert: 16 Bytes
Referenz: 16 Bytes
Integer: 16 Bytes
Float: 24 Bytes
String - leer: 36 Bytes
String - 1 1-Byte Zeichen: 36 Bytes (Diff: 0)
String - 2 1-Byte Zeichen: 36 Bytes (Diff: 0)
String - 3 1-Byte Zeichen: 36 Bytes (Diff: 0)
String - 4 1-Byte Zeichen: 40 Bytes (Diff: 4)
String - 5 1-Byte Zeichen: 40 Bytes (Diff: 0)
String - 6 1-Byte Zeichen: 40 Bytes (Diff: 0)
String - 7 1-Byte Zeichen: 40 Bytes (Diff: 0)
String - 8 1-Byte Zeichen: 44 Bytes (Diff: 4)
String - 9 1-Byte Zeichen: 44 Bytes (Diff: 0)
String - 10 1-Byte Zeichen: 44 Bytes (Diff: 0)
String - 11 1-Byte Zeichen: 44 Bytes (Diff: 0)
String - 12 1-Byte Zeichen: 48 Bytes (Diff: 4)
String - 16 1-Byte Zeichen: 52 Bytes (Diff: 4)
String - 20 1-Byte Zeichen: 56 Bytes (Diff: 4)
Array - leer: 100 Bytes
Array - 4 Elemente: 116 Bytes (Diff: 16) - 29.0 Bytes/Key
Array - 8 Elemente: 148 Bytes (Diff: 32) - 18.5 Bytes/Key
Array - 16 Elemente: 212 Bytes (Diff: 64) - 13.2 Bytes/Key
Array - 32 Elemente: 340 Bytes (Diff: 128) - 10.6 Bytes/Key
Array - 64 Elemente: 596 Bytes (Diff: 256) - 9.3 Bytes/Key
Hash - leer: 76 Bytes
Hash - 4 Keys: 208 Bytes (Diff: 132) - 52.0 Bytes/Key
Hash - 8 Keys: 372 Bytes (Diff: 164) - 46.5 Bytes/Key
Hash - 16 Keys: 636 Bytes (Diff: 264) - 39.8 Bytes/Key
Hash - 32 Keys: 1228 Bytes (Diff: 592) - 38.4 Bytes/Key
Hash - 64 Keys: 2412 Bytes (Diff: 1184) - 37.7 Bytes/Key
Hash - 128 Keys: 4780 Bytes (Diff: 2368) - 37.3 Bytes/Key
Hash - 256 Keys: 10540 Bytes (Diff: 5760) - 41.2 Bytes/Key
Hash - 512 Keys: 18988 Bytes (Diff: 8448) - 37.1 Bytes/Key
Hash - 1024 Keys: 42028 Bytes (Diff: 23040) - 41.0 Bytes/Key

Programm

 1 #!/usr/bin/env perl
 2 
 3 use strict;
 4 use warnings;
 5 
 6 use Devel::Size;
 7 
 8 print "Perl Version: $]\n";
 9 
10 my $s1;
11 print 'Skalar ohne Wert: ',Devel::Size::size(\$s1)," Bytes\n";
12 
13 my $s2 = \$s1;
14 print 'Referenz: ',Devel::Size::size(\$s2)," Bytes\n";
15 
16 my $s3 = 4711;
17 print 'Integer: ',Devel::Size::size(\$s3)," Bytes\n";
18 
19 my $s4 = 1234.567;
20 print 'Float: ',Devel::Size::size(\$s4)," Bytes\n";
21 
22 my $s5 = '';
23 my $nLast = Devel::Size::size(\$s5);
24 print "String - leer: $nLast Bytes\n";
25 
26 for my $i (1..12,16,20) {
27     $s5 = 'x'x$i;
28     my $n = Devel::Size::size(\$s5);
29     print "String - $i 1-Byte Zeichen: $n Bytes (Diff: ",$n-$nLast,")\n";
30     $nLast = $n;
31 }
32 
33 my @a1;
34 $nLast = Devel::Size::size(\@a1);
35 print "Array - leer: $nLast Bytes\n";
36 
37 for my $i (4,8,16,32,64) {
38     my @a2 = (1..$i);
39     my $n = Devel::Size::size(\@a2);
40     my $diff = $n-$nLast;
41     my $avg = $n/$i;
42     printf "Array - $i Elemente: $n Bytes (Diff: $diff) - %.1f Bytes/Key\n",$avg;
43     $nLast = $n;
44 }
45 
46 my %h1;
47 $nLast = Devel::Size::size(\%h1);
48 print "Hash - leer: $nLast Bytes\n";
49 
50 for my $i (4,8,16,32,64,128,256,512,1024) {
51     my %h2;
52     for (my $j = 1; $j <= $i; $j++) {
53         $h2{sprintf 'Eintrag%04d',$j} = $j;
54     }
55     # @h2{(1..$i)} = (1..$i);
56     my $n = Devel::Size::size(\%h2);
57     my $diff = $n-$nLast;
58     my $avg = $n/$i;
59     printf "Hash - $i Keys: $n Bytes (Diff: $diff) - %.1f Bytes/Key\n",$avg;
60     $nLast = $n;
61 }
62 
63 # eof

<input type="text"  id="e" name="text" size="20" />

Text:

Umrahmung

Rahmen von 1px Breite statt der normalen Dekoration.

#e {
  border: 1px #999 solid;
}

Hintergrundfarbe

Die Hintergrundfarbe des Eingabefeldes ändern, wenn es mit der Maus überfahren wird (:hover) oder den Fokus bekommt (:focus). Besitzt das Feld weder den Fokus noch befindet sich die Maus darüber, wird die ursprüngliche Hintergrundfarbe automatisch wieder hergestellt. Dies braucht nicht vereinbart werden.

#e:hover, #e:focus {
  background-color: #eee;
}

Font

Ein Text-Eingabefeld sollte m.E. normalerweise einen monospaced Font eingestellt haben, nur dann entspricht die optische Feldbreite exakt der Anzahl der Zeichen, die in das Feld passen.

#e {
  font-family: monospace;
}

In HTML:

<table cellspacing="0">

Per CSS (#t sei die Tabelle):

#t {
  border-collapse: collapse;
}

#t > td {
  padding: 0;
}

Layout mit Kopf, Fuss und drei Spalten:

Der HTML- und CSS-Code, der dies realisiert:

<div id="header">
Header
</div>
<div id="left">
Left
</div>
<div id="right">
Right
</div>
<div id="middle">
Middle
</div>
<div id="footer">
Footer
</div>

#header {
  clear: both;
}
#left {
  float: left;
  width: 80px;
}
#right {
  float: right;
  width: 80px;
}
#middle {
  padding: 0 80px 0 80px;
}
#footer {
  clear: both;
}

Anmerkungen

• Die Farben und die Höhe der Elemente sind weggelassen, da diese mit der Lösung nichts zu tun haben.
• Die Breite von #header, #middle und #footer passt sich dem zur Verfügung stehenden Raum dynamisch an.
• Die Reihenfolge der divs in HTML ist signifikant. Das div #middle kommt nach #left und #right.
• "clear: both;" bei #header bewirkt, dass neben dem Header kein Float platziert wird. D.h. die beiden Floats #left und #right werden vom Browser darunter platziert.
• Durch "float: left;" wird das Element #left links platziert. Analog wird Element #right durch "float: right;" rechts platziert. Die Breitenangabe "width: 80px;" weist den Floats ihren (fixen) horizontalen Raum am linken und rechten Rand zu.
• Das Element #middle hat keine clear-Angabe und kann daher zwischen die Elemente #left und #right treten. Damit der Inhalt des div sich nicht mit den Randelementen überschneidet, wird mit "padding: 0 80px 0 80px;" ein Padding eingestellt, das den Raum, der von den Randelementen belegt wird, ausspart. Die Reihenfolge der Angaben ist: oben, rechts, unten, links.
• "clear: both;" bei #footer verhindert, dass beim horizontalen Verkleinern des Fensters die oberen Floats neben oder unter den Footer springen.
• Die Konstruktion aus den fünf divs kann in den HTML <body> oder eine Tabellenzelle <td> eigebettet werden.

Das W3C stellt zwei Services zur Validierung von HTML- und CSS-Code zur Verfügung:

HTML-Validator: http://validator.w3.org/
CSS-Validator: http://jigsaw.w3.org/css-validator/

Um den HTML- bzw. CSS-Code einer Seite direkt zu validieren, können folgende Links in die Seite eingebaut werden. Aus dem Referer-Header ermittelt der Validator die Ausgangsseite und ruft diese ab. Das geht natürlich nur, wenn die Seite öffentlich zugreifbar ist.

Validierung von XHTML-Code

<a href="http://validator.w3.org/check/referer?ss=1">
  <img src="valid-xhtml10.png" width="88" height="31" alt="Valid XHTML 1.0!" />
</a>

Der URL-Parameter ss=1 sorgt dafür, dass der Validator ein Source-Listing erzeugt. Dies ist sehr sinnvoll, da dann von einem Fehler aus direkt an die beanstandete Stelle gesprungen werden kann.

Validierung von CSS2-Code

  <a href="http://jigsaw.w3.org/css-validator/check/referer">
    <img src="valid-css2.png" width="88" height="31" alt="Valid CSS!" />
  </a>

PostgreSQL ist meiner Meinung nach das beste frei erhältliche Relationale Datenbanksystem. Hier die wichtigsten Kommandos, um damit an den Start gehen zu können.

PostgreSQL RDBMS installieren (Debian)

# apt-get install postgresql

Zum DB-Admin machen

# su - postgres

Nur von diesem Unix-Account aus kann nach der Installation eine Connection zum DBMS aufgebaut werden.

Liste der existierenden Datenbanken

$ psql -l
[Liste]

Nach der Installation existiert zunächst nur die Datenbank postgres.

Datenbank erzeugen/zerstören

$ createdb DB
...
$ dropdb DB</pre>

Liste der existierenden Benutzer

$ psql
postgres=# \du

oder

postgres=# SELECT rolname FROM pg_roles;

Benutzer anlegen/entfernen

$ createuser USER
Shall the new role be a superuser? (y/n) y
...
$ dropuser USER

Benutzer sind global für alle Datenbanken einer Installation. Zunächst existiert nur der Benutzer postgres. Soll der User USER von einem anderen Account als dem entsprechenden Unix-Account connecten können, muss ein Passwort vergeben werden. Option -P.

Datenbankzugriff

Ist ein DB-User erzeugt, kann dieser vom gleichnamigen Unix-Account oder per Passwort, falls eins vergeben wurde, von einem anderen Account per psql auf die Datenbank zugreifen.

USER$ psql DB
Welcome to psql 8.3.6, the PostgreSQL interactive terminal.
...
DB=#

Liste der existierenden Objekte

Exportieren/Importieren

Session-Einstellungen

Datumsformat

Datumsangaben im Format YYYY-MM-DD

SET datestyle TO iso, ymd
select localtimestamp(0);

liefert die Zeit im Format:

2009-03-12 17:38:20

Zeichensatz

Client arbeitet mit ISO-8859-1:

SET client_encoding TO iso88591

Client arbeitet mit UTF-8:

SET client_encoding TO utf8

Siehe: http://www.postgresql.org/docs/8.3/static/multibyte.html#AEN27449

Der clientseitige Zeichensatz kann jederzeit umgeschaltet werden. Wenn Daten mit unterschiedlichem Encoding verarbeitet werden, besteht die Möglichkeit, vor dem Schreiben auf die Datenbank das clientseitige Encoding umzuschalten. Die Konvertierung wird dann vom Server übernommen.

\-Escapes in Stringliteralen verbieten

SET standard_conforming_strings TO on

Server-Zugriff von externen Hosts

Die folgenden Einträge ermöglichen den Zugriff von allen Hosts für alle User und alle Datenbanken.

In pg_hba.conf oberhalb der anderen Einträge hinzufügen:

# TYPE  DATABASE  USER  CIDR-ADDRESS  METHOD
host    all       all   0.0.0.0/0     md5

In postgresql.conf eintragen:

listen_addresses = '*'

Server neu starten

# /etc/init.d/postgresql-X.Y restart

Upgrade auf eine neue Version

Siehe Kapitel "Upgrading" in der Doku.

<object width="$WIDTH" height="$HEIGHT">
  <param name="movie" value="$URL"></param>
  <param name="allowFullScreen" value="$FS"></param>
  <param name="allowscriptaccess" value="always"></param>
  <embed src="$URL"
      type="application/x-shockwave-flash"
      allowscriptaccess="always"
      allowfullscreen="$FS"
      width="$WIDTH"
      height="$HEIGHT">
  </embed>
</object>

Im Falle eine Standard-Definition Films - wie oben - im Steitenverhältnis 4:3, errechnen sich z.B. folgende Playergrößen:

120 x 115 (klein oben - es wird keine Zeit und kein Slider angezeigt)
160 x 145 (mittel oben - es wird keine Zeit angezeigt)
240 x 205 (groß oben - Fullscreen-Button ist explizit abgeschaltet)
320 x 265 (1. YouTube-Vorschlag)
425 x 344 (2. YouTube-Vorschlag)
480 x 385 (3. YouTube-Vorschlag)
640 x 505 (4. YouTube-Vorschlag)

Favicon hinzugefügt

Zu Datei: templates/default/index.tpl

Homelink2 auf Artikelübersicht geändert

Zu index.php?/archives/summary.html in Datei: templates/default/index.tpl

Die Admin-Oberfläche bietet keine getrennte Einstellung für den eigenen Style - entweder der Haupt-Style ändert den Style der Admin-Oberfläche mit oder es bleibt bei dem (für meinen Geschmack) nicht sonderlich schönen Default.

Die Admin-Styles sind in den Verzeichnissen der Haupt-Styles in templates/STYLE/admin definiert. Die Haupt-Styles, die einen Admin-Style mitbringen, lassen sich folgendermaßen ermitteln:

$ find templates -type d | grep admin$
./carl_contest/admin
./competition/admin
./contest/admin
./bulletproof/admin
./default-rtl/admin
./default/admin

Ein Style, der keinen Admin-Style definiert, kann mit einem fremden Admin-Style ausgestattet werden, indem ein fremdes admin Verzeichnis (eines anderen Style) dorthin kopiert wird oder ein Symlink auf dieses angelegt wird:

$ cd templates/MYSTYLE
$ ln -s ../OTHERSTYLE/admin .

#!/usr/bin/env perl

Mit dieser Shebang-Zeile wird der Perl-Interpreter über die Environment-Variable $PATH gesucht. D.h. die Shebang-Zeile muss nicht angepasst werden, wenn das Skript in mehreren Umgebungen mit unterschiedlichen Installationspfaden laufen soll.

Meine Wahl der Blog-Software ist auf Serendipity gefallen, da ich es neulich positiv erwähnt gefunden habe und meine anschließende Recherche ergeben hat, dass es wohl tatsächlich gut ist.

Als ersten technischen Eintrag schreibe ich auf, wie ich Serendipity from scratch auf meinem Debian Web-Host installiert habe. Zwar gibt es Serendipity auch fix und fertig als Debian-Paket, aber das ist in Debian/Stable schon älter. Außerdem ist diese Anwendung für mich wichtig genug, dass ich alles im Detail kontrollieren möchte, einschließlich programmierung, und keinesfalls will, dass die Debian-Paketverwaltung mir mit Updates dazwischen kommt.

Homepage von Serendipity: http://www.s9y.org/

Schritt 1: Herunterladen der Software

Auf der Homepage bekommt man die aktuelle Version als Tarball und auch eine Beschreibung für die manuelle Installation. Diese hat den Titel Fresh Installation. Sie ist gut, aber in einigen Punkten nicht ausführlich genug. Ich beschreibe hier die Dinge, die ich bei meiner Installation dort nicht gefunden habe.

Schritt 2: Auspacken des Pakets

Das Paket, in meinen Fall serendipity-1.5.1.tar.gz, kann irgendwo im Dateisystem ausgepackt werden. In der Webserver-Konfiguration wird später mitgeteilt, wo es sich befindet. Ich entscheide mich als Installationsort für /opt/serendipity/1.5.1/.

Schritt 3: Benötigte Debian-Pakete installieren

# deb-install php5
# apt-get install postgresql
# apt-get install php5-pgsql
# apt-get install imagemagick

Serendipity ist in PHP5 programmiert. Als DBMS verwende ich PostgreSQL. Imagemagick wird von Serendipity zur Bildbearbeitung gebraucht.

Schritt 4: Apache Konfiguration

Im Serendipity-Paket scheint keine Apache-Config dabei zu sein. Ich habe diese von der Debian-Version übernommen, mit der ich zuvor herumgespielt habe. Lediglich die Pfade brauchte ich anpassen. Der URL des Blog wird http://SERVER.DOMAIN/blog lauten.

Alias /blog /opt/serendipity/1.5.1

<Directory /opt/serendipity/1.5.1>
        Options -Indexes +FollowSymlinks

        DirectoryIndex index.php

        <IfModule mod_php5.c>
        php_flag session.use_trans_sid off
        php_flag register_globals off
        </IfModule>

        AllowOverride All
        order allow,deny
        allow from all

        <Files *.tpl.php>
            deny from all
        </Files>

        <Files *.tpl>
            deny from all
        </Files>

        <Files *.sql>
            deny from all
        </Files>

        <Files *.inc.php>
            deny from all
        </Files>

        <Files *.db>
            deny from all
        </Files>
</Directory>

Die Datei wird als serendiptiy.conf nach /etc/apacha2/conf.d kopiert und anschließend der Apache neu gestartet:

# apache2ctl restart

Schritt 5: PostgreSQL-Datenbank einrichten

Für die Datenbank-Einrichtung sind drei Dinge zu tun:

1. Datenbank erzeugen
2. Datenbank-User erzeugen, über den Serendipity auf die Datenbank zugreift
3. Datenbanknamen und User und Passwort in die Serendipity-Config eintragen

Datenbank und User erzeugen:

# su - postgres
$ createdb serendipity
$ createuser -P serendipity
Password:

Wichtig ist bei creatuser der Parameter -P, damit der User ein Passwort erhält.

Schritt 6: Konfiguration und Administration von Serendipity

Anschließend auf http://SERVER.DOMAIN/blog/serendipity_admin.php gehen und die Datenbank-Angaben in die Formularfelder eintragen

Bei Anmeldeaufforderung per "John Doe" mit Passwort "john" anmelden. Benutzername und Passwort sollten nach der Anmeldung als erstes geändert werden. Danach kann Serendipity im Detail den persönlichen Wünschen angepasst werden.

Ich habe beschlossen, ein Technik Logbuch zu führen, in welchem ich meine Erkenntnisse aufschreibe. Primär als Nachschlagewerk zur eigenen Erinnerung, aber auch als mögliche Hilfe für andere. Ich selbst schlage meist zuerst im Web nach, wenn ich auf eine Fragestellung oder ein Problem stoße und oft ist etwas darunter, was mir schnell weiter hilft. Dies soll mein bescheidener Beitrag zur Wissensweitergabe im Zeitalter des Internet sein.