TechJava» TechJava – Articles on mdsd

Extending Xtext Build Participants

Simon Zambrovski — Thu, 17 Jun 2010 10:41:21 +0000

You’ve definitely heard about Xtext, the famous text modeling framework, community award winner . We are all looking forward to the new project management wonder: the release of Helios, upcoming on June the 23rd, which will include Xtext 1.0.0. In this article, I want do describe some aspects of integration of Xtext-based languages into IDE.

Introduction

Creating your own domain-specific textual languages in Xtext is really easy, and the authors in Northern Germany are doing a good job to make it even easier. Once you have a language, you want to process it and this means usually to transform your model into another representation. The facility responsible for this transformation is called generator and consists of a bunch of transformation templates (e.G. XPand) and some code executing them. On some event, the model is read in and the transformations are applied to produce code. Currently, there are two ways of triggering the transformation: you can put the calling infrastructure in a Modeling Workflow Engine file, which is a kind of batch script or you can write a build-participant, which react on the changes in the model. In this article I want to describe my experiences with the builder approach.

Examining initial builder

The base idea behind the builder approach is the fact, that Xtext provides an project builder, which watches for all Xtext resource changes (Xtext-based DSL models) and notifies the so-called XtextBuilderParticipants. These are registered using Eclipse extension point org.eclipse.xtext.builder.participant and implement the IXtextBuilderParticipant interface:

...
public interface IXtextBuilderParticipant {
    void build(IBuildContext context, IProgressMonitor monitor) throws CoreException;
}

public interface IBuildContext {
    IProject getBuiltProject();
    List getDeltas();
    ResourceSet getResourceSet();
    void needRebuild();
}

In order not to start completely from scratch, let us examine the builder provided in the Domain-Model-Example, delivered with Xtext. In the build method the example builder processes as follows:

checks that the project is a Java project
finds the generation folder
creates an Output
creates an Outlet and registers it in the Output
registers a post-processor managing Java imports on the outlet
creates the Xpand execution context
registers the Java Beans version of the metamodel
processes the changes and analyses if the files have to be deleted or not prior re-generation
for all changed model elements re-generates

Quite a lot of tasks, so there is a good reason, why MWE scripts are used for generation.

Using Project natures

The first improvement I created for the builder is the ability to distinguish DSLs. The problem of triggering all XtextBuildParticipants on the change of any Xtext-based resource is that the entire Workspace gets re-generated. In my scenario, we used three DSLs and a random change caused three builders to run, even if the change has been made in another project of workspace. In order to solve this problem I used the standard Eclipse way to distinguish projects: Project Natures.

The nature I created is used as a marker for the builder and is emtpy:

public class UiNature implements IProjectNature {
	public static final String NATURE_ID = "de.techjava.dsl.uiNature";
	private IProject project;

	public void configure() throws CoreException {
        }

	public void deconfigure() throws CoreException {
	}
	public IProject getProject() {
		return project;
	}
	public void setProject(IProject project) {
		this.project = project;
	}
}

Don’t forget to register it in the plugin.xml:

As the first line in my builder I check the presence of the nature in the current project and stop building if the nature is not present:

if (!context.getBuiltProject().hasNature(UiNature.NATURE_ID)) {
	// skip projects without UI DSL nature
	return;
}

Now, what is missing is the ability to add and remove the nature to/from the project. I liked the way how Xpand/Xtend Natures are configured (using toggle action in configure menu of the project pop-up menu). What you need is a ToggleAction that can be switched on, if the nature is not present and switched off, if the nature is installed.

public class ToggleNatureAction implements IObjectActionDelegate {
	private ISelection selection;
	@SuppressWarnings("unchecked")
	public void run(IAction action) {
		if (selection instanceof IStructuredSelection) {
			for (Iterator it = ((IStructuredSelection) selection).iterator(); it.hasNext();) {
				Object element = it.next();
				IProject project = null;
				if (element instanceof IProject) {
					project = (IProject) element;
				} else if (element instanceof IAdaptable) {
					project = (IProject) ((IAdaptable) element).getAdapter(IProject.class);
				}
				if (project != null) {
					toggleNature(project);
				}
			}
		}
	}

	public void selectionChanged(IAction action, ISelection selection) {
		this.selection = selection;
	}

	public void setActivePart(IAction action, IWorkbenchPart targetPart) {
	}

