Posts Tagged ‘GateIn’

New Features in GateIn 3.2 That Will Improve the eXo Platform 3.5 Experience

Wednesday, September 28th, 2011

GateIn is the open source portal framework that serves as the backbone of eXo Platform, and the upcoming GateIn 3.2 will provide eXo Platform 3.5 with a set of great portal features. GateIn 3.2 is a logical evolution of the GateIn 3.1 release; the vision is to improve the project and continue the implementation of what we started with GateIn 3.0. In this post, I will describe a few of GateIn’s numerous new features.

Navigation Controller

The navigation controller is a major change that could be summarized as the decoupling of URL expression and URL processing in GateIn. This means that:

  • URLs processed by GateIn can be easily changed because they are now declared in an XML file
  • Friendly URLs are now supported, giving the portal administrator freedom to configure how http URLs should appear

Desktop Mode

A new Desktop Mode feature was developed for the eXo Platform 3.5 release, and we’ve already updated it to run on top of GateIn 3.2. While providing a desktop experience to your sites, this new feature also gave us an opportunity to polish the UI and bring a few more improvements:

  • Ability to upload desktop backgrounds
  • Revamped dock UI

Site Describability

Sometimes there are features that are difficult to name. We had one in this version of GateIn, which we decided to call site describability. This new feature enhances GateIn’s usability by allowing the administrator to provide a display name and description for a portal site. Here are a couple of screen shots to show you what I’m referring to:

Navigation is an important concept in GateIn that allows web pages to be organized as a hierarchical navigation tree for portals and groups. Internationalization in navigation was supported until now with the help of resource bundles by providing a label containing a specific expression (like ${portal.home} for instance). In some cases this approach is not dynamic enough because, in order to to handle custom resource bundle keys, it requires a resource bundle to be updated when a new navigation node is added.

GateIn 3.2 will include fully dynamic support of navigation i18n. The setup can be done easily in navigation.xml file in a similar fashion of portlet.xml (using the xml:lang attribute to specify a language) deployment descriptor. You can watch a video of this feature on this page.

Of course it is also possible to edit the navigation i18n labels in the user interface:

Portal Public Parameters

As a portlet developer, you often need to extend the GateIn server and create portlets that interact with the environment. So you will likely enjoy this new feature, which allows you to obtain contextual information like the current navigation URI, the current page name and so on. The best thing about this feature is that it leverages the JSR 286 API to get this information in a very intuitive and natural fashion. If you think about it, the most adapted way to obtain this information is via the public render parameter API. This feature is therefore very easy to use, as the only thing you need to do is to declare a specific public render parameter in your portlet XML deployment descriptor. For instance, if you want to obtain the current site name, you will need to declare:


<portlet>
...
<supported-public-render-parameter> site_name < /supported-public-render-parameter >
...
</portlet>

<public-render-parameter>
<identifier>site_name</identifier>
<qname xmlns:prp='http://www.gatein.org/xml/ns/prp_1_0'>prp:site_name </gname>
</public-render-parameter>

And voilà, at run-time you can get the current site name by using the portlet request render parameters, pretty much like:


protected void doView(RenderRequest req, RenderResponse resp) throws PortletException, IOException {
...
writer.println("The current site is " + req.getParameter("site_name"));
...
}

Everything we thought might be useful to a portlet developer to see was done (and if you think that we forgot something useful, don’t hesitate to tell us, or even better contribute it!):

  • navigation_uri: the current navigation URI
  • page_name: the current page name
  • site_type: the current site type (“portal” for portal, “user” for dashboard, “group” for group)
  • site_name: the current site name
  • window_width: the current window width
  • window_height: the current window height

Performance

No major release of GateIn would be complete without performance improvements. In this release we focused on the improving how GateIn loads a site’s navigation tree. The navigation tree used to be entirely loaded from the Java Content Repository and was eventually an issue for sites using a large navigation. Our team worked hard to improve it, and the result is the capability to load navigation fragments instead of the whole tree, while simultaneously keeping the user interface consistent. As a bonus it improved the concurrent edition of the navigation and now we are glad to support concurrent real-time editions of the navigation, as you can see in this video.

