eleon

Cloud Foundry von vmware

2011-08-01T11:22:11Z

Nachdem die erste Version der vmware Cloud Foundry noch eine Deployment Umgebung für die Amazon AWS Cloud Plattform war, steht seit einiger Zeit die neue Cloud Foundry als Beta-Version zur Verfügung.

Java, Spring, Grails und Rails Entwickler können hier ihre Anwendungen in kürzester Zeit in der Cloud veröffentlichen.

Das Vorgehen ist denkbar bequem:

Developer Zugang anfordern
Command Line Tool oder Springsource ToolSuite Plugin installieren (wir nutzen die Spring Source Toolsuite sowie das Spring Roo Cloud Foundry Addon)
Service registrieren (MySQL, Mongo DB oder Redis)
Anwendung deployen und an den Service binden

Alles ist äußerst komfortabel, den Beta-Zustand merken wir (bisher) nur daran, dass manche commands nicht laufen - diese ließen sich jedoch immer über workarounds umgehen.

Als Test lassen wir derzeit eine Demo-Version unserer Open Source Software Timejoe laufen, die unter folgender URL aufgerufen werden kann:

timejoe.cloudfoundry.com

Sollte einer der User-Accounts gerade nicht gehen, hat wohl ein anderer Tester die Zugangsdaten verändert. Nach dem nächsten Restart werden die Daten wieder zurückgesetzt. Sollten Sie es eilig haben, senden Sie uns einfach kurz eine Mail dann setzen wir die Anwendung direkt zurück.

Zusammengefasst: einfacher kann das Deployment von Spring oder Spring Grails Applikationen in eine Cloud wirklich nicht sein. Wir sind gespannt auf das Ende der Beta-Phase und die Preisstruktur für größere Produktivanwendungen.

Active Records in Grails

2011-07-28T21:02:28Z

Grails folgt ja für die Domain Klassen dem Active Record Pattern. Das Scaffolding, also das Generieren von Controllern und Views verleitet dann gerne dazu, frühzeitig in die View-Schicht zu gehen. Also Folge bekommen die Controller zu viel Verantwortlichkeiten und übernehmen große Teile der Business Logik - ggf. wird dann noch mal in die Serviceschicht ausgelagert, aber die Domains bleiben weitgehend anämisch (Anemic Domain Model), eigentlich ein Anti-Pattern.

Grails unterstützt jedoch das Active Record Pattern mit weit mehr, als nur die Domainklassen um Validatoren, dynamische Finder und Persistenzmethoden auszustatten. Besonders hilfreich sind u.A. die GORM Events bei Inserts, Updates und Deletes. Anstatt z.B. das User-Passwort im Controller zu encoden, kann dies auch die User-Domainklasse automatisch übernehmen:

def beforeInsert() { 
	encodePassword()
} 

def beforeUpdate() { 
	if (isDirty('password')) 
		encodePassword()
}

private void encodePassword() {
	password = springSecurityService.encodePassword(password)
}

Die Methoden beforeInsert() und beforeUpdate() werden automatisch als Events für die jeweiligen GORM Operationen registriert. Damit ist sichergestellt, dass das Passwort immer encoded in die Datenbank geschrieben wird und dies nicht in irgendeinem Controller vergessen werden kann. Zudem lassen sich Domain-Klassen sehr viel einfacher und schneller testen, als Controller und Views (zumindest bis einschließlich Grails 1.3.7 - die 2.0 Version wird hier sicher einen riesigen Fortschritt bringen).

Bei Methoden die dem Java Beans Naming Standard folgen, werden entsprechende properties abgeleitet (und somit auch persistiert). Hat man z.B. eine Methode

public float getPriceWithTax() {
	return this.price * 1.19F
}

muss man daran denken, diese als nicht zu speichernde property zu deklarieren:

static transients = ['priceWithTax']

Bei der Entscheidung, was in die Domainklasse und was in die Serviceschicht gehört folgen wir der einfachen Regelung, jegliche Businesslogik die nur eine Domain betrifft in der Domain und Businesslogik die mehrere Domains betrifft in der Serviceschicht zu implementieren. Wir haben damit recht gute Erfahrungen gemacht und es erscheint es uns natürlicher, Methoden direkt auf einem Objekt und nicht auf der Serviceschicht mit dem Objekt als Parameter aufzurufen.

Einfache Shutdown-Message mit Grails

2011-07-28T09:50:35Z

Wie informiert man User über Updates, damit sie rechtzeitig speichern und das Browserfenster schließen? Manchmal muss ein Update ja auch sehr schnell in Produktion gebracht werden und man kann nicht auf die regulär geplanten Wartungsfenster zurückgreifen. Eine zugegebenermaßen einfache, aber meist ausreichende Lösung geht wie folgt:

In src/groovy erstellt man eine Klasse mit einem statischen leeren String. Diese Klasse könnte wie folgt aussehen:

class ShutdownMessage {
	private static String message = ""
	[...]getter und setter[...]
}

Über einen Controller ermöglicht man admins, den String zu ändern. Hier kann der Admin dann seinen Text eingeben, z.B. "Das System wird um 18 Uhr wegen Wartungsarbeiten für 15 min. nicht zur Verfügung stehen.". Dieser Teil dürfte klar sein und wird hier daher nicht mit einem Code-Beispiel unterfüttert.