	/**
	 * Toggles sample nature on a project
	 * @param project to have sample nature added or removed
	 */
	private void toggleNature(IProject project) {
	// implemetation of toggle nature ...
	}
}

In order to make an action to a toggle-action the Eclipse Command Framework, Object Contributions and the Command Core Expressions are needed. The idea is to register two actions as object contributions on the IProject using the org.eclipse.ui.popupMenus extension point and define visibility of those to be complement to each other (if one is visible the other is not) based on the object state, which is the presence of a project nature. The actions used point to the same implementation class but have different labels. The menu path to pop-up menu Project > Configure is org.eclipse.ui.projectConfigure/additions. The visibility is defined based on the objectState:

Please note, that the nature is implemented and registered inside of the generator project and the toggle action is implemented in the UI project. Finally, the code of the toggleNature method, which is the standard code for the project nature installation and removal:

...
	IProjectDescription description = project.getDescription();
	String[] natures = description.getNatureIds();

	// remove the nature
	for (int i = 0; i < natures.length; ++i) {
		// if nature exists
		if (NATURE_ID.equals(natures[i])) {
			// Remove the nature
			String[] newNatures = new String[natures.length - 1];
			System.arraycopy(natures, 0, newNatures, 0, i);
			System.arraycopy(natures, i + 1, newNatures, i, natures.length - i - 1);
			description.setNatureIds(newNatures);
			project.setDescription(description, null);
			return;
		}
	}

	// Add the nature
	String[] newNatures = new String[natures.length + 1];
	System.arraycopy(natures, 0, newNatures, 0, natures.length);
	newNatures[natures.length] = NATURE_ID;
	description.setNatureIds(newNatures);
	project.setDescription(description, null);
...

That’s it, run and right-click on the Project and then go to the Configure Menu (pretty low in the pop-up) and you will see the result:

Parameterizing generator

Domain-specific languages should cover only the real requirements and incorporate the specific decision made in the project. So far the theory, but in fact it is a trade-off and a compromise, what is a part of the language and what is too specific to be covered. The same holds for the generator: on the one hand you want the generator to solve exactly your problem, on the other hand you want to make it generic enough to cover a class of similar problems.

I faced the problem of using the generator for two teams in a big project, where the langage could be reused, but the generation infrastructure need to be slightly modified. For example, the information about the generation target folder, package prefix and the fact which artifact should be generated differred between the teams. In the same time the teams were able to agree on the same language. In order not to develop two generators, I decided to parameterize the generator and the templates.

The Xpand2/Xtend developers provided a way of parameterization of the templates using the so-called Global Variables, using the GLOBALVAR keyword. My favorite way of using it is to create a cached extension for reading the variable:

/*
 * Retrieves the boolean value of the global variable set from outside of the template
 */
cached Boolean generateService() :
    GLOBALVAR generateService == "true"
;

In order to set global variables from the build participant the XPand execution context constructor takes a Map argument. The nice story about the global variables, that you can provide any objects as values. So the advantage over the usage of MWE workflow with property files read-in during processing is the big flexibility in providing the object-graphs or even statefull objects as global variable values. A good example of usage of global variable is provided in Domain-Example with Java Import Tool:

JavaImportsTool importsTool = new JavaImportsTool();
...
ctx = new XpandExecutionContextImpl(output, null,
    Collections.singletonMap(JavaImportsTool.VAR_NAME,
    new Variable(JavaImportsTool.VAR_NAME,importsTool)),
    null, null);
...

In the same time it is important to be able to load simple properties from file in the generation project. For example you could implement your own ModelProperties container, which reads properties from the file located in the generation project. For example:

public class ModelProperties extends Properties {
	/**
	 * Indicates that no timestamp is available
	 */
	private static final long NO_TIMESTAMP = -1;

	private long lastModified = NO_TIMESTAMP;
	private final IFile propertyFile;
	private final HashMap globalVars;

	/**
	 * Creates a valid model properties instance
	 *
	 * @param aProject reference to the current project
	 * @param name of the property file
	 * @throws CoreException on errors
	 */
	public ModelProperties(final IProject aProject, String filename) throws CoreException {
		if (aProject == null) {
			ErrorHelper.throwCoreException("project must be not null");
		}
		if (filename == null) {
			ErrorHelper.throwCoreException("filename must be not null");
		}
		this.globalVars = new HashMap();
		this.propertyFile = (IFile) aProject.findMember(filename);
	}

