Stockbrot mit Speck und Röstzwiebeln

1. Zutaten

500g Weizenmehl
250ml lauwarmes Wasser
50ml Öl
1 Würfelhefe
1 Prise Salz
1 Prise Zucker
Speck und Röstzwiebeln nach belieben (Tipp: Viel hilft viel xD)

2. Zubereitung

Mehl, Hefe, Salz, Zucker in einer Schüssel kurz vermischen. Dann das Öl und Wasser dazugeben und ordentlich durch kneten. Zum Schluss dann den Speck und die Röstzwiebeln unterheben.

Stockbrot mit Speck und Röstzwiebeln

Stockbrot mit Speck und Röstzwiebeln

Veröffentlicht unter Sonstiges | Verschlagwortet mit , | 1 Kommentar

Grails: Fremdschlüsselerzeugung durch Hibernate unterdrücken

In meinem aktuellen Grails-Projekt lasse ich die Datenbank nicht von Grails (Hibernate) erstellen, sondern habe diese selbst erzeugt. In meinem Datenbankmodell sind alle notwendigen Fremdschlüsselbeziehungen und Indizes bereits enthalten. Trotzdem versucht Hibernate immer eigene Fremdschlüsselbeziehungen anzulegen. Diese haben nicht nur nichtssagende Namen wie z.B. „FK79D00A76C682495E“ sondern sind auch schlicht redundant.