Letzter Teil ist eine kleine Taglib mit der Ausgabe der Meldung, z.B. wie folgt:

class ShutdownMessageTagLib {
	static namespace = "eleon"
	def message = {
		if (ShutdownMessage.getMessage() != "") {
			out << """
				<div class="errors top">
					${ShutdownMessage.getMessage()}
				</div>
			"""
		}
	}
}

Den Tag dann nur noch in views/layouts/main.gsp einbinden:

<eleon:message />

Gibt der Admin nun eine Nachricht ein, wird diese den Usern angezeigt. Nach einem Neustart ist der message-String wieder leer und somit erscheint auch keine Nachricht mehr.

Die Nachricht wird natürlich nur nach einem Reload gezeigt, also wenn der User durch die Seite navigiert oder ein Formular abschickt. Hat man eine Anwendung, auf der die User sehr lange quasi inaktiv sind (z.B. einen längeren Text eingeben) könnte man die o.g. Taglib auch erweitern und die Systemmeldung in regelmäßigen Abständen per AJAX erfragen. Es würde sich anbieten, den User auch gleich auf bevorstehende Timeouts hinzuweisen.

Keine große Sache, aber mit wenig Aufwand eingebaut und man hat damit doch ein besseres Gefühl bei ungeplanten Wartungsarbeiten, als wenn man die User einfach so mit einem Neustart überfällt.

Open Source Zeiterfassung

2011-06-25T19:14:44Z

Zeiterfassung für Dienstleister, essentiell für Projektcontrolling, Dokumentation und Abrechnung, führt aber selten zu Begeisterung im Projektteam. Die meisten der diversen, am Markt befindlichen Zeiterfassungs-Lösungen haben wir durchgetestet und die für uns passende Lösung nicht gefunden.

Wenn schon die Zeiterfassung an sich keinen großen Spaß macht, sollte das doch zumindest die Software mit der man arbeitet tun. Wir haben daher eine Lösung nach unseren Vorstellungen entwickelt und als Open Source Projekt unter der Apache 2 Lizenz veröffentlicht. Jeder ist eingeladen, unsere Zeiterfassungs-Software zu nutzen und falls erforderlich zu erweitern oder auf die eigenen Bedürfnisse anzupassen.

Liferay Update von Version 5.2 auf Version 6 / Fehlende Bilder

2011-06-03T09:54:47Z

Update nach Dokumentation

Ein Update von Liferay in der Version 5.2 auf Version 6 kann ein nervenaufreibendes Abenteuer werden. Nicht zuletzt aufgrund der unzähligen unterschiedlichen Dokumentationen und Anleitungen. Grundsätzlich sollte man den Anweisungen aus dem Administrationshandbuch folgen. Das bedeutet:

neue und aktuelle Liferay-Installation neben alter Installation aufsetzen
alle Standalone-Portlets aus webapps/ löschen
Zugang zur Datenbank mit alten Daten einrichten
data/ Ordner aus alter Installation in neue kopieren
in bin/setenv.bat/sh folgenden Parameter mit aufnehmen -Dexternal-properties=portal-legacy-5.2.properties
Liferay jetzt erstmalig starten

Liferay nimmt nun automatisch das Update der Datenbank und des Rechtesystems vor. Danach sollte man seine Installation rudimentär testen (Insbesondere Rechte und Bilder). Läuft alle ordnungsgemäß, kann man die legacy-properties wieder rausnehmen und testen, ob die Installation nun auch mit dem neuen Rechtesystem läuft.

Rechtesystem geht, aber Bilder sind weg

Ganz sicher weg sind danach aber alle eingebetteten Bilder, da Liferay 6 die Bilder von data/images/ laden möchte, Liferay 5 diese jedoch in der Datenbank hält. Um die Bilder wieder anzuzeigen, muss man diese entweder konvertieren, oder diesen Teil des neuen Systemes wieder auf das alte Umstellen. Letzteres geht durch den Eintrag von

image.hook.impl=com.liferay.portal.image.DatabaseHook

in der portal-ext.properties.

Ich finde es aber schöner, wenn auch dieser Teil das neue Liferay-Verhalten annimmt und die Bilder konvertiert werden, so dass sich die Installation nach dem Update vollständig wie eine "neue" Liferay 6 Installation verhält. Für die relativ simple Konvertierung der Bilder aus der Datenbank in das Filesystem, hab ich ein kleines Portlet geschrieben.

ImageConverter-portlet-6.0.5.1.war (Portlet / war, 23 kb, Quellen beiliegend)

Mit diesem kleinen Portlet, lassen sich Bilder aus der Datenbank ins Filesystem konvertieren und umgekeht. Die Konvertierung vom Filesystem in die Datenbank dient rein zu Testzwecken. Bei der Bedienung des Portlets bitte die Log-Ausgabe beachten, da das Portlet im Frontend keinen Status ausgibt.

Nach der Konvertierung der Images aus der Datenbank in das Filesystem, sollten nun auch die Bilder im Frontend wieder erscheinen (Browsercache löschen nicht vergessen. Liferay-Bilder cashen hartnäckig, auch kaputte!).