Finally

We also made a lot of minor enhancements that will make your life with GateIn better. Here are the ones I think are most relevant:

  • Resource compressor: we provide pluggability for resource compression (JavaScript and CSS), and we integrate the YUI and Google Clojure compressors by default. It works with a system of plugins; if you want to change the configuration you can have a look at the resource-compressor-configuration.xml file. You can even develop your own compressor if you want.
  • A drop-down list for portal or group sites when adding a new page: it’s a minor usability enhancement, yet convenient.
  • A lot of work was done to make the deployment of the WSRP service more modular in JBoss AS, just how it used to be in JBoss Portal.
  • The portlet container session life cycle could sometimes have a lifetime greater than that of the portal, especially when a logout was performed. We fixed this issue, so now a logout on GateIn invalidates pending portlet sessions.

Check out JBoss.org for the latest downloads, and be on the lookout for previews of eXo Platform 3.5…

eXo and Convertigo Accelerate Portal Development with Dynamic Widget Wiring

Tuesday, April 12th, 2011

eXo customers can now ‘widgetize’ existing applications and wire them together for use in the eXo Platform, increasing developer productivity by up to 90 percent

Convertigo to commit widget wiring technology to GateIn portal project, co-led by eXo and Red Hat

SAN FRANCISCO, Calif. (April 12, 2011)eXo, a provider of Java portal and user experience technologies, and Convertigo, maker of server technology to create composite applications and mashups, today announced a partnership to accelerate user-centric development with widgets and gadgets on eXo Platform. As part of this agreement, Convertigo will also be contributing its widget wiring technology to the GateIn project.

Today, portal developers have no easy way to create dynamic widgets or gadgets that can interact with each other, requiring instead time-consuming custom coding. In fact, if developers are using legacy assets, they often need to rewrite all the applications from scratch. The eXo-Convertigo partnership changes all this. eXo will integrate the Convertigo InteractionHub with eXo Platform, enabling eXo customers to easily ‘widgetize’ any application (legacy, modern or third-party), wire them together and put them to work in the eXo environment. The result is customized eXo-based dashboards and a richer user experience for customers — with up to 90 percent less development time and reduced project costs.

News Highlights

Convertigo’s non-intrusive integration capabilities enable developers to capture and expose business processes where they are, and then create, store and share reusable components as “wireable” widgets. As a result, creating dynamic composite applications for private and public clouds or mobile devices becomes much easier.

As part of the eXo-Convertigo agreement, Convertigo is contributing this widget wiring technology to the GateIn project co-led by eXo and Red Hat. GateIn is an open source portal project, created by the merger of eXo Portal and JBoss Portal in 2009. The Convertigo code donation will be integrated into the GateIn code base, which underpins eXo Platform and JBoss Enterprise Portal Platform.

eXo Platform is an integrated user experience platform (UXP) for building and deploying transactional websites, managing web and social content and creating gadgets and dashboards. It lets companies leverage their existing Java infrastructure, while accommodating changing user behavior driven by consumer web technologies such as social networks, social publishing, forums, etc.

Supporting Quotes

Benjamin Mestrallet, founder and CEO of eXo: “Convertigo is steps ahead of everyone else in the market in creating this very rich, dynamic widget-wiring technology for portal environments. Through this partnership, eXo is able to leap ahead as well, and offer our customers a truly amazing user experience. Our ability to integrate Convertigo is a testament to the extensibility and breadth of the eXo Platform.”

Olivier Picciotto, CEO of Convertigo: “We’re thrilled to partner with eXo on bringing our wiring technology to its portal solution. With eXo, we’ve found a partner as focused on delivering as great user experience as we are, and as committed to developing the most cutting-edge technology. It simply made sense to not only collaborate but to also contribute our software to the GateIn project.”

Jason Andersen, director of product marketing for JBoss at Red Hat: “Convertigo provides an elegant solution for widgetizing and wiring applications into the GateIn framework, which in turn simplifies our customers’ experience with JBoss Enterprise Portal Platform. With Convertigo’s contribution of this technology, GateIn becomes that much stronger of a portal foundation.”

