Anmeldung

Apache Tapestry ist ein komponentenorientiertes Web-Framework zur Entwicklung von skalierbaren Web-Anwendungen in Java. In dieser Session wird Tapestry vorgestellt und ein innovativer Ansatz zur Entwicklung von Web 2.0 – Anwendungen diskutiert. Es wird demonstriert, wie Tapestry 5 die Mächtigkeit von Java mit der Einfachheit und der Produktivität von Scripting-Lösungen wie Ruby on Rails oder Django kombiniert. Mit Tapestry bekommt man das Beste aus den beiden Welten. Tapestry stellt eine Menge von Features zur Steigerung der Produktivität bereit, die ich in einigen Demos zeigen werde. Weiterhin wird der Vorteil eines komponentenorientierten Frameworks wie Tapestry erläutert.

Dipl.-Informatiker Igor Drobiazko ist Committer und PMC von Apache Tapestry. Igor verfügt über extensive Erfahrung in Web-Entwicklung, OSGi, Test-Frameworks und JEE-Architekturen. Er hat das erste deutschsprachige Buch über Tapestry 5 geschrieben und arbeitet gerade an einer Übersetzung seines Buches für Manning Publications. Igor hält Vorträge über das Framework und bloggt auf http://tapestry5.de/

That tool performs the following steps

1. Detect the current software version from the artifact metadata that is embedded into any Maven-built artifact
2. Query Nexus for available artifacts for the installed software (identified by Maven groupId and artifactId).
3. Test if any of the available artfacts has a version number higher than the installed one
4. If a newer version is available then download it
5. Move the new version to the target directory (e.g. the deployment folder of the application server)

The Nexus REST url for a simple query for some artifact looks like http://localhost/nexus/service/local/data_index/repositories/releases/content?q=commons-lang. This query asks for the commons-lang artifact from the releases repository.

More URL schemes are documented here and there.

The result from this query is like (only the latest versions are included for brevity):

<?xml version="1.0" encoding="UTF-8"?>

<search-results>
	<totalCount>5</totalCount>
	<from>-1</from>
	<count>-1</count>
	<tooManyResults>false</tooManyResults>
	<data>
		<artifact>

			<resourceURI>http://localhost/nexus/service/local/repositories/central/content/commons-lang/commons-lang/2.4/commons-lang-2.4.jar</resourceURI>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.4</version>
			<packaging>jar</packaging>
			<extension>jar</extension>

			<repoId>central</repoId>
			<contextId>Maven Central (Cache)</contextId>
			<pomLink>http://localhost/nexus/service/local/artifact/maven/redirect?r=central&g=commons-lang&a=commons-lang&v=2.4&e=pom</pomLink>
			<artifactLink>http://localhost/nexus/service/local/artifact/maven/redirect?r=central&g=commons-lang&a=commons-lang&v=2.4&e=jar</artifactLink>

		</artifact>
		<artifact>
			<resourceURI>http://localhost/nexus/service/local/repositories/central/content/commons-lang/commons-lang/2.4/commons-lang-2.4-sources.jar</resourceURI>
			<groupId>commons-lang</groupId>
			<artifactId>commons-lang</artifactId>
			<version>2.4</version>
			<classifier>sources</classifier>

			<packaging>jar</packaging>
			<extension>jar</extension>
			<repoId>central</repoId>
			<contextId>Maven Central (Cache)</contextId>
			<pomLink></pomLink>
			<artifactLink>http://localhost/nexus/service/local/artifact/maven/redirect?r=central&g=commons-lang&a=commons-lang&v=2.4&e=jar&c=sources</artifactLink>

		</artifact>

	</data>
</search-results>

That only needs to be parsed using a SAX parser for extracting the most important elements. This is the Maven GAV, packaging, classifier, and the download url which are stored in a POJO. This POJO implements the algorithm for selecting the latest version by its compareTo method.

public class MavenArtifactMetadata implements Comparable<MavenArtifactMetadata> {
	private String groupId;
	private String artifactId;
	private String version;
	private String resourceURI;
	private String packaging;
	private String classifier;

	@Override
	public int compareTo(MavenArtifactMetadata o) {
		if (!this.groupId.equals(o.groupId) || !this.artifactId.equals(o.artifactId)) {
			return -1;
		}
		return versionCompareTo(o.version);
	}