Grails development - Unsuccessful alter table

2011-07-12T18:44:43Z

Bei laufender Projektentwicklung mit Grails häufen sich mit jeder weiteren Relation die Fehler beim Start durch nicht mögliches Setzen von Datenbank-constraints. Weil mich das nervt, hab ich das gerade bei einem Projekt geputzt ohne meine wohlgepflegten Testdaten zu verwerfen. Das vorgehen ist kein Hexenwerk. Einfach die Daten ohne den Create-Table-Statements dumpen, die Tabellen löschen und von Hibernate neu anlegen lassen und danach die Daten wieder einspielen. Hier die entsprechenden Aufrufe:

			
							1
						
							mysqldump -u DBUSER -pDBPASSWD DATABASE > dump.sql
					
							2
						
							mysqldump -u DBUSER -pDBPASSWD DATABASE -c -t > data.sql
					
							3
						
							mysql -u DBUSER -pDBPASSWD -e "drop database DATABASE"
					
							4
						
							mysql -u DBUSER -pDBPASSWD -e "create database DATABASE"
					
							5
						
							6
						
							# Grails starten und die Tabellen neu anlegen lassen: 
					
							7
						
							8
						
							mysql  -u DBUSER -pDBPASSWD DATABASE -f < data.sql

Beim Wiedereinstellen der Daten in der letzten Zeile kommt es in der Regel zu diversen Fehlerausgaben. "Dublicate entry" kommt vermutlich durch Daten, die im Bootstrap-Prozess angelegt wurden. "Table 'x' doesn't exist" kann man auch ignorieren. "Column 'x' doesn't exist" ist aber problematisch. In diesem Fall hillft nur das Backup einzuspielen, die zukünftig überflüssigen Spalten zu löschen und den Prozess von neuem zu starten.

`1`	`mysql -u DBUSER -pDBPASSWD` `DATABASE` `< dump.sql`

`2`	`mysql -u DBUSER -pDBPASSWD` `DATABASE` `-e` `"ALTER TABLE tablename DROP spaltename"`

`3`	`# und jetzt nochmal von vorne starten`

Einfache JSP Pagination für Magnolia CMS

2011-06-03T12:35:16Z

Oft braucht man in Magnolia eine simple Pagination. Diese kann man, wenn man nicht mit dem STK arbeitet, in einem JSP-Template wie folgt realisieren:

<%
// Request Parameter abfragen, z.B. ?page=1, ?page=2
String pageNumString = request.getParameter(
int pageNumInt = 1;
try {
	pageNumInt = Integer.parseInt(pageNumString);
} catch (NumberFormatException e) {
	// ignore; ggf. Log-Ausgabe schreiben
}

int resultcount = 0;
%>

Nun mit der Magnolia Taglib über die Unterseiten iterieren und die Inhalte ausgeben:

<cms:loadpage path="pfad/zur/root/seite/der/iteration">
<%
resultcount++;
if ((resultcount > pageNumInt*10-10) && (resultcount <= pageNumInt*10-1)) {
%>
	// Hier die Ausgabe
	<cms:out nodedataname="title">
	...
	...
<%
}                                                                      
%>
					
</cms:out></cms:pageiterator>
</cms:loadpage>

Anschließend noch den Pagebrowser ausgeben:

<%
if (resultcount > 10) {
	int numberOfPages = (int) Math.ceil((double)resultcount/10);
	out.println("<ul id="\"pagination\"">");
	int i = 1;
	while (i <= numberOfPages) {
		%>
		<li>
		<a href="
			${pageContext.request.contextPath}
			${actpage.handle}.html<% out.print(" ?page=" + i); 
		">
		%>
		<%=if (pagenumint= i) {
			out.print("class="\"active\"");" 
		} %=>
		<% out.print("Seite " + i); i++; %>
		</a>
		</li>
		<%
	}
	out.println("</ul>");
}
%>

Aufgrund der wenig effizienten Iteration mittels cms:pageIterator, die immer alle Datensätze durchläuft, sollte bei großen Datenmengen das Ganze über ein Modul realisiert werden. Aber z.B. für ein einfaches Newssystem mit in der Regel weniger als 100 Beiträgen ist dieser Weg völlig ausreichend.

Konvertieren einer Liferay-Datenbank von Latin-1 auf UTF-8

2011-05-13T13:52:47Z

Auf dem diesjährigen Liferay-Symposium meldeten sich einige User beim Q & A mit Brian Chan mit der Frage, wie man eine fälschlich in Latin-1 angelegte Datenbank in UTF-8 konvertiert. Da wir das soeben bei einer Datenbank durchgeführt haben, hier eine kurze Anleitung:

Zunächst bitte sicherstellen, dass die Konsole auf UTF-8 gestellt ist. Wenn man den Datenbankdump mit vi aufmacht und Sonderzeichen richtig angezeigt werden, dann stimmts.

Liferay runterfahren, Datenbank-Dump ziehen und sichern:

				
								1
							
								mysqldump -u root -p liferay > dump.sql
						
								2
							
								cp dump.sql dump.sql.bak

dump.sql mit vi aufmachen und tabellendefinitionen per Suchen & Ersetzen ändern:

				
								1
							
								vi dump.sql
						
								2
							
								:1,$:s/ DEFAULT CHARSET=latin1/ DEFAULT CHARSET=utf8/g
						
								3
							
								:wq

Datenbank löschen und diesmal richtig anlegen:

				
								1
							
								mysql -u root -e "DROP DATABASE liferay"
						
								2
							
								mysql -u root -e "CREATE DATABASE liferay CHARACTER SET utf8"

Dump wieder einspielen:

				
								1
							
								mysql -u root -p liferay < dump.sql

Jetzt Liferay wieder starten und dann sollte es das schon gewesen sein.

P.S.: Diese Anleitung ist eigentlich nicht Liferay-spezifisch und sollte auch bei anderen Anwendungen helfen.

Magnolia und Eclipse

2011-05-13T13:47:16Z

Mit dem Aufbau einer Entwicklungsumgebung für Magnolia hat man beim ersten Mal seine liebe Not. Da bei uns die diversen Anleitungen von der Doku-Seite und dem Magnolia Wiki nicht geklappt haben, haben wir hier mal zusammengeschrieben wie wir Magnolia in Eclipse aufsetzen.

Vorbereitungen

Eclipse herunterladen und installieren (Eclipse JEE, Galileo oder Helios)
Maven installieren
svn Command Line Client installieren

Eclipse Plugins installieren

http://download.eclipse.org/releases/galileo bzw. http://download.eclipse.org/releases/helios => Collaboration/Subversive SVN Team Provider + WTP
http://m2eclipse.sonatype.org/sites/m2e => MV2Eclipse (wenn sich das nicht installieren lässt wegen fehlendem org.eclipse.zest.core, GEF von hier http://download.eclipse.org/tools/gef/updates/releases/ installieren)
http://m2eclipse.sonatype.org/sites/m2e-extras => Maven Integration for WTP

Überprüfen ob in Eclipse die Classpath Variable M2_REPO gesetzt ist und auf das Maven Repository zeigt (Preferences / Java / Build Path / Classpath Variables). Eclipse im JDK laufen lassen (in der eclipse.ini einstellen).

Tomcat installieren

Apache Tomcat (5.5 oder 6.0) installieren. setenv.sh und setenv.bat anlegen und damit die memory auf 1024m hochdrehen.

Magnolia aus dem Repository auschecken

Workspace für Eclipse anlegen. Im Workspace eine shell aufmachen und Magnolia aus dem Magnolia Repository auschecken.

svn co http://svn.magnolia-cms.com/svn/community/magnolia/tags/magnolia-4.3.7

pom.xml überarbeiten

Die pom.xml im root der ausgecheckten Magnolia-Version funktioniert meistens nicht wenn man Magnolia nicht vorher schon mal richtig am Laufen hatte. Daher muss die pom.xml angepasst werden.

Unten einfügen:

				
								01
							
								  <repositories>
						
								02
							
								    <repository>
						
								03
							
								      <id>magnolia.nexus.public</id>
						
								04
							
								      <url>http://nexus.magnolia-cms.com/content/groups/public</url>
						
								05
							
								    </repository>
						
								06
							
								  </repositories>
						
								07
							
								<pluginrepositories>
						
								08
							
								<pluginrepository>
						
								09
							
								      <id>magnolia</id>
						
								10
							
								      <url>http://repo.magnolia-cms.com/m2</url>
						
								11
							
								    </pluginrepository>
						
								12
							
								  </pluginrepositories>

mvn build

shell öffnen, in das ausgecheckte Projekt gehen (z.B. Ordner workspace/magnolia_4.3.7/) und dort

mvn eclipse:eclipse

Wenn hier Fehler auftreten (Build error) müssen diese beseitigt werden! Möglicherweise kommt ein Fehler auf einen restrictedpath für xdoclet, entweder hier den Pfad anpassen oder erst mal den restrictedpath auskommentieren.

Projekt in Eclipse importieren

Eclipse in der JEE Perspektive aufmachen. Import => Existing Maven Projects => Rootverzeichnis auswählen (workspace/magnolia_4.3.7). Jetzt sollten alle Projekte erkannt werden. Alle selektieren und importieren.

Tomcat hinzufügen

Neuen Tomcat hinzufügen und wie folgt konfigurieren (Doppelklick auf den Tomcat):

unter “Server Options” das Häkchen bei “Serve modules without publishing” setzen
unter “Timeout” den timeout hochdrehen (z.B. auf 320)
Add/Remove: zum Server die magnolia-empty-webapp hinzufügen

Server starten. Nun sollte in der Konsole der Server problemlos hochfahren und irgendwann erscheint:

	*********************************************************************************************************
*                                                                                                       *
* Magnolia needs module updates or installs, point your browser to your Magnolia instance and confirm ! *
*                                                                                                       *
*********************************************************************************************************

Nun im Browser Magnolia aufmachen (http://localhost:8080/magnolia-empty-webapp) und das Update durchführen. Dann erscheint der Magnolia Login-Screen, in dem man sich mit superuser / superuser einloggen kann.

Liferay friends only!

2011-05-13T13:51:25Z

Trotz des ausgefeilten und in vielen Fällen völlig ausreichenden Rechtekonzeptes von Liferay, fehlt bei Community-Portalen doch häufig eine wichtige Berechtigungseinschränkung, und das ist die Einschränkung auf “Nur für Freunde”. Wir haben dies in einem aktuellen Portalprojekt folgendermaßen implementiert.

Neuer Service für Definition von Friends-Only Permissions. Hier wird schlicht die Klasse mit Private key und einem User definiert, die vor Durchführung hinterlegter Action-ID auf Freundstatus gepfrüft werden muss. ext-impl/src/de/eleon/liferay/socialpermission/service.xml:

			
							01
						
							<!--?xml version="1.0"?-->
					
							02
						
							03
						
							<service-builder package-path="de.eleon.liferay.socialpermission">
					
							04
						
							    <namespace>Social</namespace>
					
							05
						
							    <entity name="SocialPermission" local-service="true" remote-service="false">
					
							06
						
							07
						
							        <!-- PK fields -->
					
							08
						
							<column name="socialPermissionId" type="long" primary="true">
					
							09
						
							10
						
							        <!-- Audit fields -->
					
							11
						
							<column name="userId" type="long">
					
							12
						
							<column name="createDate" type="Date">
					
							13
						
							<column name="className" type="String">
					
							14
						
							<column name="primKey" type="String">
					
							15
						
							<column name="actionId" type="String">
					
							16
						
							17
						
							        <finder name="UserId" return-type="Collection">
					
							18
						
							            <finder-column name="userId">
					
							19
						
							        </finder-column></finder>
					
							20
						
							21
						
							        <finder name="classNamePrimKey" return-type="Collection">
					
							22
						
							            <finder-column name="className">
					
							23
						
							            <finder-column name="primKey">
					
							24
						
							        </finder-column></finder-column></finder>
					
							25
						
							26
						
							        <finder name="classNamePrimKeyActionId" return-type="SocialPermission">
					
							27
						
							            <finder-column name="className">
					
							28
						
							            <finder-column name="primKey">
					
							29
						
							            <finder-column name="actionId">
					
							30
						
							        </finder-column></finder-column></finder-column></finder>
					
							31
						
							32
						
							    </column></column></column></column></column></column></entity>
					
							33
						
							</service-builder>

Erweiterung von ext-imp/build.xml:

			
							01
						
							<!--?xml version="1.0"?-->
					
							02
						
							<project name="ext-impl" basedir="." default="compile">
					
							03
						
							    <import file="build-parent.xml">
					
							04
						
							    ...
					
							05
						
							    <target name="build-service-portlet-socialpermission">
					
							06
						
							        <antcall target="build-service">
					
							07
						
							<param name="service.file" value="src/de/eleon/liferay/socialpermission/service.xml">
					
							08
						
							        </antcall>
					
							09
						
							    </target>
					
							10
						
							    ...
					
							11
						
							</import></project>

Für den generierten Service brauchen wir nur eine Handvoll Methoden in der SocialPermissionLocalServiceUtil für die Anlage und Abfrage des Services. Dies wird definiert in ext-impl/src/de/eleon/liferay/socialpermission/service/impl/SocialPermissionLocalServiceImpl.java:

			
							01
						
							package de.eleon.liferay.socialpermission.service.impl;
					
							02
						
							03
						
							import java.util.Date;
					
							04
						
							import java.util.List;
					
							05
						
							06
						
							import com.liferay.counter.service.CounterLocalService;
					
							07
						
							import com.liferay.portal.SystemException;
					
							08
						
							import com.liferay.portal.kernel.annotation.BeanReference;
					
							09
						
							10
						
							import de.eleon.liferay.socialpermission.NoSuchSocialPermissionException;
					
							11
						
							import de.eleon.liferay.socialpermission.model.SocialPermission;
					
							12
						
							import de.eleon.liferay.socialpermission.service.base.SocialPermissionLocalServiceBaseImpl;
					
							13
						
							14
						
							public class SocialPermissionLocalServiceImpl
					
							15
						
							    extends SocialPermissionLocalServiceBaseImpl {
					
							16
						
							17
						
							    @BeanReference(name = "com.liferay.counter.service.CounterLocalService.impl")
					
							18
						
							    protected CounterLocalService counterLocalService;
					
							19
						
							20
						
							    public SocialPermission addSocialPermission(long userId, String className, String primKey, String actionId) throws SystemException {
					
							21
						
							22
						
							        long socialPermissionId = counterLocalService.increment();
					
							23
						
							24
						
							        SocialPermission sp = socialPermissionPersistence.create(socialPermissionId);
					
							25
						
							        sp.setUserId(userId);
					
							26
						
							        sp.setClassName(className);
					
							27
						
							        sp.setPrimKey(primKey);
					
							28
						
							        sp.setActionId(actionId);
					
							29
						
							        sp.setCreateDate(new Date());
					
							30
						
							31
						
							        socialPermissionPersistence.update(sp, false);
					
							32
						
							        return sp;
					
							33
						
							    }
					
							34
						
							35
						
							    public void removeSocialPermission(long socialPermissionId) throws SystemException, NoSuchSocialPermissionException {
					
							36
						
							        socialPermissionPersistence.remove(socialPermissionId);
					
							37
						
							    }
					
							38
						
							39
						
							    public void removeSocialPermission(SocialPermission socialPermission) throws SystemException {
					
							40
						
							        socialPermissionPersistence.remove(socialPermission);
					
							41
						
							    }
					
							42
						
							43
						
							    public void removeSocialPermission(String className, String primKey, String actionId) throws SystemException, NoSuchSocialPermissionException {
					
							44
						
							        socialPermissionPersistence.removeByclassNamePrimKeyActionId(className, primKey, actionId);
					
							45
						
							    }
					
							46
						
							47
						
							    public List<socialpermission> findByUserId(long userId) throws SystemException {
					
							48
						
							        return socialPermissionPersistence.findByUserId(userId);
					
							49
						
							    }
					
							50
						
							51
						
							    public List<socialpermission> find(String className, String primKey) throws SystemException {
					
							52
						
							        return socialPermissionPersistence.findByclassNamePrimKey(className, primKey);
					
							53
						
							    }
					
							54
						
							55
						
							    public SocialPermission find(String className, String primKey, String actionId) throws SystemException, NoSuchSocialPermissionException {
					
							56
						
							        return socialPermissionPersistence.findByclassNamePrimKeyActionId(className, primKey, actionId);
					
							57
						
							    }
					
							58
						
							59
						
							}
					
							60
						
							</socialpermission></socialpermission>

Für die Abfrage der Berechtigung ziehen wir den AdvancedPermissionChecker nach ext und erweitern diesen. ext-impl/src/com/liferay/portal/security/permission/AdvancedPermissionChecker.java:

			
							120
						
							...
					
							121
						
							    public boolean hasPermission(
					
							122
						
							        long groupId, String name, String primKey, String actionId) {
					
							123
						
							        StopWatch stopWatch = null;
					
							124
						
							125
						
							        if (_log.isDebugEnabled()) {
					
							126
						
							            stopWatch = new StopWatch();
					
							127
						
							128
						
							            stopWatch.start();
					
							129
						
							        }
					
							130
						
							131
						
							        Group group = null;
					
							132
						
							133
						
							        try {
					
							134
						
							            SocialPermission socialPermission = SocialPermissionLocalServiceUtil.find(name, primKey, actionId);
					
							135
						
							            if (socialPermission != null) {
					
							136
						
							                boolean ret = SocialRelationLocalServiceUtil.hasRelation(socialPermission.getUserId(), user.getUserId(), SocialRelationConstants.TYPE_BI_FRIEND);
					
							137
						
							                return ret;
					
							138
						
							            }
					
							139
						
							140
						
							        } catch (NoSuchSocialPermissionException e) {
					
							141
						
							142
						
							        } catch (SystemException e) {
					
							143
						
							            e.printStackTrace();
					
							144
						
							        }
					
							145
						
							146
						
							        // If the current group is a staging group, check the live group. If the
					
							147
						
							        // current group is a scope group for a layout, check the original
					
							148
						
							        // group.
					
							149
						
							        try {
					
							150
						
							            if (groupId > 0) {
					
							151
						
							                group = GroupLocalServiceUtil.getGroup(groupId);
					
							152
						
							153
						
							                if (group.isStagingGroup()) {
					
							154
						
							                    if (primKey.equals(String.valueOf(groupId))) {
					
							155
						
							                        primKey = String.valueOf(group.getLiveGroupId());
					
							156
						
							                    }
					
							157
						
							158
						
							                    groupId = group.getLiveGroupId();
					
							159
						
							                    group = group.getLiveGroup();
					
							160
						
							                }
					
							161
						
							                else if (group.isLayout()) {
					
							162
						
							                    Layout layout = LayoutLocalServiceUtil.getLayout(
					
							163
						
							                        group.getClassPK());
					
							164
						
							165
						
							                    groupId = layout.getGroupId();
					
							166
						
							                }
					
							167
						
							            }
					
							168
						
							        }
					
							169
						
							        catch (Exception e) {
					
							170
						
							            _log.error(e, e);
					
							171
						
							        }
					
							172
						
							173
						
							        Boolean value = PermissionCacheUtil.getPermission(
					
							174
						
							            user.getUserId(), groupId, name, primKey, actionId);
					
							175
						
							176
						
							        if (value == null) {
					
							177
						
							            try {
					
							178
						
							                value = Boolean.valueOf(
					
							179
						
							                    hasPermissionImpl(groupId, name, primKey, actionId));
					
							180
						
							181
						
							                if (_log.isDebugEnabled()) {
					
							182
						
							                    _log.debug(
					
							183
						
							                        "Checking permission for " + groupId + " " + name +
					
							184
						
							                            " " + primKey + " " + actionId + " takes " +
					
							185
						
							                                stopWatch.getTime() + " ms");
					
							186
						
							                }
					
							187
						
							            }
					
							188
						
							            finally {
					
							189
						
							                if (value == null) {
					
							190
						
							                    value = Boolean.FALSE;
					
							191
						
							                }
					
							192
						
							193
						
							                PermissionCacheUtil.putPermission(
					
							194
						
							                    user.getUserId(), groupId, name, primKey, actionId, value);
					
							195
						
							            }
					
							196
						
							        }
					
							197
						
							198
						
							        return value.booleanValue();
					
							199
						
							    }
					
							200
						
							...

Das war die Implementierung der neuen Berechtigungsfuntion. Die SocialRelation wird nun bei entsprechend hinterlegten Datenbankeinträgen – egal welchen Typs – als Vorraussetzung abgefragt. Hier eine Beispielhinterlegung aus einer WOL-Erweiterung für Rechtevergabe bei WallEntries:

			
							01
						
							public void addWallEntry(ActionRequest actionRequest,
					
							02
						
							    ...
					
							03
						
							        } else if (permission.equals("friends")) {
					
							04
						
							            addCommunityPermissions = true;
					
							05
						
							            SocialPermissionLocalServiceUtil.addSocialPermission(socialActivity.getUserId(), SocialActivity.class.getName(), String.valueOf(socialActivity.getActivityId()), Constants.VIEW);
					
							06
						
							07
						
							        } else if (permission.equals("community")) {
					
							08
						
							            addCommunityPermissions = true;
					
							09
						
							        } else if (permission.equals("internet")) {
					
							10
						
							            addCommunityPermissions = true;
					
							11
						
							            addGuestPermissions = true;
					
							12
						
							        }
					
							13
						
							        ResourceLocalServiceUtil.addResources(
					
							14
						
							                socialActivity.getCompanyId(), socialActivity.getGroupId(), userId,
					
							15
						
							                SocialActivity.class.getName(), socialActivity.getActivityId(),
					
							16
						
							            false, addCommunityPermissions, addGuestPermissions);
					
							17
						
							    ...
					
							18
						
							}

Thats it!

Zugriff auf gleiche Session zwischen http und https mit Grails

2011-05-13T13:49:39Z

Wenn man seine Seite aus performance-Gründen gerne mit http ausliefern möchte, den Login jedoch nur über https erlauben will, steht man schnell vor dem Problem, dass unter https geöffnete Sessions mit http nicht zur Verfügung stehen. Das Problem lässt sich mit einem Filter, der die Session schon im http-Modus öffnet, bequem lösen. So machen wirs:
grails create-filters Session

`01`	`class` `SessionFilters {`

`02`	`def filters = {`

03 all() {

`04`	`before = {`

`05`	`if` `(!request.secure && request.getSession(false) ==` `null) {`

`06`	`request.getSession(true)`

07 }

08 }

09 }

