The trick was to get Binding object from current Groovy shell Interpreter and pass it in constructor to Groovy shells that we instantiate programmatically on socket connections. Not sure if it’s thread safe BTW (this isn’t production ready (-: ).

The code is based on Groovy Shell internals a bit, so should probably be run only from Groovy shell. (And just in case – I’m using version 1.8.4 of Groovy).

In any case, here’s again some demo video:

UPD: Also there’s the thread-safe version.
In it each shell will have it’s own Binding object, i.e. separate variables context.
But on creating shell we’ll inject two variables into that context:
- sharedConcurrentMap – an instance of ConcurrentHashMap which will serve as thread-safe shared context for all shells, and is pre-populated with “server” and “sockets” (the latter are also made thread-safe);
- thisShellSocket – a socket that is used for this child shell.

See source code at the end of the post.

As usual, a little demo video:

The source code
1. The non-thread-safe version

server = new ServerSocket(54321);
sockets = [];

serverThread = new Thread() {
    private ServerSocket server;
    private Collection sockets;
    private Binding binding;

    public void run() {

        while(!server.isClosed()) {
            server.accept {
                socket ->
                println "Socket connection established"
                sockets.add(socket)
                socket.withStreams {
                    input, output ->
                        println "Instantiating shell\n"
                        org.codehaus.groovy.tools.shell.Groovysh shell = new org.codehaus.groovy.tools.shell.Groovysh(binding, new org.codehaus.groovy.tools.shell.IO(input,output,output));
                        shell.run("");
                        println "Shell exit\n"
                }
                sockets.remove(socket)
            }
        }
    }

    public Thread init(ServerSocket server, Collection sockets, Binding binding) {
        this.server = server;
        this.sockets = sockets;
        this.binding = binding;
        return this;
    }
}.init(server, sockets, this.binding);

serverThread.start();

2. The thread-safe version

sharedConcurrentMap = new java.util.concurrent.ConcurrentHashMap();
server = new ServerSocket(54321);
sockets = new java.util.concurrent.ConcurrentLinkedQueue();

sharedConcurrentMap.put("server", server);
sharedConcurrentMap.put("sockets", sockets);

serverThread = new Thread() {
    private ServerSocket server;
    private Collection sockets;
    private java.util.concurrent.ConcurrentHashMap sharedConcurrentMap;

    public void run() {

        while(!server.isClosed()) {
            server.accept {
                socket ->
                println "Socket connection established"
                sockets.add(socket)
                socket.withStreams {
                    input, output ->
                        println "Instantiating shell\n"
                        org.codehaus.groovy.tools.shell.Groovysh shell = new org.codehaus.groovy.tools.shell.Groovysh(new org.codehaus.groovy.tools.shell.IO(input,output,output));
                        shell.interp.context.setVariable("sharedConcurrentMap", sharedConcurrentMap);
                        shell.interp.context.setVariable("thisShellSocket", socket);
                        shell.run("");
                        println "Shell exit\n"
                }
                sockets.remove(socket)
            }
        }
    }

    public Thread init(ServerSocket server, Collection sockets, java.util.concurrent.ConcurrentHashMap sharedConcurrentMap) {
        this.server = server;
        this.sockets = sockets;
        this.sharedConcurrentMap = sharedConcurrentMap;
        return this;
    }
}.init(server, sockets, this.sharedConcurrentMap);

serverThread.start();

UPD: A little video demo

Sources (updated 2011-12-16 04:16):

server = new ServerSocket(54321);
sockets = [];

serverThread = new Thread() {
    private ServerSocket server;
    private Collection sockets;

    public void run() {

        while(true) {
            server.accept {
                socket ->
                println "Socket connection established"
                sockets.add(socket)
                socket.withStreams {
                    input, output ->
                        println "Instantiating shell"
                        new org.codehaus.groovy.tools.shell.Groovysh(new org.codehaus.groovy.tools.shell.IO(input,output,output)).run("");
                        println "Shell exit"
                }
            }
        }
    }

    public Thread init(ServerSocket server, Collection sockets) {
        this.server = server;
        this.sockets = sockets;
        return this;
    }
}.init(server, sockets);

serverThread.start();

There must be nicer Groovy syntax for instantiating Threads etc (and yeah, I still instinctively put brackets and semicolons in Java manner), but in general that is it.

Launch it, open some new terminal windows, run “telnet localhost 54321″ in them, and le voila – groovy shells on Telnet.
Note that System.out output is displayed in “master” shell, so whenever you do System.out.println in telnet shells the output appears in “master” shell window – which is kind-of fun (-:

I should find some nice way to share some kind of a context between those shells, so they could share objects with each other (it’s all running in one JVM after all) – then some interesting things can be done with this.

That’s all for now.

Let’s start with an extended example – Web Content, the base of Liferay CMS features.
It is actually mentioned on Liferay Wiki that some time ago Web Content was called Journal or something like this, but at a certain point all related portlets, control panel sections etc got renamed. Yet internally you will find no sings of “Web Content”.
The Java APIs for working with webcontent as well as DB tables are all still using old naming.

Web Content item is JournalArticle, Structure is JournalStructure and template is JournalTemplate.
To manipulate those you would use classes like JournalArticle(Local)ServiceUtil, JournalStructure(Local)ServiceUtil, JournalTemplate(Local)ServiceUtil, and to see them in database you’d have to look up tables also called “journalarticle”, “journalstructure” and “journaltemplate”.

So, let’s move on to our vocabulary:

Well, that’s more/less it. Enjoy.

Well, having worked for a while with it and checking out Groovy now I immediately felt it’s be very interesting to have Groovy there instead of Velocity.

Velocity is sensibly weak in working with arrays and lists. But Groovy on contrary adds more power and convenience in this aspect. And doesn’t seem to be lacking in any other.

It seems someone in 2007 already though about this: http://raykrueger.blogspot.com/2007/07/groovy-views-in-spring-mvc.html

And even more – Grails, the Groovy framework, is actually based on Spring MVC, although this is a bit too much compared to just having Groovy scripts as “views” in Spring MVC.

All in all, it sounds like a good ting to try out.

Anyway…

# University lectures generally don’t change much, and thus can be re-used over time by using recordings (that are updated when necessary) – like Berkeley University did.
Also they can be re-used “in space” by using video-conferencing technologies.

Of-course, some theories are refined etc etc, but in general physics and mathematical analysis lectures remain mostly the same, thus making it reasonable to re-use them over time.
Also physics and math are same, no matter which university (or not even necessarily university) they’re told in.

I see no compelling reason why lectures from one university cannot be re-used in another 10 or 10 000 universities (DRY principle for real world).

Berkeley recordings IMO are a good example how not to make recorded lectures BTW: these should be more presentation/screencast-like I think, certainly not a videotaping of typical lectures in front of live auditory with all the outcoming timewaste (that blabber about attending labs etc is especially annoying in it’s distracting irrelevance).
Also Berkeley 2006 recordings look like early 90-es (-: – a bit weak sound (sometimes problems with it), bleak colours, all this chalk and dusty blackboards etc etc – even whiteboards + coloured markers would be a noticeable improvement.Compare Berkeley recordings to Google Tech Talks for instance, and you’ll know which is the direction to improve as I see it.

There are many different ways to modernize it – think of PowerPoint-like presentations, screencasts, iPad magazines ADs (-; (and flipboard app, heh) etc etc. Lots of space for imagination and experiments.

# Videoconferencing for lectures can be particularly interesting if organized as cooperative lectures, performed by several lecturers from different universities together.

Imagine two (three, four, five…) best specialists/teachers in a field lead a lecture for auditory of millions of students, distributed over multiple universities all around the country/globe, at which local teachers (or professors, title doesn’t matter) are taking over when it comes the time for Q&A (questions & answers) – after cooperative lecture is over.

Of-course, practical part (labs etc) remain local, though can also be performed cooperatively, having, say, groups from 2 universities working together, having different universities each time – that’d be somewhat refreshing and help distributing ideas quicker I reckon.
There are many variants here also – only sky is the limit.

# It’s many years now since video-recording and video-conferencing have become common and quite inexpensive. Unlike it was in 80-es or early 90-es, there’s no need for any special equipment to make (let alone playback) video recordings, or even organize a video conference – every student now has a mobile phone now that can record video, and some smartphones can actually stream it to web where anyone can watch it (see justin.tv and the like).
So there should be no problem experimenting with those until best working practices would be found.

Same/similar practices can be applied to schools and other educational facilities.

# Outro: when my parents were young, television was something new and amazing. When I was younger, Internet was new and amazing. I sincerely envy subsequent generations (-:

Today I’ve written two portlets for this. One allows you to see which groups and pages you have, and check portlets are on those pages.
Another – see what portlets you have, and check on what pages do you have instances of those portlets.

Little warning:
Portlets are pretty fresh, so there’s a chance something might fail or not work quite right.
Also the code is not very efficient, yet I haven’t got any OutOfMemory exceptions during the whole day of writing and checking, so in general they should be fine (-:

Without further due, here’s the download link. Sources are contained inside WAR file.

Portlets are written for Liferay 6.0.6 Community Edition (using corresponding plugins SDK), and should also work just fine on Enterprise Edition (though I haven’t checked yet, I’m pretty sure they will).

WAR is compiled for Java 6, some occasional @Override-s are present in code – remove them and recompile if you need it for Java 5. I might as well change it to Java 5 version a bit later…

One day I just wanted to see on which pages my portlets are used. So I had to make a little query for this:
select portletId, layout.plid, group_.friendlyURL, layout.friendlyURL from portletpreferences left join layout on layout.plid = portletpreferences.plid left join group_ on layout.groupId = group_.groupId where portletId like '%_WAR_[YOUR WAR NAME GOES HERE]%';

If you want to see all of the portlets, you can remove the “where” clause (but be prepared to be overwhelmed with the output).

The results look like this:

+-----------+--------+--------------------+--------------------+
| portletId |  plid  | group_.friendlyURL | layout.friendlyURL |
+-----------+--------+--------------------+--------------------+
| 103       | 704033 | /guest             | /my-community      |
| 145       | 704033 | /guest             | /my-community      |
| 29        | 704033 | /guest             | /my-community      |
| 49        | 704033 | /guest             | /my-community      |
| 86        | 704033 | /guest             | /my-community      |
| 87        | 704033 | /guest             | /my-community      |
| 88        | 704033 | /guest             | /my-community      |
...

Maybe I should make a full-fledged control-panel portlet for this – who knows, it might come handy.

The program has only one dependency - sqlitejdbc-v056.jar, which is a JDBC driver for SQLite databases. Download it from www.zentus.com/sqlitejdbc/ and put in the same folder where my program’s JAR is.

Besides the above-mentioned dependency, my program is just a single JAR file (sources are packed into it). To launch the program simple double-clicking on it should be just enough. If it isn’t, search web for “lanuch JAR” – you’ll find plenty of instructions. You must have Java installed, but that is an obvious thing I suppose.

Here’s the download link: mvmn.ho.ua/dld/sliteblobexp.jar (MD5 checksum = 99ca2488ac62f48721dced3c119d1271).

A small video of it in action: 

Problem: we need to obtain webcontent items by custom query with conditions, one of them being webcontent item type for instance.

The JournalArticleLocalServiceUtil.dynamicQuery(DynamicQuery query) method seems to be just what we’re looking for.

Let’s make a custom query to get 100 latest webcontent items of types “blogs” and “news”. We also add condition on groupId, because we want only items from certain group:

It almost worked. Almost.

We get all versions of webcontent items. What does it mean? When you create webcontent item, it gets a version number 1.0. When you edit it for the first time and save, it gets version 1.1 and so on. This query gets versions 1.0 and 1.1 as separate records.
You cannot just filter out lower versions in your code – you’ll get less than 100 records returned! (And it’s also inefficient of-course).

So, what can we do?

We could resort to native SQL. The query would be something like this:

But can we somehow avoid native SQL calls? Especially considering the fact that we need certain extra effort to be able to make native SQL calls in Liferay portlets.

It turns out that yes, we can. Thanks to http://issues.liferay.com/browse/LEP-6600

Dynamic query is capable of handling correlated subqueries!
So, corresponding code will look like this:

The subQuery is correlated with query by table alias “articleParent” that is referenced in eqProperty(“articleParent.articleId”) clause.

The results seems to work just fine. Yey!

! Important notice: subQuery also uses alias – “articleSub”. It seems unnecessary, as this alias is never referenced. However, removing it leads to weird incorrect results! (I haven"t been digging what exactly was it returning, but I’ve only got 1 record as a result when I removed “articleSub” alias).

This seems to be very weird, and very unpleasant, as it is easy to get caught by this very small change from DynamicQueryFactoryUtil.forClass(JournalArticle.class, “articleSub”, PortalClassLoaderUtil.getClassLoader()) to DynamicQueryFactoryUtil.forClass(JournalArticle.class, PortalClassLoaderUtil.getClassLoader()) that actually should have been completely legitimate.

Maybe I"ll investigate later what difference does it make in queries sent to DB.

That"s it for today.

Today I’ll share some generic practices which I wish I myself knew when I was starting my Liferay experience.


Embedding portlets and webcontent in theme – re-use webcontents and portlets instances on multiple pages
I have a hundred pages in my site, I want to have shared header+footer+navigation present on all those pages. Pretty usual thing to ask, isn’t it? And quite important at the same time.
So how can I do this in Liferay?

It doesn’t have “Books” like BEA Portal has, where you can put pages in one “Book”, and they all ‘ll inherit content from the book. It doesn’t seem to have any similar functionality. So, were stuck? Ready to throw Liferay out to a trash bin? Don’t rush. Though this is indeed a serious shortcoming (actually it must be the most notable one that I’ve encountered in Liferay), there is a remedy to that.

The answer is custom theme with webcontent items or portlets “embedded” in theme itself. It’s not very flexible solution, but it does the job.

Preliminary things – put those to portal-ext.properties:

First one will allow access to some things in Theme velocity templates.
Second one will allow you to create webcontent items with custom (non-autogenerated) IDs, so you could use IDs like “GENERICHEADER” instead of autogenerated numbers (like 12355 or whatever).

So, to the point.
In our custom theme _diffs/templates/portal_normal.vm we define this macro:

And now wherever in this template we want to render some webcontent items, we just add something like:

If hardcoded ID isn’t what you’re really looking for, or for some reason you’re not allowed to disable autogenerated IDs for webcontent, you can do it with Custom Fields (Control Panel: Portal: Custom Fields: Page: Edit). Let’s say we added custom field for pages, with same code – “GENERICHEADER”.
So we put value like 12355 to (default) value of page custom field, and now we just have to modify our macro accordingly:

For a particular details look up JournalContentUtil class.

And embedding portlets in a theme is actually already described on Liferay website

By the way, it’s reasonable to put any reusable stuff into portal_normal.vm. For example, we use some JavaScript code to count statistics of page accesses. The same JS code has to be present on absolutely all pages, so we just put it in the theme’s portal_normal.vm – that simple.

Link Portlet URLs to another page + Configuration action
Liferay has an interesting feature that allows you to make portlet URLs point to other Portal page than the one on which the portlet was rendered. It’s nice to use when you want for example list/details pages for something – you put List portlet on List page, it lists for example company employees. You want employee Details page to open when user clicks on some of employees in a list – how would you do that?

Pretty simple – in “Look and Feel” portlet configuration (a bit weird place for it but whatever) you have “Link portlet URLs to Page” setting, where you can choose the page. Then, if your List portlet, say, renders action URLs, and on action it sends IPC event to details portlet with employee ID, you can now place those two portlets on two different pages – it’s still work. User will click action URL, action will be sent to your List portlet, IPC event from it will be sent to Details portlet, and Details page with Details portlet will be opened. That’s pretty nice.

However, there is one significant downside – if you have an EDIT mode in your portlet, where you display some form with configurations, you’ll see that it submits… to that other page too. And all in all EDIT mode doesn’t look too nice in Liferay.

To remedy that, you can implement Configuration Action for your portlet, and thus have your preferences edited in “Configuration” popup instead of separate EDIT mode.

Liferay website actually has quite detailed description of way to add/implement configuration action – so you probably should look it up there.
One thing to note though is that Portlet Preferences of your portlet aren’t available in Configuration Action in a usual way – instead you have to make a call PortletPreferencesFactoryUtil.getPortletSetup(actionRequest, ParamUtil.getString(actionRequest, “portletResource”)) to obtain them, so don’t miss this.

In-memory time-based caching using Liferay Web Cache Util
That’s a nice facility in Liferay to allow you to cache stuff in memory for a specified period of time.

Let’s say that for example you build a portlet that displays content obtained from some REST webservice by certain URL. We want to cache the response of that webservie. Cache key will be the URL.
Let’s say the API is webServiceClientInstance.getResponse(URL url).

In our portlet we have code like

Let’s create WSCacheItem class that implements com.liferay.portal.kernel.webcache.WebCacheItem:

Now our portlet code changes to this:

The “OurPortlet.class.getName() + StringPool.PERIOD + url.toExternalForm()” part is just to have unique per URL cache key for our portlet.

As for ClassCastException, this little trick is for hot redeploys of portlet, when cached item class is unloaded and new one is loaded – we have to clear cache and re-cache our item.

As you can see, the code isn’t very complex, but the logic for web-service call moves to WebCacheItem implementation convert method.

Custom fields and problem with Document Library documents (DLFileEntry)
This is just a smaller hint, but might save some hours of digging for you.

As you may know, Liferay allows you to define custom fields for different types of Liferay objects, like for Organizations for instance, or for Document Library documents.

If you define custom field “myfield” on Organization, and you call:
organizationInstance.getExpandoBridge().getAttribute(“random”) – returns null, because there’s no field “random” defined;
organizationInstance.getExpandoBridge().getAttribute(“myfield”) – returns value as expected.
Kind of obvious. But… DLFileEntry (document library documents) is very special here.

dlFileEntry.getExpandoBridge().getAttribute(“random”) – returns null, which is expected because there is no custom field “random”.
dlFileEntry.getExpandoBridge().getAttribute(“myfield”) – always returns default value! (like empty string for Text, 1 Jan 1970 for Date etc), which is extremely confusing.

So, how do we get the actual value of custom field for Document Library Document? Well, this way:
dlFileEntry.getFileVersion().getExpandoBridge().getAttribute(“myfield”) – returns desired value.