	int versionCompareTo(String version) {
		Integer[] thatVersion = versionComponents(version);
		Integer[] thisVersion = versionComponents(this.version);
		int length = Math.min(thatVersion.length, thisVersion.length);
		for (int i = 0; i < length; i++) {
			if (thatVersion[i].equals(thisVersion[i])) {
				continue;
			}
			return thisVersion[i].compareTo(thatVersion[i]);
		}
		return thisVersion.length - thatVersion.length;
	}

	Integer[] versionComponents(String version) {
		String[] splitted = StringUtils.delimitedListToStringArray(version, ".");
		if (splitted.length>0 && splitted[splitted.length-1].endsWith("-SNAPSHOT")) {
			splitted[splitted.length-1]=splitted[splitted.length-1].replaceAll("-SNAPSHOT", "");
		}
		Integer[] components = new Integer[splitted.length];
		for (int i = 0; i < splitted.length; i++) {
			components[i] = (Integer.valueOf(splitted[i]));
		}
		return components;
	}
}

While implementing the download part I had learned an important lesson. For downloading and moving large files it is much more efficient to use the Java NIO API.

public class EntityFormController<T> extends FormController<T> {
	private Class<T> entityClass;

	public String create() {
		Object instance=getEntityClass().newInstance();
		...
	}
}

So for every specific instance of the property entityClass must be initialized explicitely by implementing a proper constructor, using dependency injection, etc.

public class AddressFormController extends EntityFormController<Address> {
	public class AddressFormController() {
		super(Address.class);
	}
}

This is kind of violating the DRY principle. The actual type is already given through the type parameter. So I was trying to eliminate this few lines of code and come up with a solution that can analyze any parameterized type from a class declaration (super class hierarchy + interfaces).

/**
 * @author Martin Ahrer
 *
 */
public class GenericTypeArgumentExtractor {
	private final Class<?> candidateClass;

	public GenericTypeArgumentExtractor(Class<?> candidateClass) {
		super();
		this.candidateClass = candidateClass;
	}

	public Class<?>[] getGenericTypeArguments(Class<?> clazz) {
		// TODO: hopefully clazz.getGenericSuperclass() == clazz.getSuperclass()
		Type[] types = Arrays.copyOf(clazz.getGenericInterfaces(), clazz.getGenericInterfaces().length
				+ (clazz.getGenericSuperclass() != null ? 1 : 0));
		if (clazz.getGenericSuperclass() != null) {
			types[types.length - 1] = clazz.getGenericSuperclass();
		}
		// Iterate all types from which the clazz inherits. i.e all generic
		// interfaces and the generic super class.
		for (Type type : types) {
			Class<?>[] arguments = getGenericTypeArguments(type);
			if (arguments != null) {
				return arguments;
			}
		}
		return null;
	}

	private Class<?>[] getGenericTypeArguments(Type type) {
		if (type instanceof ParameterizedType) {
			ParameterizedType parameterizedType = (ParameterizedType) type;
			if (isCandidate(parameterizedType)) {
				Type[] arguments = parameterizedType.getActualTypeArguments();
				Class<?>[] result = new Class<?>[arguments.length];
				for (int i = 0; i < result.length; i++) {
					result[i] = (Class<?>) (arguments[i] instanceof ParameterizedType ? ((ParameterizedType) arguments[i])
							.getRawType()
							: arguments[i]);
				}
				return result;
			}
		} else if (type != null) {
			Class<?>[] result = getGenericTypeArguments((Class<?>) type);
			return result;
		}
		return null;
	}

	/**
	 * Detects the type from which we want the type arguments. Can be overridden
	 * in subclasses.
	 *
	 * @param type
	 *            the parameterized type to check for.
	 * @return true if type arguments of the passed type are reqeusted.
	 */
	protected boolean isCandidate(ParameterizedType type) {
		return candidateClass.isAssignableFrom((Class<?>) type.getRawType());
	}
}

Using the above class for extracting type parameters would return an array containing the Address class object.

Class[] genericTypeArguments = new GenericTypeArgumentExtractor(EntityFormController.class)
		.getGenericTypeArguments(AddressFormController.class);

In many projects I found the situation that the client didn’t want to pull in another framework just for that little feature. Also for distributing responsibilities, I usually have multiple managed beans per view. So another “artificial” page bean is required just for controlling the others. So I came up with a fairly simple solution that allows to directly invoke those life-cycle callbacks on any managed bean used on a single page.

The <f:phaseListener> tag allows to bind a JSF PhaseListener. You can even bind multiple phase listeners (one for each managed bean; you get the idea).

<f:phaseListener binding="#{bean1.viewControllerPhaseListener}" />
<f:phaseListener binding="#{bean2.viewControllerPhaseListener}" />