10 }

11 }

Liferay Entwicklungsumgebungen - So läufts bei uns

2011-08-01T11:33:45Z

Zwischen “IDE im Subversion” und “Eine IDE und ein tomcat für alles” gibt es viele Variationen. Wir arbeiten so:

Auf Entwicklungsrechnern arbeiten wir mit Windows 7. Wir haben für jedes Projekt ein eigenes Verzeichnis mit der projektspezifischen Entwicklungsumgebung. Das heißt, wir haben eine IDE pro Projekt, checken diese jedoch nicht in die Versionsverwaltung ein. Bei Liferay-Pojekten sieht das dann zum Beispiel so aus:

C:\projekt\
	apache-tomcat\
	data\
	deploy\
	eclipse\
	installer\
	plugins-sdk\ <- versioniert
	workspace\
		workspace\ext\ <- versioniert
		workspace\portal\
	sql\ <- versioniert
	[>] eclipse.exe
	[>] startup.bat
	[>] shutdown.bat

Eigene Portlets die nicht innerhalb von EXT entstehen, bauen wir über das plugins-sdk und importieren diese ins Eclipse.

Das Einbinden der IDE in den Projektordner hat sich sofort bewährt, da sich damit teaminterne Hilfseinsätze zur IDE-Rettung vermeiden lassen. Weitere Teammitglieder lassen sich schnell anbinden, in dem sie einfach den Projektordner eines bestehenden Teammitglieds per USB-Stick bekommen.