Um in einem Grails-Projekt Hibernate daran zu hindern eigene Fremdschlüsselbeziehungen anzulegen, muss eine „GrailsAnnotationConfiguration“-Klasse erstellt und eingebunden werden.

  1. public class PreventForeignKeyCreation extends GrailsAnnotationConfiguration {
  2.    private boolean _alreadyProcessed;
  3.    @SuppressWarnings({ "unchecked", "rawtypes" })
  4.    @Override
  5.    protected void secondPassCompile() throws MappingException {
  6.       super.secondPassCompile();
  7.       if (_alreadyProcessed) { return; }
  8.       for (PersistentClass pc : (Collection) classes.values()) {
  9.          if (pc instanceof RootClass) {
  10.             RootClass root = (RootClass) pc;
  11.             //Hier muss die Domainklasse, welche den Fremdschlüssel erzeugt eingetragen werden.
  12. 	    if ("mein.packet.MeineDomainKlasse".equals(root.getClassName())) {
  13.                for (Iterator iter = root.getTable().getForeignKeyIterator(); iter.hasNext();) {
  14.                   ForeignKey fk = (ForeignKey) iter.next();
  15.                   //Hier muss der Name des bereits existierenden Fremdschlüssels eingetragen werden.
  16.                   fk.setName("existierender_fremdschlüssel");
  17.                }
  18.             }
  19.          }
  20.       _alreadyProcessed = true;
  21.    }
  22. }

Diese Klasse muss dann in der DataSource.groovy z.B. wie folgt eingebunden werden

  1. environments {
  2.    development {
  3.       dataSource {
  4.          ..
  5.          configClass = 'mein.packet.PreventForeignKeyCreation'
  6.          ..
  7.       }
  8.    }
  9. }
Veröffentlicht unter Grails, Hibernate | Verschlagwortet mit , | Hinterlasse einen Kommentar

Grails, PostgreSQL und Enums

Momentan bin ich dabei eine Webanwendung mit Grails zu bauen. In der dieser Webanwendung zu grunde liegenden Datenbank (PostgreSQL), habe ich eigene Datentypen in Form von Enums erstellt. Zum Beispiel den folgenden:

  1. CREATE TYPE public.payment_method AS
  2. ENUM ('CASH','CASH_CARD');

Nachdem der Enum auch in der Webanwendung erstellt wurde,

  1. public enum PaymentMethods {
  2.    cash, cash_card
  3. }

wollte ich diesen dann in Grails wie folgt einbinden.

  1. class Invoice {
  2.    static mapping = {
  3.    ..
  4.    paymentMethod column: 'payment_method'
  5.    ..
  6.    }
  7.    PaymentMethods paymentMethod
  8. }

Doch ich bekam folgende Fehlermeldung:

FEHLER: Spalte »payment_method« hat Typ payment_method, aber der Ausdruck hat Typ character varying Hinweis: Sie müssen den Ausdruck umschreiben oder eine Typumwandlung vornehmen.

Mit den standard Typen wie String, Integer oder Date kann Grails umgehen, mit einem Enum anscheinend jedoch nicht. Ein Blick in die Grails-Dokumentation offenbart folgendes:

GORM supports configuration of Hibernate types with the DSL using the type attribute. This includes specifing user types that implement the Hibernate org.hibernate.usertype.UserType interface, which allows complete customization of how a type is persisted.

Nach kurzer Zeit stieß ich auf ein Beispiel für die Implementierung eines eigenen UserTypes. Doch da ich mehrere Enums benutze und nicht für jeden Enum eine extra UserType-Klasse definieren wollte, suchte ich weiter. Die Antwort fand ich dann auf diesem Blog. Dort wird erklärt wie ein parametrisierten UserType erstellt wird. Durch die Mischung beider Beispiele entstand die folgende Klasse, die es ermöglicht in Grails mit verschiedenen Enums zu arbeiten.

  1. public class PGEnumUserType implements UserType, ParameterizedType {
  2.    private static final SQL_TYPES = [Types.VARCHAR] as int[]	
  3.    private Class enumClass;	
  4.    @Override
  5.    public void setParameterValues(Properties parameters) {
  6.       String enumClassName = parameters.getProperty("enumClassName")
  7.       try { enumClass = (Class) Class.forName(enumClassName) }
  8.       catch (ClassNotFoundException cnfe) { throw new HibernateException("Enum class not found", cnfe) }
  9.    }
  10.    @Override
  11.    public Object assemble(Serializable cached, Object owner) throws HibernateException { return cached }
  12.    @Override
  13.    public Object deepCopy(Object value) throws HibernateException { return value }
  14.    @Override
  15.    public Serializable disassemble(Object value) throws HibernateException { return value }
  16.    @Override
  17.    public boolean equals(Object x, Object y) throws HibernateException { return x.equals(y) }
  18.    @Override
  19.    public int hashCode(Object x) throws HibernateException { return x.hashCode() }
  20.    @Override
  21.    public boolean isMutable() { return false }
  22.    @Override
  23.    public Object nullSafeGet(ResultSet rs, String[] names, Object owner) throws HibernateException, SQLException {
  24.       def result = rs.getObject(names[0]);
  25.       if (result) { return Enum.valueOf(enumClass, (String) result) }
  26.       else { return null }
  27.    }
  28.    @Override
  29.    public void nullSafeSet(PreparedStatement st, Object value, int index) throws HibernateException, SQLException {
  30.       if (value) { st.setObject(index, ((Enum)value), 1111); }
  31.       else { st.setNull(index, Types.VARCHAR) }
  32.    }
  33.    @Override
  34.    public Object replace(Object original, Object target, Object owner) throws HibernateException { return original }
  35.    @Override
  36.    public Class returnedClass() { return enumClass }
  37.    @Override
  38.    public int[] sqlTypes() { return SQL_TYPES }
  39. }

Jetzt muss diese Klasse nur noch in Grails eingebunden und das zu verwendende Enum übergeben werden:

  1. class Invoice {
  2.    static mapping = {
  3.    ..
  4.    paymentMethod column: 'payment_method', type: PGEnumUserType, params : [ enumClassName: "package.PaymentMethods"]
  5.    ..
  6.    }
  7.    PaymentMethods paymentMethod
  8. }

Jetzt kann Grails mit Enums arbeiten.

Veröffentlicht unter Grails, Hibernate, PostgreSQL | Verschlagwortet mit , | Hinterlasse einen Kommentar

PostgreSQL und WordPress

Offiziell unterstützt WordPress nur die MySQL-Datenbank. Dies hat mich sehr geärgert, da ich vor hatte komplett auf PostgreSQL umzusteigen. Nach kurzer Zeit stieß ich dann auf das Plugin PostgreSQL for WordPress (PG4WP), welches auch sehr gut funktioniert.

Leider funktioniert (zumindest bei mir)  das Plugin nicht mit der aktuellen WordPress-Version 3.7.1 .

Veröffentlicht unter Plugins, PostgreSQL | Verschlagwortet mit , | Hinterlasse einen Kommentar

pgModeler

Vor kurzem bin ich komplett auf PostgreSQL umgestiegen. Auf der Suche nach einem geeigneten Programm um Entity-Relationship-Diagramm zu modellieren, stieß ich auf pgModeler.

Mit pgModeler lassen sich ER-Diagramme erstellen, die direkt auf einen Datenbankserver oder als PNG- sowie SQL-Datei exportiert werden können.

pgModeler

Screenshot von pgModeler

pgModeler sieht schick aus und bietet eine intuitive Benutzeroberfläche. Momentan befindet sich pgModeler in der Version 0.6.1 und läuft nicht immer stabil, daher empfiehlt es sich öfter mal abzuspeichern. Da die Informationen über die ER-Diagramme in einer XML-Datei abgelegt werden, ist das Wiederherstellen von Dateien, die bei einem Programmcrash zerstört wurden, möglich.

Veröffentlicht unter pgModeler, PostgreSQL | Verschlagwortet mit , | Hinterlasse einen Kommentar

ejabberd mit ICQ-Transport

1. Installation
Zunächst einmal muss ejabberd installiert werden.

sudo apt-get install ejabberd

Danach muss ejabberd konfiguriert werden.

sudo dpkg-reconfigure ejabberd

Bei diesem Schritt muss zunächst der Servername inklusive der Domain angegeben werden (z.B. jabber.pascalkrause.info oder pascalkrause.info). Danach wird eine Jabber-ID angelegt, welche administrative Rechte erhält. Jetzt sollte man ejabberd neustarten.

sudo /etc/init.d/ejabberd restart

2. Portfreigabe und SRV-Records
Folgende Ports müssen freigegeben werden:

  • 5222 eingehend, für Client-Verbindungen unverschlüsselt oder TLS-verschlüsselt
  • 5269 ein- und ausgehend, für Verbindungen zu anderen Servern
  • 5280 eingehend, für Client-Verbindungen über HTTP-Polling (nützlich für Webapplikationen)

Zusätzlich zu der Freitschaltung der Ports müssen im DNS die SRV-Records eingetragen werden. Ein Beispiel dafür, wie diese Records aussehen könnten ist hier.

  1. _jabber._tcp.pascalkrause.info.       IN SRV   0 0 5269   pascalkrause.info.
  2. _xmpp-server._tcp.pascalkrause.info.  IN SRV   0 0 5269   pascalkrause.info.
  3. _xmpp-client._tcp.pascalkrause.info.  IN SRV   0 0 5222   pascalkrause.info.

Wenn der Hostname von der Adresse der JID abweichend ist, muss aufgrund eines Bugs in Debian Wheezy die ejabberd.cfg um folgende Zeile ergänzt werden.

  1. {fqdn, "xmpp.pascalkrause.info"}.

3. ejabberd konfigurieren /etc/ejabberd/ejabberd.cfg
Wenn man nicht möchte, das sich fremde Leute am eignen Jabber-Server registrieren können, sollte die ejabberd.cfg so aussehen.

  1. % Every username can be registered via in-band registration:
  2. %{access, register, [{allow, all}]}.
  3.  
  4. % None username can be registered via in-band registration:
  5. {access, register, [{deny, all}]}.

Außerdem ist es z.B. möglich, die Admin-Oberfläche auf einen anderen Port zu legen und an ein bestimmtes Device zu binden. Um die Admin-Oberfläche von Port 5280 auf Port 5288 zu verschieben und an localhost zu binden, müsste man z.B. die Zeile

  1. {5280, ejabberd_http,    [http_poll, web_admin]}

in folgende Zeilen abändern:

  1. {5280, ejabberd_http,    [http_poll]},
  2. {5288, ejabberd_http,    [{ip, {127, 0, 0, 1}}, web_admin]}

4. Benutzer verwalten und sichern
Da ich eingestellt habe, dass sich niemand an meinem Jabber-Server anmelden kann, muss ich alle Accounts von Hand einrichten. Dies geht mit folgenden Befehlen:

#Benutzer hinzufügen
sudo ejabberdctl register Benutzername Servername Passwort
#Benutzer löschen
sudo ejabberdctl unregister Benutzername Servername

Um nicht jedesmal alle Benutzer erneut eingeben zu müssen, kann man diese auch Backupen. Dies geschieht mit den Befehlen

#Sicherung anlegen
sudo ejabberdctl backup pfadZurDatei
#Sicherung wiederherstellen
sudo ejabberdctl restore pfadZurDatei

Achtung! ejabberdctl immer nur als root ausführen, sonnst kann es zu Problemen kommen.

5. ICQ-Transport mit Pyicqt einrichten
Auch hier muss zunächst einmal erst pyicqt installiert werden.

apt-get install pyicqt

Danach müssen in der Datei /etc/pyicqt.conf.xml folgende Tags befüllt werden:

  • <jid> z.B. mit icq.pascalkrause.info
  • <mainServer> z.B. mit 127.0.0.1
  • <mainServerJID> z.B. mit pascalkrause.info
  • <port> z.B. mit 5555
  • <secret> z.B. mit foobar

Der Port und das Secret müssen auch in der ejabberd.cfg eingestellt werden. Dies könnte so aussehen:

  1.   {5555, ejabberd_service, [
  2.                             {ip, {127, 0, 0, 1}},
  3.                             {access, all},
  4.                             {shaper_rule, fast},
  5.                             {hosts, ["icq.pascalkrause.info", "sms.pascalkrause.info"],
  6.                                        [{password, "foobar"}]}
  7.                             ]},

Es ist gut möglich, dass dieser Eintrag bereits in eurer ejabberd.cfg existiert. Dann muss er nur auskommentiert und angepasst werden.
Achtung: In Debian gibt es einen Bug, pyicqt hat keine Schreibrechte im Ordner /var/lib/pyicqt diese müsst ihr per Hand setzen.

Veröffentlicht unter ejabberd, Programme | 1 Kommentar

Apache und JBoss auf Port 80

Normalerweise läuft das Webinterface von JBoss auf Port 8080. Oftmals sitzt man aber hinter einer Firewall die alle Ports außer Port 80 blockiert. Da Port 80 aber meist von einem Apache belegt ist, können wir im JBoss nicht einfach Port 80 als neuen Port für das Webinterface einstellen. Wir müssen Port 8080 auf Port 80 tunneln. Die Lösung dafür lautet mod_proxy.

Es bedarf nur vier Schritte um, euren JBoss unter einer Subdomain erreichbar zu machen.

1. Schritt : Installiere Apache2 und JBoss

2. Schritt : Lade benötigte Apachemodule

sudo a2enmod proxy
sudo a2enmod proxy_http
sudo a2enmod vhost_alias

3. Schritt : Erstelle Datei /etc/apache2/sites-available/jboss und Schreibe in die Datei folgenden Inhalt:

  1.       # Hier eure Server IP
  2.         ServerName jboss.pascalkrause.info # Hier eure Subdomain
  3.         ProxyRequests Off
  4.  
  5.                 Order deny,allow
  6.                 Allow from all
  7.  
  8.         ProxyPreserveHost on
  9.         ProxyPass / http://localhost:8080/
  10.         ProxyPassReverse / http://localhost:8080/

4. Schritt : Aktiviere den vHost und starte Apache neu

sudo a2ensite jboss

Wenn ihr Plesk benutzt,
müsst ihr keine Datei anlegen und den vHost aktivieren. Ladet die Module und legt eine Subdomain an. In meinem Fall war dies jboss.pascalkrause.info. Plesk legt automatisch eine Konfigurationsdatei an, welche ihr unter

/var/www/vhosts/{eure Subdomain}/conf/xxxx.include

findet. In diese fügt ihr den Inhalt von Schritt 3 ein. Nun muss nur noch Apache neugestartet werden.

Probleme mit der JBoss-Admin-Console
Leider Funktioniert dies nicht mit der Admin-Console, es scheint ein Bug im aktuellen JBoss AS 7.1.1 zu sein. Ich hoffe bei der nächsten JBoss-AS Version wird dieses Problem gefixxt sein.

Veröffentlicht unter Apache, JBoss, Programme | Verschlagwortet mit , | Hinterlasse einen Kommentar

Mediatasten mit MATE und Debian Wheezy

Seit kurzem bin ich von Cinnamon auf MATE umgestiegen, da der Stromverbrauch von Cinnamon so hoch war, dass meinen Akku bereits nach zwei Stunden in die Knie gezwungen wurde.

Leider funktionierten unter MATE die Mediatasten meiner Tastatur (Logitech Illuminated) nicht. Hier mein Trick, wie ich die Tasten dennoch nutzen konnte.

Zunächst habe ich mit dem Befehl xev geprüft, ob das System die Tasten überhaupt erkennt. Dies war wie zu erwarten der Fall. Danach habe ich einfach drei folgenden Tastenkombinationen in MATE angelegt:

  • Clementine-Play-Pause : clementine –play-pause
  • Clementine-Next : clementine –next
  • Clementine-Previous : clementine –previous

mediakeys

Dies funktioniert auch mit Banhsee.

  • Banhsee-Play-Pause : banhsee –toggle-playing
  • Banhsee-Next : banhsee –next
  • Banhsee-Previous : banhsee –previous

Beim VLC Player ist dies nicht so einfach möglich, da dieser nur auf Umwegen Befehle über die Kommandozeile annimmt. Bei Interesse sollte man vielleicht mal hier vorbeischauen.

Veröffentlicht unter Clementine, Debian, Mate | Hinterlasse einen Kommentar

Syntax-Highlighting in WordPress

Als ich meinen ersten Artikel mit Sourcecode veröffentlichen wollte, fehlte mir ein Plugin, welches meinen Sourcecode hervorhebt.

Okay, Syntax-Highlighting hab ich schon in unzähligen WordPress-Blocks gesehen, das kann doch nicht schwer sein…

Aus der auf fünf Minuten geschätzen Aktion wurden zwei Stunden… Zuerst musste ich mich durch die gefühlten 9001 verschiedenen Syntax-Plugins kämpfen. Ich fand zwei Plugins von denen ich glaubte, dass sie meinen Ansprüchen gerecht werden.

  • SyntaxHighlighter Evolved
  • WP-Syntax

Bei SyntaxHighlighter Evolved gab es in den Einstellungen einen Punkt, bei dem ich das Farbschema auswählen konnte, zu meiner Freude tauchte die Option Eclipse auf. Ich prüfte das Highlighting, alles schien perfekt. Doch dann bemerkte ich, dass das Highlighting nur mit aktivem JavaScript funktioniert. Da ich aber ein Freund von NoScript bin und Seiten nur im äußersten Notfall JavaScript ausführen lasse, testete ich WP-Syntax.

Zunächst war ich verärgert, da WP-Syntax keine Einstellung zur Auswahl des Farbschemas anbietet, jedoch funktioniert WP-Syntax auch ohne aktivem JavaScript.

Mit dem Plugin WP-Syntax Colorizer (krasser Name ;-)), kann man sich ein individuelles Farbschema zusammen stellen. Dazu muss die Datei wp-syntax_colorizer.php (Plugins -> WP-Syntax Colorizer -> Bearbeiten) bearbeitet werden. Ich habe versucht ein Farbschema zu erstellen, welches sich so gut es mir möglich war an Eclipse orientiert.