So each of the beans would provide a reference to a phase listener that would take care to perform the proper processing for the bean itself. Every bean then would use a set of annotations (like @PreRenderView, @PostRestoreView, @PreInvokeApplication, etc.) to mark those methods that should be called during a specific phase.

public class EntityListController<T> {
	private volatile ViewControllerPhaseListener viewControllerPhaseListener;

	public ViewControllerPhaseListener getViewControllerPhaseListener() {
		if (viewControllerPhaseListener == null) {
			viewControllerPhaseListener = new ViewControllerPhaseListener(this);
		}
		return viewControllerPhaseListener;
	}

	@PreRenderView
	public void updateModel() {
		...
	}

	...

The code above is partially showing a base class from which many of my managed bean are subclassed. Key is the ViewControllerPhaseListener which hides all of the details of doing the reflection job for finding (and then caching) the annotated methods to invoke during a specific phase. For brevity I’m showing only the key elements of this class.

public class ViewControllerPhaseListener implements PhaseListener {
	private final Object target;

	public ViewControllerPhaseListener(Object target) {
		super();
		this.target = target;
	}

	private final Class<Annotation>[] LIFECYCLE_ANNOTATIONS = new Class[] { PreRenderView.class, PostRestoreView.class,
		PreInvokeApplication.class };

	private final static Map<Class<?>, Map<Class<? extends Annotation>, Set<Method>>> controllerClasses = new ConcurrentHashMap<Class<?>, Map<Class<? extends Annotation>, Set<Method>>>();

	static Map<Class<?>, Map<Class<? extends Annotation>, Set<Method>>> getControllerClasses() {
		return controllerClasses;
	}

	@Override
	public void beforePhase(PhaseEvent event) {
		if (PhaseId.RENDER_RESPONSE.equals(event.getPhaseId())) {
			invokeAnnotatedMethod(PreRenderView.class, target);
		} else if (PhaseId.INVOKE_APPLICATION.equals(event.getPhaseId())) {
			invokeAnnotatedMethod(PreInvokeApplication.class, target);
		}
	}

	@Override
	public void afterPhase(PhaseEvent event) {
		if (PhaseId.RESTORE_VIEW.equals(event.getPhaseId())) {
			invokeAnnotatedMethod(PostRestoreView.class, target);
		}
	}

	@Override
	public PhaseId getPhaseId() {
		return PhaseId.ANY_PHASE;
	}

	void invokeAnnotatedMethod(Class<? extends Annotation> annotation, Object targetObject) {
		if (!controllerClasses.containsKey(targetObject.getClass())) {
			registerController(targetObject.getClass());
		}
		for (Method method : controllerClasses.get(targetObject.getClass()).get(annotation)) {
			try {
				method.invoke(targetObject);
			} catch (Exception e) {
				LOGGER.error("Error invoking @{} annotated method {} on {}", new Object[] { annotation.getSimpleName(),
						method, targetObject });
				throw new RuntimeException(e);
			}
		}
	}

	public void registerController(Class<?> controllerClass) {
		// do the reflection work
	}
}

In a few projects this has proven to be quite versatile. Currently I have a couple of interesting phase listener components, from the simple DebugPhaseListener to the OpenTransactionInViewPhaseListener. I can just throw them into any view as they are required.

Versioning only works for resources loaded from the webroot (e.g webroot/resources/library-name/version/resource-name…) and it looks like the next version of the JSF spec will drop some of the versioning features again.

It is questionable if this versioning mechanism makes any sense, if versioning in JAR files would not be supported at all?

So I came up with trying that with jQuery (in my case it is already included in Rich-Faces that I was using here). The idea is to actually render all FacesMessage objects at the very bottom of the page and once the page has finished loading move its DOM tree up where it was supposed to be displayed.

<div id="messagesTarget"</div>

...
...

<rich:panel id="messagesSource" rendered="#{! empty facesContext.maximumSeverity}">
	<rich:messages showDetail="true" showSummary="true" errorClass="errorSeverity" warnClass="warningSeverity"
		infoClass="infoSeverity" />
</rich:panel>

<rich:jQuery selector="$('messagesTarget')" query="append($('messagesSource'))" timing="onload" />

ssl_disable = no
ssl_cert_file = /etc/ssl/certs/certificate.pem
ssl_key_file = /etc/ssl/private/key.pem

The certificate and key must be created before either using the dovecot tools or the way I’m describing that in-depth.

apt-get install libsasl2-2 sasl2-bin libsasl2-modules

The postfix configuration requires the following update in/etc/postfix/main.cf.

# add permit_sasl_authenticated for SASL support
smtpd_recipient_restrictions =
        permit_mynetworks,
        permit_sasl_authenticated,
        reject_unauth_destination,
        check_policy_service inet:127.0.0.1:60000

# add these options
smtpd_sasl_auth_enable = yes
smtpd_sasl_authenticated_header = yes
broken_sasl_auth_clients = yes
smtpd_sasl_security_options = noanonymous

Create /etc/postfix/sasl/smtpd.conf with this content

pwcheck_method: saslauthd
mech_list: plain login

Then create directory /var/spool/postfix/var/run/saslauthd

