Texo and Xcore: tex(o)tual modeling and JPA/JSON webservices

Xcore allows you to define and maintain models in a textual form. To quote the Xcore wiki page: ‘It eliminates the dividing line between modeling and programming, combining the advantages of each.’ Xcore really adds value and makes working with models easier and much more fun. So no wonder that it has been on my todo-list for a while now to see how I could integrate it nicely with Texo.

As often I got the extra needed push from questions on the newsgroup to finally get this done. The past year I have taken a closer look at Xcore and  the way it handles models. I was pleasantly surprised to see that you can load Xcore-defined models through an EMF Resource and can easily get to the underlying EMF/ecore model.

This made it quite easy to make all the Texo functionality work for Xcore models:

• generate JPA entities directly from Xcore
• define annotation models to control code generation in detail
• overriding/extending code generation with own custom templates
• auto-generate while changing models
• full automatic-zero-coding CRUD JSON and XML webservice support

Most of the functionality is directly available with a simple right-click on a xcore file:

Note the last menu option: I also added a nice feature that allows you to generate the ecore model from an xcore file (not needed for Texo, but sometime nice to have in any case).

Thanks for reading and I hope this blog post helps to give Texo a try. Visit the Texo wiki for more information. Let me know if you have any questions or remarks on the EMFT newsgroup or forum!

gr. Martin

Texo what’s Next

Hi,

After a long time since my last blog post on Texo it is time to get back. So what’s next for Texo!

The first main thing is Xcore support. It is something requested often by several users. I am almost done with it, so should be there shortly. An interesting next xcore-step is to see if it is possible to integrate the Texo annotations models into the Xcore editor. This so that people don’t need to maintain a separate annotations model.

Another technology I have worked with the past years is Mondrian, it can be interesting to see what/if Texo (runtime) can be integrated with Mondrian.

Recently I have gotten quite interested in micro-service architectures because of their elegant scalability and robustness capabilities and nice decomposition approach. I have some research topics/questions I would like to explore here, further developing Texo in the direction of a micro-service architecture. This is for me probably one of the most interesting areas for 2015!

Related to micro-service architectures is the topic of no-sql datastores. No-sql datastores are better (than relational stores) in supporting distributed data storage, making them suited for micro-service architectures. Would be nice to extend Texo to support different no-sql databases.

A long (really long) while back I had a chat with people from the EMF Client Platform. It is very interesting to make the Texo runtime layer suitable as a ECP persistence backend, there seems to be a perfect fit there!

Having said the above, my plan for this year is to get to an official release and real version 1.0, and then participate in the subsequent official Eclipse release.

I am also very interested in working with others who want to collaborate and contribute. Texo can be split in 2 main parts: generation and runtime behavior providing JSON/XML webservices. Both interesting areas to contribute to. I mentioned several topics above, but other ideas are also welcome! Feel free to contact me directly if you want to participate (mtaal_at_elver.org).

Thanks for reading and I hope this blog post helps to give Texo a try and possibiy contribute. Visit the Texo wiki for more information. Let me know if you have any questions or remarks on the EMFT newsgroup or forum!

gr. Martin

EMF Texo and Teneo available for Maven

Hi,

Traditionally Teneo and Texo are distributed through Eclipse update sites. The past year several people have asked me to make the Texo and Teneo runtime jar files also available through a Maven repository.

Recently this topic also came up for some sponsored Teneo development I am currently doing. With these requests from multiple sides it was time to make this happen!

So from today: Teneo/Texo (and their EMF dependencies) are uploaded to the Sonatype repositories (thank you Sonatype for providing this repo-service!) and from there synced to Maven central. They are all published in the org.eclipse.emf group.

The nightly builds are available on the Sonatype snapshot repository. The builds are released regularly to Maven central. You can find the jar files there:

• Teneo on Maven central
• Texo on Maven central

See these Texo and Teneo wiki pages for some more information.

Thanks for reading and I hope this blog post helps to give Teneo and Texo a try. Let me know if you have any questions or remarks on the EMF/EMFT newsgroup or forum!

gr. Martin

ps: when using maven with Texo, make sure to check out this troubleshooting tip.

EMFT Texo: integrating Texo in your build process

Hi!

The latest Texo version supports headless/server code generation directly from Java or ANT. This makes it possible to integrate Texo code generation in your overall build process.

So how to setup headless/build-integrated code generation?

Texo uses Eclipse for code formatting and import resolving. So, start by downloading an Eclipse version suitable for your build platform. Then install the Texo plugins in this Eclipse version through the Texo update site and put this Eclipse version somewhere on your build server.

As a second step choose a location on the build server where Texo can create a workspace and Java project. And last, place the model (ecore/xsd) files on the build server.

To generate code using ANT you can use a macrodefinition. To run the macro:

<texo.gen eclipse=”/home/build/eclipse”

data=”/home/build/workspace”

projectName=”testgen”

modelLocation=”/home/build/models”

jpa=”true” dao=”false”/>

The parameters have the following meaning:

• eclipse: the eclipse installation location
• data: the workspace location
• projectName: the name of a Java project to use, see here for more information
• modelLocation: the location of the model files
• jpa: generate code with JPA annotations
• dao: generate a DAO layer

The generated code will be present in the Java project on your build server and can be copied/compiled from there.

Instead of using ANT, you can also execute headless code generation directly in Java.

That’s all, with these latest developments, code generation and your build process can be nicely tied together!

Thanks for reading and I hope this blog post helps to give Texo a try. Visit the Texo wiki for more information. Let me know if you have any questions or remarks on the EMFT newsgroup or forum!

gr. Martin

EMFT Texo: using xtend2 for faster generation

Hi!

A month back a Texo user asked me on the newsgroup about the speed of Texo code generation. His proposal was to use xtend2 as the template technology as it is much faster. As often with proposals and ideas, it takes a while, but then suddenly, motivation and time come together and coding starts.

So from today Texo as a default uses xtend2 as a templating technology. This indeed gives a considerable speed increase!

The nice thing is that I managed to still keep the great feature of allowing overriding and/or extending of templates within a development project. You can do this using xpand templates. So the base standard part of Texo uses fast xtend2, if you want to override/extend you use xpand. This is also nice for backward compatibility as your current xpand overriding/extending templates will work fine!

Thanks for reading and I hope this blog post helps to give Texo a try. Visit the Texo wiki for more information. Let me know if you have any questions or remarks on the EMFT newsgroup or forum!

gr. Martin

Taking EMF to the third tier: the Texo JSON Resource

Hi!

After supporting a 2-tier architecture it is now time to make the step to a full 3-tier application architecture for EMF based RCP’s connected to  a standard JPA web server. The server side of this 3-tier architecture was already done earlier: the Texo JSON web service layer. The only remaining topic was implementing the client side: an EMF resource which talks JSON with the server.

Well a first version is available now: the JSONTexoResource. This resource uses JSON to communicate with a server with JPA entities generated from ecore models using Texo.

The nice thing is that the JSONTexoResource transparently works with EMF Proxies. So EMF proxies are automatically resolved by sending a HTTP request to the server and getting the content of the object.

It is easy to override Texo code to add authentication support to the HTTP communication layer. An additional nice feature is that the server side can change/update objects when they are being persisted. Server-side changes are send back to the client (executing the persist action) and merged with the client side objects.

The Texo Resource also support loading objects using queries, counting, retrieving and refreshing individual objects (from the server) and cross-reference queries.

For more information:

• specifics on the JSONTexoResource can be found here
• for setting up the server side is check out this wiki page or see this video.

Thanks for reading and I hope this blog post helps to give Texo a try. Visit the Texo wiki for more information. Let me know if you have any questions or remarks on the EMFT newsgroup or forum!

gr. Martin

EMFT Texo: Auto-generate Java model code on model file changes

Hi!

Next to the work I am doing on an EMF JSON resource, and solving some bugs, I was very motivated to get a nice new feature into Texo: automatic code generation on model file changes.

After each model change you have to go through the somewhat cumbersome right click on a project file and finding the Texo menu to generate your code.

This has now become a lot easier! In the Texo project properties you can now define, that code should be automatically generated when a model file changes. This includes changes to xsd’s and annotation model files.

The project properties allow you to set different things like if only certain model files should trigger a regenerate, or if JPA or DAO classes need to be generated. It is all described here.

So just check the correct flag in the project properties and your code is generated on-the-fly and more importantly: automatic.

Thanks for reading and I hope this blog post helps to give Texo a try. Visit the Texo wiki for more information. Let me know if you have any questions or remarks on the EMFT newsgroup or forum!

gr. Martin

EMFT Texo: EMF – RCP persistence using Texo generated JPA entities

Hi!

After working on Texo JSON Rest, the next step for me has been to implement an EMF Resource which persists its data using JPA annotated entities in a standard ORM.

This makes it possible to use Texo in a RCP environment with an EMF generated front-end and a Texo generated JPA backend.

The first implementation of the TexoResource supports a 2-tier architecture: the JPA TexoResource communicates directly with the database through the JPA/ORM layer.

My next step will be to implement a Texo JSON Resource which communicates using JSON with a server running Texo. The server side of this 3 tier architecture is already done: the Texo JSON web service layer. For an example project running Texo in Tomcat/web container check out this wiki page or see this video.

For this new development I am developing EMF JSON converters, these could be useful also in other solutions, you can find the relevant plugin here in git.

I am cooperating with others to develop an example RCP using Texo. My goal is to provide more example projects. If you are interested in cooperating on this, ping me on the Texo forum.

Thanks for reading and I hope this blog post helps to give Texo a try. Visit the Texo wiki for more information. Let me know if you have any questions or remarks on the EMFT newsgroup or forum!

gr. Martin

EMF Texo: JSON REST web service support, connecting your client to an EMF supporting web-server!

Hi!

As always, Eclipsecon was an inspiration to finally implement those features which I always wanted to do. This time it was implementing JSON REST web service support in Texo. This new feature is based on my experience implementing RIA user interfaces for business web apps.

Texo automatically provides the JSON REST web service support using the ecore/xsd domain model. So with just a few lines of code your domain model is accessible from browser/mobile web UIs.

Why would it be a good idea to try out and use the Texo JSON functionality? Well first it is quite feature complete, supporting full CRUD, querying in multiple ways, individual update/inserts, mass delete/update/insert, proxying, etc. The second good reason is that it is based on real application experience, this explains why attention has been paid to details as querying for multiple values to fill a grid, record counting and object titles. The third good reason: the combination of JSON REST with the other Texo features (JPA entity generation, runtime layer, etc.) makes it possible to have a running feature-complete JSON REST function within a few minutes, generated from an ecore/xsd model.

Texo JSON runs typically in a web container like Tomcat. The example project illustrates how to set this up. After installing/running the solution in a web container, you can for example do these type of uris/queries to retrieve information:

• http://localhost:8080/texo/jsonws/Writer/1
• http://localhost:8080/texo/jsonws/Writer
• http://localhost:8080/org.eclipse.emf.texo.web.example/jsonws?query=select e from Writer e

The first example will retrieve a single object in JSON format, the second all Writer objects and the third example shows how a free-format query can be passed. Security and SQL injection prevention are important topics here to.

Insert/update are supported through POST http methods, deletion is done through the DELETE http method.

Other features of the Texo JSON REST support:

• Paging parameters to support efficient scrolling through a large grid of data
• Setting the number of levels in the containment tree which should be returned
• The proxy concept, references are sent back with a proxy uri, to prevent reading the complete database
• Several ways of doing insert/update
• Combining multiple insert/update/delete actions in one request

As a next step I am considering implementing a few example web apps using client side UI technology as provided by sencha or even try to connect a RCP with an EMF UI to the Texo JSON layer.

Thanks for reading and I hope this blog post helps to give Texo a try. Visit the Texo wiki for more information. Let me know if you have any questions or remarks on the EMFT newsgroup or forum.

gr. Martin

Texo: easy (custom) code generation with EMF merging, code formatting and import resolving

Texo provides code/JPA entity generation from ecore/xsd models specific for web server/service environments. In this post I will discuss how easy it is to extend/override Texo code generation with your own templates. You can even replace the complete Texo code generation with your own templates. Using Texo for your own code generation has some distinctive advantages.

Texo uses XPand as the templating language, the first question is why use Texo and not use XPand directly, well here are several good reasons:

• EMF merging: Texo supports the same merging of manual code as EMF, you can manually change the generated code, manual changes will be retained when regenerating, so if you generate your code with the @generated javadoc tag you will get EMF merging for free (incl. support of merging of annotations etc.)
• Code formatting: Texo makes sure that your code is formatted according to the development project code formatting standards
• Import resolving: an important/difficult topic to solve yourselve, just generate all your code with fully-qualified class names, Texo will do automatic import resolving for you.
• Efficient/Effective: a source file is only touched if it is actually changed by Texo, so your code will not show unneeded diffs, source files which are not needed anymore are automatically removed

All this is available out-of-the box and will work for all your generated code! Now how to extend/override code generation?

Let’s first see how to generate Texo standard code, it is very easy… After installing Texo, right-click any ecore/model and in the Texo submenu choose one of the generate code options.

Texo Entity Generation

Now the next step is to add/override Texo templates, it is a just few steps:

• add the Texo nature to the project

Add Texo nature

• create a folder structure inside your development project, the folder structure must match the template path in Texo
• place your own templates in the folder structur
  

  Texo

Now let’s see an example of a template, here is one which generates a simple subclass of a generic DAO:

«IMPORT org::eclipse::emf::texo::modelgenerator::modelannotations»
«IMPORT org::eclipse::emf::texo::annotations::annotationsmodel»
«IMPORT org::eclipse::emf::ecore»
«IMPORT org::eclipse::emf::texo::generator»

«EXTENSION org::eclipse::emf::texo::modelgenerator::templates::util»

«DEFINE root(ModelController modelController) FOR EClassModelGenAnnotation-»

«LET ((EPackageModelGenAnnotation)this.ownerEPackageAnnotation) AS ePackageAnnotation»

«FILE "org/eclipse/emf/texo/example" + toLowerCase(ePackageAnnotation.name) + "/" + this.simpleClassName + "HbDaoImpl.java" java-»
package org.eclipse.emf.texo.example.daoimpl.«toLowerCase(ePackageAnnotation.name)»;

/**
 * The Dao implementation for the {@link «this.qualifiedClassName»} entity.
 * @generated
*/
public class «this.simpleClassName-»HbDaoImpl extends org.eclipse.emf.texo.example.GenericDaoHbImpl<«this.qualifiedClassName», Long> implements org.eclipse.emf.texo.example.dao.«toLowerCase(ePackageAnnotation.name)».«this.simpleClassName-»Dao
{

/**
 * @generated
 */
 public «this.simpleClassName-»HbDaoImpl(org.eclipse.emf.texo.example.HbSessionProvider sp, org.eclipse.emf.texo.example.dao.DaoFactory df) {
 super(«this.qualifiedClassName».class, sp);
 }

}
«ENDFILE-»
«ENDLET»
«ENDDEFINE»

See that the @generated doc tag is used, this makes it possible to manually change the generated code, and re-generate without loosing your changes.

This was basically it, so it is not more than adding your own templates and tell Texo where to find them.

Thanks for reading! Visit the Texo wiki for more information. Let me know if you have any questions or remarks on the EMFT newsgroup or forum.

gr. Martin