Additional Online Resources

Introduction to CRaSH

Tuesday, January 11th, 2011

I’ve just written a new tutorial that gives a technical introduction to CRaSH, an open source project I lead that makes interacting with Java Content Repository (JCR) technology easier. The complete tutorial can be found on the eXo Resource Center – but here’s a sneak peak:

It’s been a year now since I started the CRaSH project. We use Java Content Repository (JCR) technology a lot at eXo, and I realized we all spent too much time and effort trying to interact with content repositories. We needed a tool to make this easier – so I decided to write a shell for JCR. While this new project, CRaSH, started as an interactive shell for browsing, querying and modifying JCR repositories, it has evolved into more than that.

The architecture of CRaSH is founded on two ideas:

  • The capability to serve multiple protocols: telnet and SSH are must-have’s
  • Extending the shell should be easy, and possible at runtime

CRaSH started very simply, so the first usable version took me only a few days to write. In this first version, I remember I used the Netty library to provide connectivity, as it had basic support for the telnet protocol (I didn’t need anything more at the time). I also selected Groovy language for writing shell commands, thinking it was the perfect match for two reasons. First, Groovy is dynamic and easy to compile, and second, you only need a little knowledge of Groovy to begin using it.

Since then, CRaSH has evolved to become richer and offer more capabilities. Netty was dropped because its telnet support was too basic; instead, Wimpi Telnetd and Apache SSHD were adopted to provide a real shell experience. CRaSH benefited from a couple of contributions as well (it’s always nice to have people in the open source community helping you), so it is pretty mature as of the recent 1.0.0-beta18 release (the only missing feature I would like is command line completion).

CRaSH is now a valuable tool to interact with a JVM runtime. The latest release provides two bundles. The first one, the core bundle, can be deployed in any servlet container. The second one is the GateIn bundle, which is built specifically for the GateIn portal server to add a powerful set of JCR features.

In this tutorial, we will focus on explaining basic CRaSH development, and demonstrate this by coding a command that will display a nice list of the JVM system properties.

Continue reading the “Introduction to CRaSH” tutorial on the eXo Resource Center…

eXo Delivers First User Experience Platform for Java

Monday, September 20th, 2010

eXo Platform 3.0 marks the future of Java application development: enterprise content management, collaboration, social and rich UI with enterprise portal capabilities