 mkdir -p /var/spool/postfix/var/run/saslauthd

Set permissions

dpkg-statoverride --add root sasl 710 /var/spool/postfix/var/run/saslauthd

And add postfix user to group sasl

adduser postfix sasl

/etc/default/saslauthd Requires some modifications

START=yes
OPTIONS="-c -m /var/spool/postfix/var/run/saslauthd -r"

Finally restart some services.

/etc/init.d/saslauthd restart
/etc/init.d/postfix restart

Upgrading from debian etch

If you are upgrading and getting permission errors then you can fix these by berforming the steps above where permissions for /var/spool/postfix/var/run/saslauthd are set and the user group sasl is updated.

SASL authentication failure: Password verification failed
SASL PLAIN authentication failed: generic failure
SASL authentication failure: cannot connect to saslauthd server: Permission denied
SASL LOGIN authentication failed: generic failure

<h:outputText value="#{day.date}">
	<f:convertDateTime type="date" pattern="dd.MM.yyyy" timeZone="#{viewController.timeZoneId}"/>
</h:outputText>

The latter approach allows to have a single point of detecting a users timezone preference (unfortunately the timezone is not included in the HTTP header) but requires to have the timezone attribute implemented in multiple places.

So far so good. Many solutions propose using the timezone offset based timezone identifier which turns out to be bad. It doesn’t allow the JDK date formatters to properly apply the daylight settings. So better use “Europe/Vienna” instead of “GMT+1″. It even looks like there were some subtle changes with turning from JDK 1.5 to JDK 1.6 regarding this.

public boolean isSevereMessage() {
	Severity severity = FacesContext.getCurrentInstance().getMaximumSeverity();
	return severity == null ? false : severity.compareTo(FacesMessage.SEVERITY_INFO) > 0;
}

Seems that could go into the FacesContext implementation, right? In order to get there you need a FacesContextFactory that instantiates your FacesContext implementation.

The FacesContextFactory is setup by a FactoryFinder which supports quite a few strategies for picking up the factory.

public class BlueprintFacesContextFactory extends FacesContextFactory {
	private final FacesContextFactory factory;
	public BlueprintFacesContextFactory(FacesContextFactory factory) {
		super();
		this.factory = factory;
	}
	@Override
	public FacesContext getFacesContext(Object context, Object request, Object response, Lifecycle lifecycle)
			throws FacesException {
		return new BlueprintFacesContext(factory.getFacesContext(context, request, response, lifecycle));
	}
}

By implementing a constructor that takes a FacesContextFactory as argument we can easily get hold of the factory provided by the JSF implementation and delegate.

For our FacesContext implementation the deal is to wrap the existing FacesContext with your own implementation. Therefore it also implements a constructor taking a Facescontext as argument.

public class BlueprintFacesContext extends FacesContext {
	private final FacesContext context;
	public BlueprintFacesContext(FacesContext context) {
		super();
		this.context = context;
		setCurrentInstance(this);
	}

	/**
	 * Test if a request processing resulted in a severe message. A message is
	 * considered severe if it is more severe than INFO.
	 *
	 * @return true if
	 *         <code>maximumSeverity.compareTo(FacesMessage.SEVERITY_INFO) > 0</code>
	 */
	public boolean isSevereMessage() {
		Severity severity = getMaximumSeverity();
		return severity == null ? false : severity.compareTo(FacesMessage.SEVERITY_INFO) > 0;
	}
	@Override
	public ELContext getELContext() {
		ELContext elContext = context.getELContext();
		elContext.putContext(FacesContext.class, this);
		return elContext;
	}
	//other methods stripped for brevity, they only delegate to context!

With JSF2 a FacesContextWrapper is provided so only those methods need to overridden that are required to add the desired behaviour.
Here I needed to override getELContext in order to make the custom FacesContext available in EL expressions.