	public IFile getPropertyFile() {
		return propertyFile;
	}

	/**
	 * Returns the global variables.
	 * @return global variables.
	 */
	public Map getGlobalVars() {
		updateProperties();
		return globalVars;
	}

	@Override
	public String getProperty(String key) {
		updateProperties();
		return super.getProperty(key);
	}

	/**
	 * Updates the properties and the global variables if the property file has
	 * been modified.
	 */
	public void updateProperties() {
		if (this.propertyFile != null && lastModified != this.propertyFile.getModificationStamp()) {
			loadProperties();
			globalVars.clear();
			for (Map.Entry entry : entrySet()) {
				final String propertyName = (String) entry.getKey();
				globalVars.put(propertyName, new Variable(propertyName, entry.getValue()));
			}
		}
	}

	/**
	 * Loads the properties from the model file
	 */
	private void loadProperties() {

		try {
			if (propertyFile != null && propertyFile.exists()) {
				super.load(propertyFile.getContents());
				this.lastModified = propertyFile.getModificationStamp();
				handleSpecialProperties();
			}
		} catch (CoreException e) {
			// no model property file isn't a problem but clear the properties:
			super.clear();
			this.lastModified = NO_TIMESTAMP;
		} catch (IOException e) {
			super.clear();
			this.lastModified = NO_TIMESTAMP;
		}
	}

	protected void handleSpecialProperties() {

	}
}

Using this class you can simple initialize the XPandExecutionContext with properties read from the file system. So in build-Method of your Generator put something like:

         ModelProperties structureProperties = new ModelProperties(context.getBuiltProject(), "structure.properties");
         XpandExecutionContextImpl ctx = new XpandExecutionContextImpl(output, null, structureProperties null, null);

Now you can resolve the values from the property files directly from the Templates and Extensions using the built-in GLOBAL VAR feature.

2nd Workshop on MDSD Today 2008

HeSoK — Thu, 06 Nov 2008 21:11:27 +0000

On October 15th to 17th the Workshop on MDSD Today 2008 took place in the Nordakademie Elmshorn near Hamburg. This workshop was actually the sequel to two different workshops which were led by Frank Zimmermann (Nordakademie) and Simon Zambrovski (TUHH) the year before. For this years event, Peter Friese (Itemis) from Itemis joined the two for organizing the Workshop.

The workshop was divided into three parts: Day 1: Management Day, Day 2: Professional Day (Modeling Projects and Tutorials) and Day 3: Professional Day (Generator Tutorials). (See also MDSD08).

The first day was dominated by excellent key-note speeches given by the EMF lead Ed Merks Ph.D. and SAPs Dr. Axel Uhl. Ed was talking about misconceptions in understanding and applying model driven techniques. Axel on the other hand talked about the challenges that still lay on our way and need to be overcome. He discussed for example the different benefits and drawbacks of using different sorts of DSL (e.g. non-textual / textual) with respect to storing them in repositories, merging and refactoring (i.e. general tool-support). Birger Garbe and Stefan Reichert (both Lufthansa Systems consultants) talked about their experiences in applying MDSD in the field. Chances and riscs were explained and how they managed to overcome those riscs. Thomas Stahl of b+m Informatik gave a talk about how MDSD, BPM and SOA fit together, unfortunately he couldn’t give is planned speech “Experiences of 10 years of MDSD”. As one of the authors of the model-driven software development book and with the experience background he has, this would be have been clearly very interesting. The speech he gave instead was also interesting but took little different directions.

The second day was filled with two different tracks one could attend. One covered contributions coming from the fields of research and the industry. And in the other one Ed Merks gave an intro to the Eclipse Modeling Framework (EMF). After that, Ralf Möller of the Eclipse Foundation talked about innovation networks. The afternoon was filled with a tutorial on how to generate graphical editors using the GMF. The tutorial was given by Robert Wloch who jumped in for Jan Köhnlein (both itemis) who unfortunately got sick.

The third and last day was filled with a tutorial on xText, which was given by Peter Friese and Sven Efftinge (both itemis). Later Arno Haase (independant consultant) tought the audience how to do model-to-model and model-to-code transformations.

Summing up this was a very, very interesting event where the cremé dé la cremé of MDSD gathered and where people had the chance to ask, learn and get to know each other. Not only the speeches and tutorials were very interesting, funny but the overall event had socially a nice friendly touch. Some further pictures can be found in the FlickR gallaery.

The Workshop Proceedings can be obtained at amazon:
Proceedings of the Second Workshop on MDSD Today 2008 (engl.)

Ed Merks new book will be published sometime in the beginning of 2009, here is a link to the “old” (but still good) one:

Eclipse Modeling Framework (engl.)

Also I would like to mention the book by Arno Haase, Markus Völter, Thomas Stahl, Sven Efftinge:

Modellgetriebene Softwareentwicklung ( english version)

Productive Java EE 6

Simon Zambrovski — Wed, 10 Sep 2008 22:16:53 +0000

The holiday season is over and we can enjoy an event every week. After Maven 2, Eclipse Stammtisch and reasoning on modularity an event on enterprise systems can be visited. It seems that after the last visit on Java EE 5 Hacking Adam want to tell something on Java EE 6 Hacking…

This session will be interactive / openspace like. He will walk through the new EJB 3.1 APIs and explain some interesting stuff as well. It is the logical conduction of the first JUG HH session in May 2008.

Location: Lehmanns Fachbuchhandlung (Hamburg Hauptbahnhof), Kurze Mühren 6, 20095 Hamburg

Date and Time: 16.09.2008, 20:00
Topic: Productive Java EE 6 – Rethinking Best Practices And Bashing On Patterns, Cluster One

Abstract: Java EE 6 is great, but many questions like:

Are DAOs dead?
Do JSF really suck?
Are anemic JPA-entities a best practice?
Are XML deployment descriptors legacy?
Are EJBs lightweight?
How to test EJBs?
Is layering an antipattern?
Do we need factories?
How to integrate with RESTFul services?
Is it possible to deploy EJBs into a …WAR?
Are “plain old web containers” dead?
Services or Objects – what is the way to go?

still remain open. These and many other questions will be discussed interactively with …code.

Speaker: Adam Bien

About the speaker: Java Champion Adam Bien is a self-employed consultant, lecturer, software architect, developer, and author in the enterprise Java sector in Germany who implements Java technology on a large scale. He is also the author of several books and articles on Java and J2EE technology, as well as distributed Java programming. His books include J2EE Patterns, J2EE HotSpots, Java EE 5 Architectures, Enterprise Architectures, Enterprise Java Frameworks, SOA Expert Knowledge, and Struts, all published in German.

As BEA technical director, Bien is also a member of the NetBeans Dream Team; an Expert Group member of the Java Community Process for EJB 3.1, JPA 2.0, and Java EE 6; and involved in embedded Java, Grid, and P2P technology. He currently works as an architect and developer in several J2EE-Java EE Model-Driven Architecture (MDA) and EAI component architecture projects for the Java EE platform and .NET.

Eclipse DemoCamp Hamburg 2007 – Content

HeSoK — Tue, 18 Dec 2007 10:18:20 +0000

At the Eclipse DemoCamp we had the opportunity to present certain aspects of our work. Our talk concentrated on building a repository for GMF based diagram editor models. The problem there is, that GMF makes assumptions about the underlaying model which had to be worked around. In the following slides the essence of the steps necessary are explained.

Presentation Slides

Thanks to http://www.loroma.com/ for creating and cutting the video. It is dark, but you can hear our voices, even though the presentation is in German.

Eclipse DemoCamp Hamburg 2007

Simon Zambrovski — Tue, 18 Dec 2007 07:36:11 +0000

Yesterday, the first Hamburger Eclipse DemoCamp took place. About fifty participants and eight speakers met in the nice Spanish restaurant Aqui in Schanzen-District, just a step away from the Headquaters of Gentleware AG. The event was, what it should be – a local exchange of experience and know-how in the area of Eclipse. Because of the interests of Gentleware, b+m Informatik AG and itermis AG, the session was not just Eclipse-generic, but focused on MDSD topics. I liked the fact that the participants quickly build a homogenous group – all of them had some experience in PDE, EMF, etc. Amazing demo has been shown by Frank Zimmerman, who used some MDSD techniques to program the Lego Robot. A very nice start event, hopefully it can become a tradition. The photos are available in a FlickR’s Photo Set.