Unsere Server sind fast immer Debian- oder Ubuntu-Systeme. Als Online-Testumgebung haben wir einen leistungsstarken Ubuntu-Server als vmware-Host. Auf diesem laufen in der Regel 20 – 30 Gastsysteme mit Liferay o.ä. paralell.

UPDATE 01.08.2011: Entwicklungs-Rechner sind inzwischen Linux Ubuntu und nicht mehr Windows 7. IDEs halten wir nicht mehr je Projekt sondern zentral. Die Projektstruktur und deren Versionierung wurde jedoch beibehalten.

Google Apps für Unternehmen – unser Exchange Killer

2011-05-13T13:46:00Z

Wir lieben Microsoft. Naja, zumindest arbeiten wir damit. Unseren dummen Exchange mögen wir nicht. Wir verstehen nicht, was da für ein riesiger proprieterer File unsere Mails speichert und wir haben keine Lust rauszufinden, wie man da Mails wieder rauszuppft, wenn alles kaputt ist. Seit ein paar Monaten haben wir auf Google Apps für Unternehmen umgestellt. Mails, Kalender & Co haben wir jetzt nur noch webbasiert. Ein Outlook o.ä. gibt es nicht mehr. Aber das macht gar nichts außer Freude, da der Webclient von Google schneller ist, als alles was man sich so an Fatclients zur Mailverwaltung auf seinem Rechner installieren könnte. Spam gibt es übrigens auch keinen mehr. Unser Exchange-Spamfilter, für den wir bisher jährlich 400 EUR gezahlt haben, war nicht halb so gut.

