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
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.
public class PreventForeignKeyCreation extends GrailsAnnotationConfiguration {
private boolean _alreadyProcessed;
@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
protected void secondPassCompile() throws MappingException {
super.secondPassCompile();
if (_alreadyProcessed) { return; }
for (PersistentClass pc : (Collection) classes.values()) {
if (pc instanceof RootClass) {
RootClass root = (RootClass) pc;
//Hier muss die Domainklasse, welche den Fremdschlüssel erzeugt eingetragen werden.if ("mein.packet.MeineDomainKlasse".equals(root.getClassName())) {
for (Iterator iter = root.getTable().getForeignKeyIterator(); iter.hasNext();) {
ForeignKey fk = (ForeignKey) iter.next();
//Hier muss der Name des bereits existierenden Fremdschlüssels eingetragen werden.fk.setName("existierender_fremdschlüssel");
} } }_alreadyProcessed = true;
}}Diese Klasse muss dann in der DataSource.groovy z.B. wie folgt eingebunden werden
environments { development { dataSource {..
configClass = 'mein.packet.PreventForeignKeyCreation'
..
} }}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:
CREATE TYPE public.payment_method AS
ENUM ('CASH','CASH_CARD');
Nachdem der Enum auch in der Webanwendung erstellt wurde,
public enum PaymentMethods {
cash, cash_card
}wollte ich diesen dann in Grails wie folgt einbinden.
class Invoice {
static mapping = {
..
paymentMethod column: 'payment_method'
..
}PaymentMethods paymentMethod
}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.
public class PGEnumUserType implements UserType, ParameterizedType {
private static final SQL_TYPES = [Types.VARCHAR] as int[]
private Class enumClass;
@Override
public void setParameterValues(Properties parameters) {
String enumClassName = parameters.getProperty("enumClassName")
try { enumClass = (Class) Class.forName(enumClassName) }
catch (ClassNotFoundException cnfe) { throw new HibernateException("Enum class not found", cnfe) }
}@Override
public Object assemble(Serializable cached, Object owner) throws HibernateException { return cached }
@Override
public Object deepCopy(Object value) throws HibernateException { return value }
@Override
public Serializable disassemble(Object value) throws HibernateException { return value }
@Override
public boolean equals(Object x, Object y) throws HibernateException { return x.equals(y) }
@Override
public int hashCode(Object x) throws HibernateException { return x.hashCode() }
@Override
public boolean isMutable() { return false }
@Override
public Object nullSafeGet(ResultSet rs, String[] names, Object owner) throws HibernateException, SQLException {
def result = rs.getObject(names[0]);
if (result) { return Enum.valueOf(enumClass, (String) result) }
else { return null }
}@Override
public void nullSafeSet(PreparedStatement st, Object value, int index) throws HibernateException, SQLException {
if (value) { st.setObject(index, ((Enum)value), 1111); }
else { st.setNull(index, Types.VARCHAR) }
}@Override
public Object replace(Object original, Object target, Object owner) throws HibernateException { return original }
@Override
public Class returnedClass() { return enumClass }
@Override
public int[] sqlTypes() { return SQL_TYPES }
}Jetzt muss diese Klasse nur noch in Grails eingebunden und das zu verwendende Enum übergeben werden:
class Invoice {
static mapping = {
..
paymentMethod column: 'payment_method', type: PGEnumUserType, params : [ enumClassName: "package.PaymentMethods"]
..
}PaymentMethods paymentMethod
}Jetzt kann Grails mit Enums arbeiten.
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 .
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.
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.
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:
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.
_jabber._tcp.pascalkrause.info. IN SRV 0 0 5269 pascalkrause.info.
_xmpp-server._tcp.pascalkrause.info. IN SRV 0 0 5269 pascalkrause.info.
_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.
{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.
% Every username can be registered via in-band registration:%{access, register, [{allow, all}]}.% None username can be registered via in-band registration:{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
{5280, ejabberd_http, [http_poll, web_admin]}
in folgende Zeilen abändern:
{5280, ejabberd_http, [http_poll]},
{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:
Der Port und das Secret müssen auch in der ejabberd.cfg eingestellt werden. Dies könnte so aussehen:
{5555, ejabberd_service, [
{ip, {127, 0, 0, 1}},
{access, all},
{shaper_rule, fast},
{hosts, ["icq.pascalkrause.info", "sms.pascalkrause.info"],
[{password, "foobar"}]}
]},
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.
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:
# Hier eure Server IP
ServerName jboss.pascalkrause.info # Hier eure Subdomain
ProxyRequests Off
Order deny,allow
Allow from all
ProxyPreserveHost on
ProxyPass / http://localhost:8080/ 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.
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:
Dies funktioniert auch mit Banhsee.
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.
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.
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.
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);
}
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.
static public String convertToCharset(String stringToConvert, String targetCharset) {
Charset charset = Charset.forName(targetCharset);
byte[] temp = stringToConvert.getBytes(charset);
return new String(temp, charset);
}Hier ist eine Auswahl an möglichen Parametern für den Parameter „targetCharset“:
