Bloko

POJOs in the Kloud !

2011-10-08T15:23:00.010+02:00

As far as I can remember, deployment of Java webapps on the internet has always been painful. Since the early days of the servlet spec, it's been almost impossible to find cheap and reliable hosting for Servlet/JSP applications.

Good news : those days might be over soon !

With the rise of the Cloud Computing movement, several platforms now exist where you can deploy Java webapps, with various backend services, and pricing models. One of them caught my eye a few months ago, the one from Google, called App Engine.

It's basically a JEE web container (to run your servlets) plus some back-end services for various stuff, from persistence to user management etc.

Rings a bell ?

Looking at the spec, and taking it out for a quick spin, it became immediately apparent that we could actually deploy Woko-based webapps there.

As GAE supports JPA, all we needed was to implement a dedicated ObjectStore backed by Google's JPA provider. And a Stripes interceptor that manages the lifecycle of the EntityManager, a replacement for the OSIV mechanism we already have for Hibernate.

Those were implemented in an hour or so : JPA is very similar to Hibernate for the client API, so writing the base components was really easy.

Then, a bit of fight with the maven pom and maven-gae-plugin. I had to configure a few things as usual, and eventually I had my Woko/GAE project ready. I could run it on my dev server :

> mvn gae:run

And even deploy in GAE :

> mvn gae:deploy

Nothing more to do : the webapp is pushed to Google's infrastructure, and ready to serve requests :
http://test.wokotestbabz.appspot.com/home

I could use the developer role (wdevel/wdevel) in order to create instances of a test POJO and browse them. Stripes, JPA persistence, everything seems to work just fine... Yikes !

Of course, there is room for improvement (full text search, Google user accounts, etc.) but overall it's very encouraging. Deploying Woko apps to GAE is definitly easy, and provides a really cool solution for hosting your apps on the internet at a very low cost (free for small apps), without sysadmin hassles, in an infrastructre that is supposed to scale.

Our next slogan will probably look like "Woko : POJOs in the Kloud !"

Everything is detailed here:
https://github.com/vankeisb/woko2/wiki/GoogleAppEngine

Enjoy,

Remi

PS : for those who have not followed recent developments, we have moved to GitHub for the next release (Woko 2).

JFacets 3.0 is out

2009-04-12T19:50:00.004+02:00

JFacets 3.0 has just been released. Changes include :

Complete rework of the project's structure and dependencies : No third party dependencies are required for Java/XML and Annotated facets. This is great as it allows using JFacets easily without Spring...
Removal of IExecutable interface and executable facets : the use case was too detailed, and can be implemented very easily if you need it, so this feature has been removed from the framework.
Removal of JFacets.get(...) factory methods. They were tightly coupled with Spring, and as we don't depend on Spring any more, the factory methods are not necessary, and the lifecycle of the JFacets instances is now to be handled by the user.
New JFacetsBuilder class for creating instances of JFacets easily, useful e.g. when you don't use Spring or any other D.I. framework.

A tag has been created for this 3.0 version in the SVN repository, and the maven bundles have been submitted for upload in the central maven repository. For now the easiest way to start using JFacets 3.0 is just to checkout the code from the tag, and compile/install it in your maven repository (mvn clean install).

Enjoy !

Rémi

Rich Internet Applications, Woko Style !

2007-10-28T17:24:00.000+01:00

For a while, the idea of exporting Woko managed POJOs into processable formats has been floating around. This way, the data could be accessed not only by human beings, but also by "third party" code easily...

With the growing integration of AJAX and RIA technologies into web applications, the idea has transformed into a requirement. Dynamicity inside the browser has a price : in addition to HTML, you need your webapp to serve some processable infos for your AJAX or RIA client-side technology. Also, beyond export of objects, client applications might need to access more advanced features, like CRUD, search, or custom biz logic.

But wait...

Woko already serves your POJOs as HTML... why wouldn't it serve them as XML, or JSON ?
Woko already allows a human being to access the application's business logic... why wouldn't it allow another program to do it as well ?

XML/JSON POJO Exports

This is now an out-of-the-box feature ! You can now easily export your POJOs to XML or JSON, via the (xml, profileId, targetType) facet.
It's a command facet, so it can be invoked remotely just be sending an HTTP request to the appropriate URL, like :

http://.../myapp/command/Book/123/xml

Default export is available for all Objects and ROLE_WOKO_DEVELOPER, but of course, you can reuse and tweak the output for your own profiles/objects... via facet override, as usual !

Fat Client API

In addition to XML/JSON export, Woko also allows remote applications to access "functionalities" in the application. It proposes a RPC-style API for invocation of all the features in Woko : CRUD, search, and triggering of Command Facets.

In short, a remote client can virtually do everything a human being can do with the application (depending of course of the facet assignation) !

The Killer AJAX/RIA Backend

This is pretty fat news, as you can guess. The "Fat Client API" enables fast and easy implementation of hybrid webapps, where regular HTML is mixed with AJAX widgets, Flash components, Applets etc.

Last but not least, security isn't a problem either. As all the Fat Client API uses facets that you define, the whole system is consistent. Data and services are tailored to the caller's profile, so you hardly publish a service to the wrong clients without noticing it ! Moreover, the "user profiling" principle applies here too : you probably don't wanna provide the same level of features to everybody...

This feature embraces Woko's Web 2.0 and simplicity principles, and makes it a first class choice for people building AJAX/RIA webapps. Forget about writing all those handlers for your XmlHttpRequest objects, they're already there ! You already have all the plumbing for exporting your data, and deploy new RPC services.

Put your POJOs on the Web !

JFacets 2.1 with Instance Facets !

2007-05-21T12:20:00.000+02:00

JFacets 2.1 has just been released, with support for Instance Facets !

Until now, facets were bound to types (Class or Interface), but you could not easily attach a facet to an instance of a given type... Well, now you can, using InstanceFacets !

A new interface has been introduced (IInstanceFacet - javadocs here), that defines a callback method that you have to implement in order to decide if the facet matches the target object or not.

This new release is available for download on sf.net. It doesn't break compatibility, so you can upgrade your jfacets jar without breaking anything to your app.

Enjoy !

WokoTracker demo available

2007-05-20T16:26:00.000+02:00

WokoTracker, a full blown Woko demo, has just been released on sf.net.

It's a simple but functional issue tracker with 3 different roles, that demonstrates some advanced features of Woko, such as :

Custom users (part of the Domain Model)

CRUD features customization (instance-based permissions and the like)

Page Templates and Object Renderer extension

Filtered search, extended results page

Commands on objects

...and more !

JFacets 2.0 released

2007-04-14T22:19:00.000+02:00

JFacets 2.0 has just been released.

Here's the change list :

enabled use of plain POJOs : facets don't even need to implement the IFacet interface any more !

Added a getFacet(facetName, profileId) method to JFacets : allows easier use when you don't need any target object

Added access to the FacetDescriptor used for retrieving the facets from the facet context (deprecated one method in IFacetContextFactory and added a new one)

Added INavigableProfileRepository (and upgraded Acegi integration layer) : enables full nav on the Profiles Graph from IDEs, tools etc.

Refactored WebFacets for greater flexibility (now you can obtain request-scoped JFacets beans from the Spring context, in your Spring apps)

Upgraded Spring version, now uses 2.0.2, but still compatible with earlier versions

Those changes should not break backward compatibility (unless you have developed custom facet context factories etc.), so don't hesitate to upgrade to this new release !

Full sources + maven2 build is available (in a zip) as well as a compiled jar on sf.net downloads (plus demos of WebFacets and Acegi integration).

Also, the core JFacets project is now managed with SVN on sf.net (moved from the CVS).

Enjoy !

Woko 0.5 released

2007-03-08T18:07:00.000+01:00

I've just released a 0.5 of the Woko project template. It includes several enhancements :

Merged ROLE_READ and ROLE_WRITE into a single ROLE_USER as this makes the overall stuff simpler. ROLE_USER is appropriate for demos, or really simple apps only. For more advanced stuff, it's better to extend the profiles graph as you want !

Improved association editing : now you can create new objects and associate them directly to other objects. This is much more user friendly than the previous version where you had to create objects separatly and then associate them.

Localized all messages and texts, and provided a French translation. More languages could be supported easily just by creating new resource files.

Improved search page : now search results are grouped by class, and the score is shown.

Fixed property specific overriding : now it's really easy, and reliable :-)

Included a calendar widget for date properties by default (uses jscalendar)

Fixed some bugs and made small improvements here and there...

The docs in the wiki will be updated soon to reflect the current status of development.

Grab the project template from sourceforge, and enjoy the ride !

Cheers

Remi

JFacets 1.3.6 released

2007-01-07T21:56:00.000+01:00

JFacets v1.3.6 has just been released. It's a minor evolution that includes "behind-the-scenes" enhancements, and maven2-based build.

You can get it from sourceforge, or use maven2 dependencies (thanks to the maven team for uploading the bundle !).

Change list :

Maven2 used for the build in replacement of ant
Profiles cache in the JFacets bean : profiles can be kept in a map for avoiding calls on the ProfileRepository and gain lots of performance (e.g. if your Profile Repository is making calls on some DB). Configurable via Spring using the "useProfilesCache" property.
Lowered some logs (too many INFOs !)
added "dumpFacetsAsXml()" method in JFacets : allows to retrieve a list of all descriptors as XML (can be useful in order to know about active facets and/or to reassign them to other profiles/object types)
MetaFacetDescriptorManager : removed caching of descriptors, this allows to have dynamic facets easier (see Woko's Dynamic DB facets)
Finally created a few unit tests (to be continued) !

Enjoy !

Woko : POJOs on the Web !

2006-12-17T11:25:00.000+01:00

Get Displayed : What's a GUI ?

GUI developement is simple in the concept. Basically, it's all about presenting objects to the end-user, and allowing to interact with them. You typically show a product, show a cart, allow to add products to the cart etc. In the end, if you think about it, the GUI can be seen as a set of views of, and interactions with objects. Views present the objects, and interactions allow to trigger some processes (collaborations between objects) in the Domain Model.

Get Into Troubles : GUI developement is often chaotic...

In practise, it's very often a repetitive and boring task. You usually feel like you reinvent wheels all the time just to get things displayed on the screen... annoying, huh ? OK, you have frameworks and tools that help a lot now, but there's almost no really consistent methodology behind them ! Take RCPs for example : they offer a lot of attractive and useful features to build interfaces, but no-one really tells you how to use these tools in order to build an application. You rarely see the concept of views on objects in such tools, they're ingredients, but you still do the cooking yourself ! Not to mention so called "web frameworks" which mostly have their "proprietary" vision and tools, and all require you to learn a new language and concepts just to get started...

Get Organized : Domain Driven Developement

Let's climb a bit in the abstraction levels, and we find much more interesting stuff, like Naked Objects and other frameworks gravitating around the Naked Objects Pattern (JMatter, RomaFramework, Able, etc.).
Basically, the idea is that objects should be self-descriptive to such an extent that GUIs can be completely generated for them ! You feed the system with some Domain Objects, and you've got the GUI for free ! Doesn't thet sound like a dream ??? It's reality !

Get Profiled : The Woko Way !

Woko inspires from this concept too. It's an Object-Oriented Wiki : it allows to put your objects on the web without the hassle of writing UI code. It heavily relies on facets in order to allow profilized browsing of persistent POJOs without effort.
You simply develop your Domain Model using annotations and POJOs, and Woko displays them out-of-the-box in web pages ! Kinda Wiki-style CRUD : you can browse, create, edit and associate objects together directly in an intuitive and easy approach... You can also search in your objects "a la Google" directly, and have RSS feeds for them !!!

Woko is all about presenting some facets of your objects to end-users based on their profile. This is its major difference with other Domain-Driven frameworks. In Woko, almost everything is facet-driven, which means that you can customize the default rendering of some Domain Objects for some particular user profiles ! And that's what all web application developement is about today : you want information to be shared in a personalized fashion !
Last but not least, you don't "scaffold" or generate code in Woko : you extend it ! You don't have any round-tripping issues, you never overwrite the wrong file... you simply add what you want by extending the appropriate facets for the appropriate Domain Object and User Profile.

Woko is more than an framework, it's a full-stack application skeleton, which bundles a bunch of technologies and frameworks together :

Hibernate + Annotations : Persistence and Domain Model ;
Stripes + Stripernate : Web MVC, FORMs & validation, Hibernate integration ;
JFacets : User profiling ;
Acegi : User authentication, long-term sessions, ACLs ;
Compass : Object-Oriented search engine.

The integration between all these components is almost transparent for the developpers. Of course, you have to understand Hibernate Annotations and JEE webapps to develop Woko apps, but as for the rest, complexity is encapsulated so you often have a very simple answer to your problems.
Developing in Woko is simple : you write Domain Objects, and facetize them for your user's roles !

Get Involved !

Woko is fun : the way you get your objects on the screen in a few seconds is still kinda magic :-)
Woko is disruptive : it completely breaks the model and proposes a new way of building multi-profile, object-and-profile-driven webapps.
Woko is easy : it leverages complex technologies by allowing to use them in a simple way, without even noticing it.

For the moment, it's only a prototype, but it's really promising. We're open to new ideas and contributions, so feel free to speak up !

Try it, and tell us what you think !

JFacets 1.3.5 released...

2006-12-06T20:28:00.000+01:00

JFacets v1.3.5 is available for download on sf.net !

It includes some pretty cool improvements that have been tested in several applications recently.

Change List

Acegi integration : the JFacets core now includes the Acegi integration layer. It revealed very efficient and easy to use, and has now been in use for months without problems. It's now bundled with the JFacets jar for easier use.

fallback profile : JFacets can now default to a fallback profile in case supplied profile is null. For a while, invoking facets for unauthenticated (or guest) users has been painful. You had to manyally check if there was a profile, and decide what to do in this situation (otherwise you had a nice NPE !). With the more and more common use of Acegi as the authentication system, we needed automation there ! So now the JFacets bean can be configured with a fallbackProfileId property, and it'll handle all the null-checks etc ! No profile for the current request ? Fallback profile used :-) This allows to use facets even in the "public" sections of the application without any coding !

@FacetKeyList : you can now have several assignations for the same facet class, when using annotated facets. The @FacetKeyList annotation allows to have several @FacetKey for the same class.

Plus some small improvements here and there, and doc writing (don't get mad, it's still pretty messy in there, sorry for that).

Powered by JFacets !

JFacets has been intensively tested recently, in various situations...

We now use it at work in a WebStarted Swing application where facets are used to create a fully profiled UI (actually some JPanels implement IFacet and own a @FacetKey annotation ! we just load them when creating the UI for the current profile). This was the first real attempt at writing facet-based Swing apps, and it's a really successful one. The programmer (a colleague at CSTB) was amazed with the ease of use of the facets, and I think it saved him a few months of work !
Also, JFacets continues to grow in the web tier, and to power more and more webapps, little by little. The integration with Acegi is really a bless, and the full annotations/taglibs makes facet-based web developement really easy.
Last but not least, on a parallel note, Woko gets really serious now, and opens pretty awesome perspectives in Agile Web Developement ! I'm currently trying to set up a flash demo so that you see it in action, it's really cool stuff, kind of "the stack of your dreams" ??? Stay tuned...

Enjoy this new release !

Remi

PS : I've shut the Sourceforge ML since nobody was using it. A forum should be up and running soon, I'm on it...

Automatic discovery of annotated facets

2006-11-17T15:56:00.000+01:00

As of v1.3.3, JFacets has a new way of writing facets. After Java/XML and Groovy facets, here comes annotated facets !

The aim of this solution is to enable pure Java facets without any external configuration file (let's get rid of the XML facets descriptor). Basically, you can now annotate some Java classes that implement IFacet, with the @FacetKey annotation. You simply specify the facet assignation parameters as attributes of the annotation. A dedicated Facet Descriptor Manager can be configured so that annotated facet classes are loaded from the classpath at startup.

It's a good tradeoff for people who want anto-discovery but don't want to use groovy.

Read more on the wiki

Acegi Authentication

2006-09-18T17:45:00.000+02:00

While working on CMS, I've had a look to Acegi and I really found it simple and nice. So I decided to begin testing with it before going deeper in JAAS...

Since JFacets and Acegi are fully Spring-based, integration has been pretty easy and makes sense ! A single component can be used in order to implement both the ProfileRepository and the UserDetailsService, and both flat and hierarchical roles can be handled.

I've checked a new JFacets2-acegi module in the CVS (an eclipse project) and added a page in the wiki.

Check it out !

Container Managed Security part 2 : exploring users and roles

2006-09-16T10:17:00.000+02:00

I've went again through JAAS docs, and apparently there is no standard API for exploring the users and roles "database" :-/

This is similar with Acegi... You can, from a user principal, get a list of "roles" (bottom-up), but you can't get a list of all roles, get all the users in a given role, etc. (I have posted a question on the Acegi forum but got no answer).

Last but not least, realms have to be configured at the App Server level, and so it's not portable from a container to another...

All this just sucks ! Not only the roles/users structure is flat, moreover you can't get the informations in a standard way !
Man, maybe I should propose the Profile Repository concept to the JCP ;-P

So, for using facets with CMS, one has to implement a specific Profile Repository from scratch, that relies on his own stuff...

Today I'll try to work on a base class that already implements most of the stuff for managing Users and Roles, with a higher abstraction level than the base IProfileRepository interface. This should allow easier implementation of the Profile Repository.

This base class will be used for testing with regular CMS (e.g. JAAS Login Module in Tomcat) and Acegi (custom UserDetailsService).

If testing is successful, I'll include the CMS stuff in 1.3.

Container Managed Security part 1 : authentication

2006-09-15T19:12:00.000+02:00

It's no secret, J2EE webapps can (and should) rely on Container Managed Security (CMS) in order to perform authentication and authorization.

From anywhere in the application, you are able to retrieve the user name :


String userName = request.getRemoteUser();

In typical WebFacets applications, the user profiles are identified by the user's login name... see where we're coming to ? We could use this user name in order to use facets...
An utility class could be used to retrieve the current user's profile, something like :


public IProfile getCMSProfile(HttpServletRequest request) {
  String userName = request.getRemoteUser();
  if (userName==null)
    return null;
  else 
    return profileRepository.getProfileById(userName);
}

And we could also have a filter that automatically loads the profile, for each incoming request.

Here it is for the authentication part. Next to come : mapping the CMS roles to profiles...

Blog Opened

2006-09-15T15:09:00.000+02:00

I've decided to set-up this blog in order to broadcast some infos about my work with (and on) the framework.

More to come soon...

Have fun