Die neue Lösung mit Google Apps für Unternehmen kostet 40 EUR pro Jahr und Mitarbeiter. Pro Postfach gibt es 20 GB Speicher. Der Import meiner gespeicherten 12.000 Mails der letzten Jahre belegt 10% des Kontospeichers. Das ist im Vergleich zu Outlook und Exchange dann doch etwas effizienter.

Installation von Liferay Änderungen aus der EXT-Umgebung auf das Produktivsystem

2011-05-13T13:46:29Z

Eine hochoffizielle Dokumentation zur Installation von Änderungen aus der EXT-Umgebung des Entwicklungssystems auf dem Produktivsystem ist mir bisher nicht untergekommen. Einige Zeit haben wir immer den kompletten Tomcat aus dem Entwicklungssystem gepackt, hochgeladen und auf dem Produktivsystem wurden dann die relevanten Teile aus dem Entwicklungssystem eingesetzt. Nach dem ca. 100MB großen Upload kam dann immer noch eine viertelstunde potentiell fehleranfälliges herumdoktern im Produktivsystem auf uns zu.

Besser spät als nie, hab ich vor einiger Zeit folgenden Ant-File als Installationshilfe gebaut. Das Script packt alle Änderungen aus der Ext-Umgebung in einen Zipfile, der dann in der Regel nur 2-3 Megabyte groß ist. Der Inhalt dieses ZIPs lässt sich mit “cp -Rf * /path/to/apache-tomcat/” in die Produktionsumgebung verschieben, ohne portal-ext.properties u.ä. zu überschreiben.