WP-Syntax Beispiel

Hier mein Eintrag in der wp-syntax_colorizer.php.

function my_custom_geshi_styles(&$geshi) {
$geshi->set_overall_style("color: black;", true);

$geshi->set_keyword_group_style(1, „color: #7F0055;“, true);
$geshi->set_keyword_group_style(2, „color: #7F0055;“, true);
$geshi->set_keyword_group_style(3, „color: blue;“, true);
$geshi->set_keyword_group_style(4, „color: #7F0055;“, true);

$geshi->set_symbols_style(„color: black;“, true);
$geshi->set_methods_style(1, „color: black;“, true);
$geshi->set_regexps_style(1, „color: black;“, true);

$geshi->set_strings_style(„color: #2A00FF;“, true);
$geshi->set_numbers_style(„color: #F36E00;“, true);

$geshi->set_comments_style(1, „color: #3F7F5F;“, true);
$geshi->set_comments_style(‚MULTI‘,“color: #3F7F5F;“, true);
}

Veröffentlicht unter Plugins, Wordpress | 1 Kommentar

String in andere Zeichensätze konvertieren

Man will es kaum glauben, aber auch im Jahr 2013 gibt es noch so etliche Web-Anwendungen die mit ISO-8859-15 arbeiten.

Dies kann beim Arbeiten mit Java zu Problemen führen, da Java Strings intern mit UTF-16 verarbeitet. Es ist ratsam diese Strings erst einmal in UTF-8 oder UTF-16 zu konvertieren. Der folgende Beispielcode zeigt wie.

  1. static public String convertToCharset(String stringToConvert, String targetCharset) {
  2.         Charset charset = Charset.forName(targetCharset);
  3.         byte[] temp = stringToConvert.getBytes(charset);
  4.         return new String(temp, charset);
  5. }

Hier ist eine Auswahl an möglichen Parametern für den Parameter „targetCharset“:

  • ISO-8859-15
  • US-ASCII
  • UTF-8
  • UTF-16
Veröffentlicht unter Java | Hinterlasse einen Kommentar