JAVA ONE (BOOTH #5209), SAN FRANCISCO, CA (September 20, 2010) – eXo today delivered the next generation of its flagship product, eXo Platform 3.0. Architected on the new GateIn portal framework, eXo Platform 3.0 offers the first integrated environment for building modern Java applications with features such as content management, collaboration and social. The product’s features will be showcased this week at Java One (booth #5209).

Why Use eXo Platform 3.0

Enterprises have invested millions in their Java infrastructure, but now those applications are beginning to show their age, especially when compared to the user experience and collaboration driven by the consumer web. End users of Java applications are demanding more than most Java shops can deliver in terms of collaboration, personalization and dynamic content.

“Until now, Java developers have been cobbling together a wide range of ‘best of breed’ software for content management, collaboration or social into their Java systems — because their only other option has been SharePoint,” said Benjamin Mestrallet, founder and CEO of eXo. “You shouldn’t have to throw out our Java investments to get these capabilities. With eXo Platform 3.0, Java enterprises now have a user experience platform for building modern Java apps with rich, interactive and social features — all in a modular architecture that developers are used to.”

eXo Platform 3.0 runs on standard Java middleware, but leverages REST services, Groovy, JavaScript, mashups and gadget-based development to build user-centric Java applications.

What You Can Do with eXo Platform 3.0

eXo Platform 3.0 offers all the capabilities expected of an enterprise portal. It leverages GateIn, the portal framework that eXo co-develops with Red Hat, to build portal-based applications complete with features like access control and single sign-on (SSO) for security.

But eXo Platform 3.0 goes well beyond an enterprise portal to provide:

  • A social intranet: Build an intranet by turning an LDAP directory into an enterprise social network where employees can connect and interact; teams can collaborate in their own online work spaces; and real-time updates and relevant information can be published in activity streams to the right people.
  • An integrated web content management (WCM) system: Quickly build and launch dynamic web 2.0 websites with a full suite of tools, including automated workflow for content publishing, version control and templates.
  • An application development platform for modern Java applications: With a REST architecture and native APIs, eXo Platform 3.0 is an extensible framework for building composite applications quickly and easily. eXo Platform 3.0 includes a web-based IDE for building and integrating applications, gadgets and mashups.

Technical Advantages

  • Unlimited extensibility: Create custom REST APIs on the fly to integrate any third party applications — even from .NET, PHP and other programming languages.
  • GateIn extensions: This new mechanism significantly simplifies application development. Developers can augment and customize GateIn’s features using extensions — without the need to modify the underlying GateIn framework itself. Upgrades to future versions will only require artifacts with the modified files.
  • Powerful and scalable content repository: By keeping applications’ structured data in a content repository, eXo Platform 3.0 provides developers with advanced capabilities that are lacking in traditional databases, including versioning, locking and more. IT operations also benefit from a wide range of management and monitoring functions — all provided in a scalable, clusterable architecture optimized for the consumer web.
  • Extensive open standards and protocol support: These include Java Content Repository (JCR), Java Portlet specification (JSR-286), JAX-RS for REST services and Content Management Integration Specification (CMIS). eXo Platform also implements the OpenSocial specification for gadgets and social APIs for People and Activity.

Availability & Support

eXo Platform 3.0 is immediately available for purchase or with a 30-day trial subscription that includes three support tickets. Download eXo Platform 3.0 today.

Online Resources

eXo Accelerates Modern Java Application Development with Early Adopter Program

Thursday, July 22nd, 2010

Customers can begin prototyping modern Java applications for the forthcoming eXo Platform 3.0 through new program

SAN FRANCISCO, CA (July 21, 2010) – eXo today announced the eXo Early Adopter Program designed to give Java enterprises access to the training and technical resources they need to begin rolling out cutting-edge, rich Java applications built on eXo Platform 3.0. The company’s much-anticipated flagship offer, planned for general availability by the end of the year, has been re-architected with the fast, modern portal framework co-developed by eXo and Red Hat, GateIn.

In recent months, eXo has delivered new and updated community versions of all the key components in eXo Platform 3.0 to run on GateIn 3.0: eXo Social, eXo Content, eXo Collaboration and eXo Knowledge. The Early Adopter Program goes beyond a beta program, and instead offers eXo’s most innovative customers and other Java enterprises a realistic path to modernizing their legacy Java applications.

The training and developer support offered through the Early Adopter Program is designed to help developers begin prototyping a new breed of rich, interactive, social Java applications that can run popular Java environments such as JBoss, Spring, Tomcat or IBM WebSphere. Applications developed today will be compatible with the GA release. These services will be delivered by eXo’s technical product leaders.

Program Details

  • Early access to all updates between now and final GA.
  • Three-hour web-based trainings on all eXo components comprising eXo Platform 3.0.
  • One-year Developer Subscriptions, giving users support on community and beta releases.
  • Discounts on eXo Platform 3.0 Production Subscriptions down the road.
  • Participation in the Early Adopter Program is a one-time $5,000 fee, which can be applied to the future purchase of a Production Subscription.

Supporting Quotes

Benjamin Mestrallet, founder and CEO of eXo: “The enthusiasm we’re seeing for eXo Platform 3.0, even in this early stage, validates the heavy investment we’ve made to deliver the best user experience platform on the market for Java enterprises. The Early Adopter Program, which we initially opened to select customers, has been so well received that we’re opening it up to more enterprises looking for a ‘SharePoint’ of their own that would work with their existing Java systems and make the most of their Java talent. This program puts the power of the eXo Platform in developers’ hands, with a practical roadmap to get them from design and development to production.”

Online Resources