Hier der Ant-File:

				
								01
							
								<project name="build-installer" xmlns:antelope="antlib:ise.antelope.tasks">
						
								02
							
								<property name="installer.name" value="kundenname">
						
								03
							
								<property name="installer.dir" value="../../installer">
						
								04
							
								<property name="installer.dir.ext" value="${installer.dir}/lib/ext">
						
								05
							
								<property name="installer.dir.root" value="${installer.dir}/webapps/ROOT">
						
								06
							
								<property name="installer.dir.lib" value="${installer.dir.root}/WEB-INF/lib">
						
								07
							
								08
							
								    <target name="installer.clean">
						
								09
							
								        <delete dir="${installer.dir}">
						
								10
							
								    </delete></target>
						
								11
							
								12
							
								    <tstamp>
						
								13
							
								<format property="installer.time" pattern="yyyyMMdd-HHmm">
						
								14
							
								    </format></tstamp>
						
								15
							
								16
							
								    <target name="installer.copy">
						
								17
							
								        <mkdir dir="${installer.dir}">
						
								18
							
								        <mkdir dir="${installer.dir.ext}">
						
								19
							
								        <mkdir dir="${installer.dir.lib}">
						
								20
							
								        <copy todir="${installer.dir.ext}">
						
								21
							
								            <fileset file="ext-service/ext-service.jar">
						
								22
							
								        </fileset></copy>
						
								23
							
								        <copy todir="${installer.dir.lib}">
						
								24
							
								            <fileset file="ext-impl/ext-impl.jar">
						
								25
							
								        </fileset></copy>
						
								26
							
								        <copy todir="${installer.dir.root}/WEB-INF">
						
								27
							
								            <fileset dir="ext-web/tmp/WEB-INF">
						
								28
							
								        </fileset></copy>
						
								29
							
								        <copy todir="${installer.dir.root}/html">
						
								30
							
								            <fileset dir="ext-web/docroot/html">
						
								31
							
								        </fileset></copy>
						
								32
							
								        <echo message="${installer.dir}">
						
								33
							
								    </echo></mkdir></mkdir></mkdir></target>
						
								34
							
								35
							
								    <target name="installer.compress">
						
								36
							
								<input message="Please enter filename" addproperty="installer.zipname" defaultvalue="${installer.name}_ext_${installer.time}.zip">
						
								37
							
								        <zip destfile="${installer.dir}/${installer.zipname}" basedir="${installer.dir}">
						
								38
							
								39
							
								        <echo message="Fertig, ${installer.zipname} erstellt!">
						
								40
							
								    </echo></zip></target>
						
								41
							
								42
							
								    <target name="installer.install">
						
								43
							
								        <antcall target="installer.clean">
						
								44
							
								        <antcall target="installer.copy">
						
								45
							
								        <antcall target="installer.compress">
						
								46
							
								    </antcall></antcall></antcall></target>
						
								47
							
								</property></property></property></property></property></project>

Wir legen dieses Script in der EXT-Umgebung neben der build.xml an und binden es in dieser mit

ein. Danach steht einem das Ant-Target installer.install zur Verfügung. Nach Rückfrage zum Dateinamen wird zwei Ordner höher – bei uns ist das dann der Ordner in dem auch der workspace von eclipse liegt – ein Ordner namens “installer” angelegt und darin liegt das erstellte ZIP.

Vielleicht ist es ja dem einen oder anderen hilfreich. Wenn jemand einen anderen praktikablen Weg zur Installation von EXT-Änderungen ins Produktivsystem gefunden hat, bin ich für Hinweise dankbar.