R&D blog

Software AG integrates Terracotta Inc. technology across product suite

2012-01-17T08:31:54Z

On the 23rd of May 2011 Software AG announced the acquisition of Terracota Inc. Today we know that the integration of the new tools with existing products - webMethods and Centrasite - was successful.

Terracotta Server Array allowed webMethods to fully utilize cloud environments. Terracota Ehcache greatly improved the performance of CentraSite - according to the provider we should experience a 50% increase in performance:

„Terracotta’s Ehcache caching technology dramatically improves product performance for CentraSite® by up to 50 percent”

With new technologies we not only gain additional performance, but we are also able to run clustered webMethods on Amazon EC2 public cloud.

More information about the inclusion of Terracota's tools in Software AG's products can be found in related articles:

Computerworld (Polish)

Software AG wprowadza technologię in memory, by przyspieszyć pracę aplikacji

BusinessWire (English)

Software AG rapidly integrates Terracotta Inc. technology across product suite in just five months

Software AG has been very active in the takeover market recently. Aside from the aforementioned Terracota Inc., this year Software AG also acquired Metismo Ltd. - a mobile application platform provider. We will see how this acquisition influences existing products.

Creating and maintaining production and test environments in the field of integration.

2011-10-25T14:36:05Z

Creating and maintaining production and test environments in the field of integration - how to make one's life easier by ensuring the highest quality of the environments and their building and updating processes?

Business system integration increasingly often enters various areas of the companies' activities. This development brings not only the increased number of areas where integration is applied. It also makes the integration environments more complex. Among the companies that use integration solutions in their everyday activity we will find numerous examples of businesses that use tens/hundreds of integration servers, as well as various technologies used simultaneously.

Companies that specialize in integration solutions provide complete software to install individual integration servers, but what if the whole integration platform consists of tens or hundreds of machines that work together, when the code, server parameters and their configuration have to be updated on all these machines daily? Of course it is possible to perform all these tasks manually, but does it have to be this way?

Building a complex integration environment through manual installation of individual servers seems to be a very painful process in itself. The whole process is not repeatable, which can result in large divergences on individual machines resulting from human error. Not mentioning the costs and time it takes to complete such process. Machine cloning may seem to reduce the environment installation costs and time, but it can also have unforeseeable consequences, for example, the errors made in the base installation will be propagated onto the whole environment. We do not have any clear list that would tell us what elements compose individual servers and what their configuration is. Looking from the point of view of environment maintenance, we do not have access to the change history of the configuration. We can only hope that the actions performed manually by the administrators were completed meticulously and identically on all the servers. Another problem for very large integration environments is the maintenance of the updated code in the environment. What is meant here is not only the proper update process, but also the downtime of the environments. Imagine 100 testers that idly wait for the environment update or configuration improvement. Costs of such actions are enormous because it is not only the costs of the work performed on the environment, but also all the other costs associated with the unavailability of the environments.

All these arguments convinced BlueSoft that it is necessary to create a tool that would automatically perform all the actions associated with the installation and maintenance of integration environments in a repeatable manner. Such work should be done simultaneously on all the machines that constitute the integration environment. The tool is called Enterprise Deployer. It is designed to support integration environment administrators in everyday activities. It fully automates the installation and maintenance processes, it provides mechanisms for updating code and configuration on servers that work on WebMethods, WebSphere and Tibco technologies. The tool's requirements, the logic it is based on and all the other details were consulted with administrators that take care of integration environments every day. The result of this cooperation is the tool that optimizes and facilitates the work of administrators, at the same time ensuring high quality of the environments, their repeatability, and minimized downtime that results from standard procedures as well as human errors that become apparent when the environment is used. Main advantages of this tool include:

1. Mapping environment structures in the configuration repository (division into editions, areas, environments, servers)

2. Separating the files that define the actions that are to be executed on individual machines from the physical location of the machine, additional services etc. (quick creation of new environments through copying the existing configurations, only the file that contains the physical location needs to be modified)

3. Running various operation sets on any level of the configuration tree with the option to define which operations will be executed (e.g. calling the installation operation from the edition level and all the lower levels, which results in automatic installation of shared elements of the whole edition simultaneous with the installation executed on individual servers).

4. Defining dependencies between the performed operations in the form of clear rules (e.g. blocking any server installation stage until the shared element defined on a different level of the tree is installed).

5. Defining if the grouped operations are to be executed sequentially or simultaneously (in combination with rule definitions it is a very flexible tool that optimizes the time it takes to create and update the environments).

6. Modular approach to the operations the tool can perform (option to add plugins that expand its functionality through a simple interface).

7. Support for integration technologies such as WebMethods, Tibco and WebSphere

8. Simple text interface and complex reporting mechanism that allows the administrator to run automatic window overlay (automatic environment updating along with mail notifications and full reports on general and detailed level).

9. The option to use standard mechanisms offered by svn to verify the configuration of individual elements of integration environments (verification of configuration changes history, comparing configuration of 2 different areas/machines etc.)

RIS Invocation Manager and Tibco BusinessWorks

2011-10-20T08:56:40Z

In the situation where time to market is the key competence of our client and the complex and numerous business workflows make it hard to perform a quick analysis, we need a tool that can collect and easily combine real calls of consecutive layers of the integration platform. Let us now take a look at a few solutions for this problem using Tibco as an example.

The easiest way is to log everything everywhere. Let us look at such solution more closely:

every platform enables putting messages into logs, regardless of the system that is being used;
the person that operates the platform can find consecutive workflow calls;

But there are more cons:

the code is littered by logger calls in inappropriate places. What was good when the code was being written is not always good when performing tests. We can change/introduce additional loggers, but will they perform well in the future? I have seen Tibco processes where there were more logging steps than business logic. Let's all agree that that is not what we are looking for;
performance markup of the left out log entry calls. Nobody is changing the tested code and the exclusion of logging does not clean the code.
if error occurs, the logs will not facilitate debugging. They usually have the wrong format, they do not contain all the required fields and their recovery is time-consuming;
and what if the technical architecture is complex? We know that the message cannot be lost behind the mediation layer. The documentation says that it will reach systems A and B. But the adapters for each of these systems consist of 4 or 5 machines. And the event took place 3 or 4 days ago. We need an efficient grep and know what we are looking for. And still we need to unpack and grep the following: 1 mediation layer log (maybe something didn't work there), 5 logs for each adapter machine X 2 days. That is simply a waste of time of our client;
people responsible for operating the system should enrich their experience with development projects to keep their knowledge up to date. Therefore there is no time to introduce new people to the project;

Income/costs ratio falls below the expected level. But we need information required to analyze the problems.

Let us look for a solution that meets our requirements:

invocations - it has to enable the collection and easy utility of invocations;
transparency - the logic of collecting information cannot modify the present code;
configuration - enabling its modification in an easy and centralized manner
invocation binding - combining any business workflow into 1 string regardless of the machine where the call is to be made using automatic or predefined ID (e.g. order id);
efficiency - tool's markup on the platform is minimal;
speed - the result, as well as input and output of the service should be visible within 3 minutes after the execution

Having these requirements in mind, our R&D team started working on such tool. A tool where the analysis of a given problem could be performed using the browser and Tibco Designer.

RIS Invocation Manager is the result of our work.

It completes all the required tasks. Tibco processes do not contain any additional steps necessary to collect information. A centralized way of saving the configuration enables quick modification without the need to stop or restart the platform and without introducing any other interruptions.

Processing performance tests conducted with RIS Invocation Manager confirm the reliability of the solution with minimal load coming from Tibco BusinessWorks and other components: Tibco EMS, Rv and the database that works with the platform. Further calls are available in the format that is ready to perform debugging on the working code.

Implementation of this solution has significantly shortened the troubleshooting time on the integration platform, reduced the number of analysis mistakes and enabled us to provide proven data for the architects and developers, required in the analysis of the new functionalities.

I invite you to take a look at the product's page.

Order Management

2011-10-20T22:50:16Z

Order Management is a BPM (Business Process Management) system that enables modeling, processing and management of business processes. In most cases, OM systems are not out-of-box solutions, since the architecture of the system is strictly connected to the business process topology in the given company.

An important thing at the stage of OM system analysis in the given company is the choice of proper technology. When selecting the technology, one should consider the following aspects:

Level of complexity of the business processes
Number of simultaneously processes orders
Number of internal systems with which the Order Management system will communicate
Scalability of the solution

When implementing the subsequent versions of the OM system in the company, it is often necessary to raise the version of the orders for which the processing has started in the old version of the code. To do that, it is necessary to thoroughly analyze the impact of each change on the regression in each project. If it turns out that the target solution is not a strictly regressive solution, one should make necessary changes to the orders in progress to properly process those orders.

Main advantages of the OM system:

High efficiency
Low maintenance and development costs
Processing of large number of orders coming in from external systems
Resistant to infrastructure failures
Low costs of adding new sales channel (ordering system)
Low costs of adding new domain system
Addition of new domain system is transparent for ordering systems
Easy configuration of order fulfillment
Flexible architecture and configuration
Scalability of the system
Asynchronous processing mode

Who is the leader on the integration solution market?

2011-10-19T13:50:43Z

In the '90s, the IT market has seen a visible development of technologies used in system integration. After less than 20 years from the appearance of the first, pioneer solutions, they are used every day in many companies, not only the largest ones. Successful implementation of integration solutions that, which are counted in hundreds or even thousands by leading vendors, are often the only way to keep up with the modern markets. In some cases, they can even bring the competitive advantage. A great deal of factors can be quoted that influence this, for example:

faster reaction to frequently occurring changes (external as well as internal)
process approach support in the company
automation, and, as a result, acceleration of process realization.

There are currently a number of companies that provide integration solutions. Although this segment has been very dynamic for the last few years, three providers always lead the rankings (in random order):

These companies are characterized by very extensive experience in the integration product market, as well as the comprehensiveness of the solutions they provide. This can be confirmed by the last reports made by the largest research companies - Forrester and Gartner.

In the report entitles "The Forrester Wave™: Comprehensive Integration Solutions" from the 4th quarter of 2010, the largest providers of complete integration solutions (EAI, BPM, EDI, SOA etc.) were evaluated. The criteria were divided into two groups - "current offering" and "strategy". In addition, the diagram includes the companies' presence on the market (fig. 1).

Figure 1. Forrester Wave - Comprehensive Integration Solutions
Source: Forrester Research, Inc., "The Forrester Wave™: Comprehensive Integration Solutions"

In the first group, the most important criteria that included summarized 110 attributes, were architecture, integration server, BPM, support and application development framework.

In the field of strategy, the costs, product strategy, customer reference checks and strategic alliances were evaluated.

All three aforementioned companies made it to the top of the list. The interesting fact is that the differences between those providers are slight, in many categories even unnoticeable. In the "strategy" group, among the most important criteria, the ratings of the leaders were identical, only the cost of the software turned out to be slightly worse for Software AG. In the "current offering" category, Software AG and Tibco were considered to be the best providers from the architecture point of view, and Tibco Software became the leader in the case of integration server.

As we can see on the diagram, SAG occupies the highest position, although it is slightly moved to the left side due to the cost of its solution. Notice the position of Oracle, which won in the "strategy" category (maximum points for "customer reference checks"). It was, however, rated low for its offer, compared to the three leaders mentioned before.

Gartner included similar evaluations in its "Magic Quadrant for Application Infrastructure for Systematic Application Integration Projects" report. The criteria and scope of research differed from the report described previously. In this case the position on the diagram depended on the "completeness of vision" and the "ability to execute" (more information on the methodology used for evaluation can be found here).

Although the methodology was different, Software AG, Tibco Software and IBM occupy the leaders quadrant (fig. 2). Again, very close to each other.

Figure 2. Gartner’ s Magic Quadrant for application integration technologies vendors
Source: Gartner, Inc. "Magic Quadrant for Application Infrastructure for Systematic Application Integration Projects"

Is there a simple way to choose the best technology? Obviously not. As we can see on the included diagrams, despite the enormity of the research spectrum, the differences in ratings are very small. The completeness of each mentioned solution will surely meet the requirements of business clients. This can be confirmed by a large number of implementations completed by every leader.

In most cases the obvious factor would be the cost of the system's implementation and its maintenance. It is easy to explain to project sponsor.

The second, easily verifiable factor is the availability of providers that specialize in the given technology. Larger selection means easier negotiations for the client - this translates into price again. But what is more important, large base of providers facilitates their change. You should never preclude the possibility that the cooperation will not go perfectly.

Thinking about other factors - efficiency, simplicity of the solution, easiness to introduce a new system analyst etc. I'm getting the impression that their verification is often limited to reading the marketing materials. Pure guesswork. Of course, the providers will gladly prepare the proof of concept in order to confirm the excellence of their solution. However, it can be very time-consuming, so the clients usually don't decide to make a number of PoC's in different technologies to compare them.

However, there is a new field in which the technology providers now compete - business orientation. More emphasis is being put on comfortable and easy modeling, modification and analysis of the implemented processes. It would be best to operate the processes after the successful installation without IT. Business has to pay for IT, so the direction is reasonable, although the resignation from IT is also quite utopian. Aren't we limiting the selection to marketing issues this way?

Getting back to proof of concept - an independent business case, performed in every leading technology, would be very useful. Such materials are most likely unavailable. Maybe we should make such exercise one day...

Consequences of improper use of technologies in application integration and BPM

2011-10-19T14:29:39Z

Integration platform designing and business process modeling require good analytical skills and high competence in technology in which the whole environment is to be implemented. Whether it's Webmethods, Tibco or WebSphere, the analyst has to know the performance limits and restrictions each technology has. It's also impossible to design an application in isolation from programmers' feedback, since wrong decisions made at the stage of analysis will result in slow execution of the application and lack of scalability etc. Worst case scenario is a caricature of a system where every functionality is implemented using components that are not fit for particular tasks.

Too many steps in process

When modeling business processes, a question arises whether the particular task or action is a new activity (results in a new step of the process) or an element of the existing activity. Whether it's BPML model or process implementation in a given technology, processes should be created that consist of low number of steps and that combine similar tasks into one activity. Each step requires the preparation of input data, memory allocation and in general prolongs the duration of the process. If the tasks completed in a given step are short, the performance markup caused by the creation and execution of this step may exceed the time required to perform the target action. It is unacceptable to create sequences of steps of the same type that, for example, process information independently. It is better to aggregate such list into one element of the process. The documentation of each of the aforementioned technologies recommends creating as few steps as possible in the project processes. New step in the process should be created only when a new type of step is required, when processing is split into numerous branches or when joint processing occurs.

Too big input data

When implementing business processes, the most common mistake is saving large quantities of information on the pipeline and forwarding them through the whole process. Each step in the process acquires a lot of data and uses only a small portion of it. It causes a decrease in performance and prolongs the execution of each step. Webmethods and WebSphere technologies enable clearing the pipeline and allow the designer to specify what will be forwarded to the next step in the process. This functionality should always be used and the designer should remember that the less data in the pipeline between the steps the better. Tibco technology does not allow clearing the pipeline . It has a cumulative character, which means that each step acquires the cumulated data from all the previous steps. The conclusion is obvious - long processes will be extremely ineffective since the last steps will acquire large quantities of useless data. The solution in this situation is creating short processes that execute strictly defined tasks.

Other side effects

Oversized pipeline and long processes will cause the integrated environment to run slowly and inefficiently. Out of memory, CPU overload and depletion of connections and thread pool etc. may appear, as well as hard-to-analyze errors caused by the platform overload. For example, Webmethods technology features an error resulting from the loss of transition between the steps in the process. In test environments it was impossible to recreate this problem, since it appeared in random moments when the integration platform was overloaded and lacked resources. After performing an optimization consisting of lowering the quantity of data forwarded between the steps in the processes (documents consisting only of basic types, structure with 2-3 levels), the error no longer appeared and the efficiency of the whole application increased significantly. If the step in a process required more data, it was able to obtain it from the database. In other technologies problems may appear where processes are preemptived if their execution takes too long. This will cause the process to stop and it is not guaranteed that it will start again shortly. It is much better for the processes or services to be executed completely without any interruptions.

Summary

Lack of knowledge in the technology used to create a given integration platform or business processes may cause numerous errors, especially efficiency-related errors. An application created using the technology not meant for its function may meet the functional requirements but its throughput, scalability and further development will be very difficult. When creating a new system, the designer should always thoroughly analyze the technology that is going to be utilized.

Multi-Project management of application development - Meet RIS RM

2011-10-19T12:53:23Z

How to effectively control the production process in a large, integrated environment where the application code is divided into numerous, dependent components that are developed by different vendors and the code is tested on various test environments? Let us think about the solution to this problem. It can be essential to the development of our application. The task is difficult, especially when tight schedule comes into play. Every mistake can cost us a lot of stress and wasted time, which is precious in such moments. How to avoid involving a team of specialists that will watch over the coherence of the whole process? Let's try using RIS RM.

USE CASE

The application consists of 30 components that are interconnected with dependencies. A change made in component X may result in the necessity to update components Y and Z.
The projects are made by 3 providers:
- provider A - a provider with long experience
- provider B - a provider with medium level of experience
- provider C - a provider with little experience - did not participate in application development before
Test environments:
- Automatic test environment - ST
- Integration test environment - INT
- Efficiency test environment - EF

Each environment has its own application code line. These lines are based on the same version of the code - the last release version.

Projects:
- provider A works on 2 projects that introduce new functionalities and modifies existing elements of the application as part of the 3rd project
- provider B improves the efficiency of the application
- provider C works on 1 small project that also introduces new functionalities

POSSIBLE ERROR SCENARIOS

Let us describe a few scenarios that can occur in case of lack of proper monitoring of our application development. The providers work simultaneously on the code, each of them has different goal and experience - this can cause potential errors. One of the basic ones is overwriting changes of one provider by another provider. Referring to our earlier example, the situation can look like this: providers A and C include changes in the X component. Provider C, the less experienced one, needs more time to make the necessary modifications. When C is making changes to the code of the component, A delivers 2 new changes. Provider C, after finishing his changes, updates the code of the component, at the same time removing the 2 last changes made by provider A. As a result, the work made by one of the providers is lost. Best case scenario - the error will come out during the tests and the problem will be solved in a relatively short time. However, it is also possible that A has finished tests of the given functionality and will remain unaware that his changes have been overwritten.

Another source of problems can be the fact that the code is tested simultaneously on more than one environment. These environments have different character and scope of the tested functionalities. Error that can occur here is the wrong change propagation from one environment to another. To put it in the context of our example - provider B works mainly in EF test environment when performing efficiency tests. He introduces frequent but small modifications and the results of the work are periodically reported to the code in other environments. Due to provider B's oversight, part of the modifications made to the applications is not transferred to the code in ST and INT. As a result, his work is not comprehensively tested along with the changes introduced by providers A and C, which causes a relatively high risk that the whole planned optimization will not bring the desired effect.

Various consequences can result from such scenarios, and the situations where further errors occur can be multiplied infinitely: overwriting each other's code by the providers, scope conflicts, erroneous, incomplete change propagation between the test environments, different order of introducing changes into the environments resulting in different versions of the application on parallel branches of the code, developing changes basing on outdated code and many more. How to avoid these situations to minimize the risk of error? Let us see what RIS RM can offer in this area.

RIS RM - SOLUTION

RIS RM supports simultaneous management of multiple projects with independently defined scopes. The application detects and solves conflicts for code delivered by different providers. It also allows easy definition of its workflow.

In RIS RM every change made to the application is submitted by creating a new notification, the co-called release note. It is the only way to deliver code to the test environments. Each release note is associated with the factual change (depending on the type, it can be application code or configuration). Each notification contains the present state, information on the origin, type, scope and full history of the circulation. Circulation of every release note is controlled using a definable workflow, which, with its system of rules and rights, leads the notification through test environments.

Let us now refer to the aforementioned situations where errors occurred and see how RIS RM can handle these problems. In the case where provider C overwrites the changes made in the meantime by provider A - with its scope mechanism, RIS RM automatically detects such events. The conflict is indicated when the code is provided by C in the form of a proper status in the release note. Conflict details appear along with the status, which allows the provider to easily locate the section where the potential overwrite would occur. Complex reporting and notifications allow other parties to observe the event and control the way it is handled.

Second case - provider B does not propagate changes from EF environment to other environments correctly. When working with RIS RM we do not have to worry about such situations - the tool will handle them for us. Changes in the application are submitted through subsequent release notes and then introduced in series or in parallel (depending on the workflow configuration) onto the test environments - no change is lost on the way. With the available reports and notifications we can control the state of development of our application in real time.

In both cases RIS RM stands on guard and does not allow the unwanted situations to occur. Similarly to the aforementioned problems, RIS RM handles a wide spectrum of other potential anomalies associated with code circulation.

SUMMARY

The quoted examples show only a portion of features offered by RIS RM. The tool works perfectly as a mean to organize code provision process in a multi-project environment in a safe, controlled and manageable manner. High configurability and flexibility make it a perfect choice for large as well as small production environments.

MORE INFORMATION

More information can be found at: http://www.bluesoft.net.pl/products/ris/release_mind

How to measure and ensure the quality of the integration code?

2011-10-19T11:16:22Z

People responsible for the development and maintenance of integration platforms often ask how they could measure and ensure the quality of the integration code. While it's easy in the case of Java, there are no globally accepted standards and tools available for platforms such as WebMethods, Tibco or WebSphere to verify the quality of the code. Quality understood as the compliance with the rules of implementation, models and good practices.

Lacks in code quality as defined above may bring numerous potential risks, such as increased costs of code development or problems associated with the change of provider.

Even the most complex and hermetic test process cannot guarantee that the implemented integration code is compliant with the implementation rules and models. A properly organized verification process can ensure the high quality of the code. Automation of this process ensures scalability and utilization of complex validation mechanisms without the need to use massive resources.

I will now present how we used RIS ServiceAnalyser tool to organize such process.

More information about RIS tools can be found here.

Development

Quality verification should start at the stage of development. The developer should possess the tools to verify his or her creation before sending it for testing. At this stage we provide the developers with appropriate plugin or application that verifies the code by presenting the report showing the compliance with implementation models and rules.

Code circulation through test environments

RIS ServiceAnalyser is the integrated RIS Release Mind tool that enabled the developer to organize the code flow through test environments. By integrating these tools we are able to run RIS ServiceAnalyser in “firewall” mode. When this mode is used, the code that is not compliant with the defined rules and models is rejected. With this we can be sure that the potential errors and lack of compliance with the implementation rules will not leave the development environments and move to test environments.

Cyclical code reviews

The last stage of code validation is the cyclical quality review. RIS ServiceAnalyser contains a module responsible for cyclical verification of the production code and presentation of results in the form of appropriately defined benchmarks.

How Liferay Portal boosts crime-prevention effectiveness

2012-01-17T08:59:59Z

Use case

In the beginning of the year 2011 Central Forensic Laboratory of the Polish Police ordered the implementation of web-based application consisting of knowledge base frontend and the database of cars, motorcycles, trucks, lorries, buses and spare parts. This application is now available for police experts accross countries from Central and Eastern Europe. The application is called FAVI (Forensic Aid for Vehicle Identification).

One of the most important and inovative issue was to give police experts the opportunity to build the community for their narrow specialization together with the ability of quick communication and sharing of thoughts and knowledge. Its target user is an expert from toolmark examination unit of the police who is responsible for identification of removed manufacture markings on metal surfaces of vehicle bodies, engines, etc.

Liferay Based Solution

Our solution was designed to be based on Liferay Portal architecture. We chose it because it has built-in plugins and features which makes building a community easier and faster, such as forum, chat, wiki, user profiles. Liferay Portal covers all issues with user account management, groups, roles and permissions, which allows to create the solution for several levels of access. Registered users have the possibility to fill in their profile information which identifies authors of articles and forum messages.

Using Liferay as a base of our solution has let us minimize internal cost and time of the project. Our client estimated one year as sufficient period of time for building the system. We managed to do this in 6 months.

To summarize, the solution uses Liferay features as listed below:

user acconts and profiles, session management
groups, roles, permission, security, authentication, authorization
forum
chat
wiki

FAVI application, which is built as a Liferay JSR-168 portlet, allows experts to build common knowledge base by writing and saving articles with studies on specific vehicles. These articles are instantly visible for other experts. Our implementation of GUI is a Flash text and graphical editor of articles and pictures. Graphical editor allows to:

scale, rotate, format pictures
control of contrast, brightness, transparency of pictures
overlap and compare of several pictures

Beasides graphical features it also has the capability of uploading videos and text documents (word and pdf). We used Lucene as a searching engine, and jackrabbit as a content repository which stores all the information within the knowledge base.

Liferay Portal and Virtual Hosts

During the last phase of the project - the deployment of the system on production environment - we encountered the problem with linking the same instance of Liferay Portal with two different HTTPS domains: first one for the internet and vpn, second for the intranet. The problem was related to the fact that each Liferay Portlet can create URLs in HTTP response independently and in different way. One way of generating URL is by using Virtual Host Name which can be set in Liferay administration console. So, what domain: internal or external should be set in Liferay?

We came to the solution that virtual name should be set to "localhost" and we need to have configured Apache HTTP Server with SSL on the front and with appropriate mod_substitute configuration. In Apache we need to have set two virtual domains with mod_proxy to Liferay Portal. For each of the domain we implemented substitution for URL in Response Body, which substitutes each localhost in URLs. The example is shown below:

<VirtualHost *:443>
  ServerName intranet_domain_name 
  SSLEngine on
  SSLCertificateFile _path_to_certificate_file
  SSLCertificateKeyFile _path_to_private_key

  ProxyRequests Off
  ProxyPass / http://127.0.0.1:8088/ #Liferay is running on the same 
host as Apache HTTP Server.
  ProxyPassReverse / http://127.0.0.1/ #We are using Liferay on Tomcat 
and in server.conf file there is nothing about SSL or domain configuration, 
just localhost is set everywhere
  <Location />
	FilterProvider gzinflate INFLATE resp=Content-Encoding $gzip 
	FilterProvider replace SUBSTITUTE resp=Content-Type $text/ 
	FilterProvider replace SUBSTITUTE resp=Content-Type $/xml
	FilterProvider replace SUBSTITUTE resp=Content-Type $/json
	FilterProvider replace SUBSTITUTE resp=Content-Type $/javascript
	FilterProvider gzdeflate DEFLATE Content-Type $text/ 
	FilterProvider gzdeflate DEFLATE Content-Type $/xml 
	FilterProvider gzdeflate DEFLATE Content-Type $/json 
	FilterProvider gzdeflate DEFLATE Content-Type $/javascript 
	FilterChain +gzinflate +replace +gzdeflate

	Substitute "s|http://127.0.0.1|https://intranet_domain_name|ni"
	Substitute "s|http://127.0.0.1|https://intranet_domain_name|ni"
	Substitute "s|http%3A%2F%2F127.0.0.1|https%3A%2F%2Fintranet_domain_name|ni"
	Substitute "s|http%253A%252F%252F127.0.0.1|https%253A%252F%252Fintranet_domain_name|ni"
  </Location>
</VirtualHost>

blog comments powered by Disqus

Mule ESB - how fast it really is?

2012-01-17T09:07:52Z

Mule ESB highlights

Mule ESB is an Open Source enterprise message bus. It allows message routing, transformation and adaptation between different integration technologies (more information...).

Two things make Mule special among other ESB implementations:

Open standard - Mule ESB is released as an Open Source, but also - XML used to configure Mule services is standarized and available in Mule documentation. This thing alone allows third parties to build Mule-based tools and solutions, such as service generators or service analysers.
Lightweight implementation - Mule combines existing standards and frameworks, such as Apache CXF, Jetty or Apache ActiveMQ in a unique way, building light and agile foundation for deployment of integration services

Use case

One of the enterprise use cases for an ESB is a translation between synchronous client using SOAP over HTTP and asynchronous service, operating over JMS. Such translation should produce as little overhead as possible while maintaining high throughput.

What our test case service did, was:

Receive 64kb message by SOAP over HTTP
Log message to console (Mule's venerable Echo Service)
Send this message to ActiveMQ queue (non-persistent)
Receive this message back from the same ActiveMQ queue using JMS correlation id
Send the message back to the client using SOAP over HTTP.

Such translation layer, can also provide other significant features, such as:

authentication & authorization
error and timeout handling
message logging

Test setup

All tests have been performed using Mule EE 3.1.2, ActiveMQ 5.5.0 and JMeter 2.4. The test machine was Sun Fire X4270, Xeon 2.53GHz (E5540); 4 physical cores, 48 GB RAM (of which 4 GB was used) and all of the software, including JMeter was running on the same machine at the same time.

Test results

We were astounded to find, that Mule ESB (and ActiveMQ) performs very well. Up to 450 req/s, the average delay was around 7-8 ms (including ActiveMQ and client delay). At 450 req/s max delay for tens of thousands of requests was only 78 ms.

The whole setup managed to reach 520 req/s, with average delay of 20 ms.

Test config

Mule service configuration file is really straightforward. We have used Mule service model to simplify our implementation.

Sample soap-config.xml (service definition file deployed to Mule):

	<?xml version="1.0" encoding="utf-8" ?> 
<mule xmlns="http://www.mulesoft.org/schema/mule/core"
      xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
      xmlns:http="http://www.mulesoft.org/schema/mule/http"
      xmlns:jms="http://www.mulesoft.org/schema/mule/jms"
       xmlns:cxf="http://www.mulesoft.org/schema/mule/cxf"
      xsi:schemaLocation="
       http://www.mulesoft.org/schema/mule/core 
       http://www.mulesoft.org/schema/mule/core/3.1/mule.xsd
       http://www.mulesoft.org/schema/mule/http 
       http://www.mulesoft.org/schema/mule/http/3.1/mule-http.xsd
       http://www.mulesoft.org/schema/mule/cxf 
       http://www.mulesoft.org/schema/mule/cxf/3.1/mule-cxf.xsd
       http://www.mulesoft.org/schema/mule/jms 
       http://www.mulesoft.org/schema/mule/jms/3.1/mule-jms.xsd">

    <http:connector name="http_in"
                   validateConnections="false"
                   keepAlive="true"/>
    <jms:activemq-connector name="amq"
                           specification="1.1"
                           jndiDestinations="false"
                           forceJndiDestinations="false"
                           acknowledgementMode="AUTO_ACKNOWLEDGE"
                           clientId="testmq"
                           durable="false"
                           noLocal="false"
                           persistentDelivery="false"
                           honorQosHeaders="false"
                           maxRedelivery="0"
                           cacheJmsSessions="true"
                           eagerConsumer="true"
                           numberOfConsumers="20"
                           disableTemporaryReplyToDestinations="false"
                           embeddedMode="false"
                           brokerURL="tcp://localhost:61616"/>
    <configuration>
        <default-threading-profile
            maxThreadsActive="300" doThreading="true"/>
    </configuration>

    <model name="Async_Request-Response_Message_Pattern">
        <service name="AsyncRequestResponseService">
            <inbound>
                <inbound-endpoint address="http://localhost:8030/hello"
                                  exchange-pattern="request-response"
                                  connector-ref="http_in">
                    <cxf:simple-service/>
                </inbound-endpoint>
            </inbound>

            <echo-component/>

            <outbound>
                <pass-through-router enableCorrelation="ALWAYS">
                    <jms:outbound-endpoint queue="reply.queue"
                                           exchange-pattern="one-way"
                                           connector-ref="amq"/>
                    <reply-to address="jms://reply.queue"/>
                </pass-through-router>
            </outbound>

            <async-reply timeout="4000">
                <jms:inbound-endpoint queue="reply.queue"
                                      exchange-pattern="one-way"
                                      connector-ref="amq"/>
                <single-async-reply-router/>
            </async-reply>
        </service>
    </model>
</mule>

ActiveMQ file only disables persistence for all queues - activemq.xml, JMeter script sends soap requests (64kb file content commented out), logs responses and manages throughput on a desired level - soap-mule.jmx.

The conclusion

It looks like Mule ESB is capable of high performance operation indeed. Average delay of 7 or 8 ms per such operation is a very good result and bodes well for the future of Mule ESB.

blog comments powered by Disqus

Newsletter for Liferay - Newsletter Admin Portlet

2011-10-05T20:48:24Z

The configuration portlet allows the Portal Administrator to manage available subscription categories. In future, such portlet could grow to support subscription administration. As an administrative portlet, Newsletter Admin Portlet is available only in Liferay Control Panel.

For the impatient, the entire solution has been made available under LGPL at GitHub: https://github.com/tlipski/newsletter-for-liferay.

Also, feel free to visit discussion thread on Liferay Forums: http://www.liferay.com/community/forums/-/message_boards/view_message/9856880. In this thread, there are some additional valuable notes and tips provided by other users.

Putting your portlet in Control Panel

Putting portlet in a Liferay's Control Panel requires that you do two things only:

Hide the portlet in Liferay's "Add content" dialogue
Make the portlet visible in Control Panel

Step 1 is optional, but when skipped, requires the developer/administrator to consider setting additional permission restrictions on a portlet (if necessary).

To hide a portlet in Liferay's "Add content" dialogue, you have put your portlet in a special category in liferay-display.xml:

<category name="category.hidden">
    <portlet id="Newsletter Admin Portlet"/>
</category>

To make portlet visible in a Liferay's Control Panel, you have to add additional information about a portlet in liferay-portlet.xml:

<portlet>
    <portlet-name>Newsletter Admin Portlet</portlet-name>
    <instanceable>false</instanceable>
    <ajaxable>false</ajaxable>
    <control-panel-entry-category>content</control-panel-entry-category>
    <control-panel-entry-weight>1</control-panel-entry-weight>
</portlet>

The portlet

The implementation of this portlet is even more straightforward than a Subscription Portlet. Everything is contained inside of class pl.net.bluesoft.rnd.newsletter.gui.NewsletterAdminPane using only 100 lines of code.

The portlet consists of:

Category list - simple VerticalLayout containing one HorizontalLayout per each category (of course, Vaadin's Table could be more applicable when newsletter category could would increase to, let's say - 20 newsletters)
Add new category Button
Category add/edit Window. This Window contains simple form generated by VaadinUtil.simpleScaffoldForJPA method. This method simply takes a Java class and displays edit form for fields specified in a method parameter. The type of Field used to represent each field is determined using JPA annotations. Also, the form is enriched with I18n-enabled labels and captions.

blog comments powered by Disqus

Newsletter for Liferay - Subscription Portlet

2011-10-10T20:32:46Z

The first, and most important portlet in a newsletter application is the Subscription Portlet. This portlet allows users, whether logged-in, or anonymous, to subscribe and unsubscribe from a newsletter configured for this portlet.

For the impatient, the entire solution has been made available under LGPL at GitHub: https://github.com/tlipski/newsletter-for-liferay.

The portlet supports two modes of operation:

PortletMode.VIEW - available to all users, and
PortletMode.EDIT - which enables the portal or site administrator to configure particular instance of this portlet

The modes were enabled for this portlet using <supports> tag in portlet.xml:

The logic controlling which Vaadin controls are displayed is placed inside of Vaadin Application used by this portlet (pl.net.bluesoft.rnd.newsletter.portlets.NewsletterPortletApplication. This Application also accesses Portlet Preferences API, to make used components abstract from Liferay:

	@Override
public void handleRenderRequest(RenderRequest renderRequest,
                                RenderResponse renderResponse,
                                Window window) {
    try {
        this.preferences = renderRequest.getPreferences();
        PortletMode portletMode = renderRequest.getPortletMode();
        if (!portletMode.equals(previousMode)) {
            getMainWindow().setContent(new VerticalLayout());
            if (portletMode.equals(PortletMode.VIEW)) {
                String val = preferences.getValue(NEWSLETTER_CATEGORY_ID, null);
                if (val == null) {
                    getMainWindow().addComponent(new Label("Please configure this portlet."));
                    return;
                }
                long id = Long.parseLong(val);
                NewsletterCategory newsletterCategory = (NewsletterCategory)
                        HibernateUtil.getSession().get(NewsletterCategory.class, id);
                subscriptionPane = new NewsletterSubscriptionPane(newsletterCategory);
                getMainWindow().addComponent(subscriptionPane);
            } else if (portletMode.equals(PortletMode.EDIT)) {
                NewsletterCategory newsletterCategory = null;
                String val = preferences.getValue(NEWSLETTER_CATEGORY_ID, null);
                if (val != null) {
                    long id = Long.parseLong(val);
                    newsletterCategory = (NewsletterCategory) HibernateUtil.getSession()
                            .get(NewsletterCategory.class, id);
                }

                NewsletterSubscriptionEditPane editPane = new NewsletterSubscriptionEditPane(
                        newsletterCategory,
                        new NewsletterSubscriptionEditPane.SaveCallback() {

                    @Override
                    public void onSave(NewsletterCategory newCategory) {
                        try {
                            if (newCategory == null)
                                preferences.reset(NEWSLETTER_CATEGORY_ID);
                            else
                                preferences.setValue(NEWSLETTER_CATEGORY_ID,
                                        String.valueOf(newCategory.getId()));
                            preferences.store();
                        } catch (ReadOnlyException e) {
                            throw new RuntimeException(e);
                        } catch (ValidatorException e) {
                            throw new RuntimeException(e);
                        } catch (IOException e) {
                            throw new RuntimeException(e);
                        }
                    }
                });
                getMainWindow().addComponent(editPane);

            }
        }
        previousMode = portletMode;
        if (subscriptionPane != null)
            subscriptionPane.setUrl(PortalUtil.getPortalURL(renderRequest)
                    + PortalUtil.getCurrentURL(renderRequest));
    } catch (RuntimeException e) {
        e.printStackTrace();
        throw e;
    }
}

Also, an example of Vaadin-Portlet API integration has been provided in the init() method:

	@Override
public void init() {

    final Window mainWindow = new Window();
    setMainWindow(mainWindow);

    ApplicationContext applicationContext = getContext();
    if (applicationContext instanceof PortletApplicationContext2) {
        PortletApplicationContext2 portletCtx =
                (PortletApplicationContext2) applicationContext;
        portletCtx.addPortletListener(this, this);
    } else {
        mainWindow.addComponent(new Label("Please use this application from a Portlet"));
        return;
    }
}

View mode - subscription/unsubscription

The entire view mode is provided in a class pl.net.bluesoft.rnd.newsletter.gui.NewsletterSubscriptionPane (255 lines of code).

The portlet in this mode allows user to provide his/her email address and subscribe/unsubscribe from a newsletter. When a user performs an operation, a confirmation message is sent to a supplied email address. To confirm an operation, user has to invoke a popup window (method displayConfirmationCodeDialog) and enter the confirmation key from received email.

The graphical interface is user-friendly and requires no page refresh thanks to Vaadin. The look of the interface is 100% Vaadin-theme dependent - remember, that you can change the theme used in Liferay's portal-ext.properties configuration file.

Almost all of the mechanisms provided in a previous post about Liferay Newsletter are used in this portlet.

Edit mode - portlet configuration

The configuration view (PortletMode.EDIT) is provided in a class pl.net.bluesoft.rnd.newsletter.gui.NewsletterSubscriptionEditPane - only 89 lines of code, as the functionality is really simple. NewsletterSubscriptionEditPane does not integrate with Liferay directly - it provides a callback interface:

	public static interface SaveCallback {
	void onSave(NewsletterCategory newCategory);
}

//called to save preferences:
addComponent(button("newsletter.subscription.edit.save", new Button.ClickListener() {
		@Override
		public void buttonClick(Button.ClickEvent clickEvent) {
			callback.onSave((NewsletterCategory) categoriesBox.getValue());
			VaadinUtil.displayNotification(getWindow(),
                          "newsletter.subscription.edit.save-succesfull");
		}
}));

//and provided to Portlet Preferences API by NewsletterPortletApplication:
NewsletterSubscriptionEditPane editPane = new NewsletterSubscriptionEditPane(newsletterCategory,
        new NewsletterSubscriptionEditPane.SaveCallback() {

    @Override
    public void onSave(NewsletterCategory newCategory) {
        try {
            if (newCategory == null)
                preferences.reset(NEWSLETTER_CATEGORY_ID);
            else
                preferences.setValue(NEWSLETTER_CATEGORY_ID,
                        String.valueOf(newCategory.getId()));
            preferences.store();
        } catch (ReadOnlyException e) {
            throw new RuntimeException(e);
        } catch (ValidatorException e) {
            throw new RuntimeException(e);
        } catch (IOException e) {
            throw new RuntimeException(e);
        }
    }
});

Conclusion

As you have seen, the newsletter subscription portlet is really simple, yet powerful due to mechanisms provided by Java Portlets API.

blog comments powered by Disqus

Vaadin, Clojure and Google App Engine

2011-10-05T20:56:16Z

Vaadin

Vaadin is a great framework not only for enterprise, feature rich and desktop-like web applications. It can be also used in publicly available web 2.0 applications. And of course, there are many articles on how to use Vaadin on GAE - even on Vaadin.com - http://vaadin.com/wiki/-/wiki/Main/Google%20AppEngine%20HOWTO.

Clojure

But, Vaadin gives us another great possibility - to build our RIA applications on JVM using scripting languages. Clojure is a fine example of how quick the development of solutions on Java platform can be - when one is using a scripting language.

Besides powerful macros,elegant syntax, and easy interaction with Java, Clojure allows us to use REPL interactive console (just like in Python for example) to test and modify our code in a realtime. No more restarts, redeployments, etc. The development can be several times faster than in Java language.

Google App Engine

Google App Engine is a hosting service for building cloud computing applications. GAE introduces several restrictions on deployed applications, but such restrictions would appear in almost any highly scalable solution.

How do they work together?

Pretty great actually, but ss there was no solution combining Vaadin, Clojure and Google App Engine, I have enhanced appengine-magic Clojure library with Vaadin support. The library is available as a GitHub public repository: https://github.com/tlipski/appengine-magic-vaadin.

Sample application looks like this:

blog comments powered by Disqus

Newsletter for Liferay - Introduction

2011-10-10T21:02:08Z

In this post, I will describe basic mechanisms used in Newsletter for Liferay portlets. Such mechanisms can be used as a basis of any Liferay-Vaadin application.

Liferay/Vaadin Integration

The portlet descriptors (JSR168/286 compliant and Liferay specific) are rather standard. One thing worth mentioning is the extension of default Vaadin Portlet implementation:

in web.xml:

<servlet>
    <servlet-name>VaadinPortletServlet</servlet-name>
    <servlet-class>com.liferay.portal.kernel.servlet.PortletServlet</servlet-class>
    <init-param>
        <param-name>portlet-class</param-name>
        <param-value>
            pl.net.bluesoft.rnd.newsletter.portlets.VaadinApplicationPortlet2
        </param-value>
    </init-param>
    <load-on-startup>0</load-on-startup>
</servlet>

and also in portlet.xml (for all <portlet> entries):

<portlet>
    <portlet-name>Newsletter Portlet</portlet-name>
    <display-name>BlueSoft Newsletter Portlet</display-name>
    <portlet-class>
        pl.net.bluesoft.rnd.newsletter.portlets.VaadinApplicationPortlet2
        </portlet-class>
    <!-- ... -->
</portlet>

The other important thing is the ugrade of Liferay's Vaadin widgetset and themes. I have encountered several problems when using Vaadin 6.4.10 on Liferay (default version provided with Liferay 6.0.6), so currently newsletter portlets depend on Vaadin 6.5.4. Anyway every version of Vaadin brings cool improvements and features, so it is always worth to upgrade!

Hibernate Integration

Portlet class mentioned above provides also seamless access to Hibernate Session and coordinates transaction, making it available to Hibernate SessionFactory.getCurrentSession() calls:

protected void handleRequest(final PortletRequest request,
                             final PortletResponse response)
    throws PortletException, IOException {
    Session session = HibernateUtil.getSession();
    try {
        Transaction tx = session.beginTransaction();
        Locale locale = request.getLocale();
        VaadinUtil.setThreadLocale(locale);
        try {
            VaadinApplicationPortlet2.super
                .handleRequest(request, response);
        } finally {
            VaadinUtil.unsetThreadLocale();
        }
        tx.commit();
    } catch (Exception e) {
        session.getTransaction().rollback();
        throw new RuntimeException(e);
    }
}

Of course, in a more complicated environment, Java Transaction API (JTA) should be used. The Hibernate configuration is pretty straightforward - of course more sophisticated deployment should use datasource instead of hibernate.cfg.xml database configuration.

The class pl.net.bluesoft.rnd.newsletter.model.HibernateUtil governs Hibernate SessionFactory as a static field, which is enough in our example. Sample code (NewsletterAdminPane.java) using our Hibernate mechanism:

button("newsletter.admin.edit.change", new Button.ClickListener() {
    public void buttonClick(Button.ClickEvent event) {
        displayEditWindow((NewsletterCategory)
             HibernateUtil.getSession().get(NewsletterCategory.class, cat.getId()));
    }
}),
button("newsletter.admin.edit.remove", new Button.ClickListener() {
    public void buttonClick(Button.ClickEvent event) {
        HibernateUtil.getSession().delete(HibernateUtil.getSession()
             .get(NewsletterCategory.class, cat.getId()));
        loadData();
    }
})

Even though method getSession is called multiple times (and never closed), the implementation uses Hibernate per-thread session scoping. In hibernate.cfg.xml we have:

        
<?xml version="1.0"?>
<!DOCTYPE hibernate-configuration PUBLIC "-//Hibernate/Hibernate Configuration DTD//EN"
"http://hibernate.sourceforge.net/hibernate-configuration-3.0.dtd">
<hibernate-configuration>
    <session-factory>
        <property name="hibernate.dialect">
            org.hibernate.dialect.PostgreSQLDialect
        </property>
        <property name="hibernate.connection.driver_class">
            org.postgresql.Driver
        </property>
        <property name="hibernate.connection.url">
            jdbc:postgresql://127.0.0.1:5432/newsletter
        </property>
        <property name="hibernate.connection.username">
            newsletter
        </property>
        <property name="hibernate.connection.password">
            newsletter
        </property>
        <property name="hibernate.hbm2ddl.auto">
            update
        </property>
        <property name="hibernate.format_sql">
            true
        </property>
        <property name="hibernate.use_outer_join">
            true
        </property>
        <property name="hibernate.cglib.use_reflection_optimizer">
            true
        </property>
        <property name="hibernate.connection.autocommit">
            false
        </property>
        <property name="hibernate.show_sql">
            true
        </property>
        <property name="current_session_context_class">
            thread
        </property>
        <mapping
            class="pl.net.bluesoft.rnd.newsletter.model.NewsletterCategory"/>
        <mapping
            class="pl.net.bluesoft.rnd.newsletter.model.NewsletterSubscription"/>
        <mapping
            class="pl.net.bluesoft.rnd.newsletter.model.NewsletterJob"/>
        <mapping
            class="pl.net.bluesoft.rnd.newsletter.model.NewsletterJobRecipient"/>
    </session-factory>
</hibernate-configuration>

And in HibernateUtil.java we call SessionFactory.getCurrentSession():

public static Session getSession() {
    return sessionFactory.getCurrentSession();
}

Locale support

As you may have noticed, there is some Locale-related code in our custom VaadinApplicationPortlet2. The code simply sets a value of a Locale for the running thread. Portlet container provides us with Locale value in PortletRequest and we propagate it further.

protected void handleRequest(final PortletRequest request,
                             final PortletResponse response)
    throws PortletException, IOException {
    Session session = HibernateUtil.getSession();
    try {
        Transaction tx = session.beginTransaction();
        Locale locale = request.getLocale();
        VaadinUtil.setThreadLocale(locale);
        try {
            VaadinApplicationPortlet2.super
                .handleRequest(request, response);
        } finally {
            VaadinUtil.unsetThreadLocale();
        }
        tx.commit();
    } catch (Exception e) {
        session.getTransaction().rollback();
        throw new RuntimeException(e);
    }
}

This setting is used in pl.net.bluesoft.rnd.newsletter.gui.VaadinUtil utility class, e.g.:

public static String getValue(String key) {
    return nvl(ResourceBundle.getBundle("newsletter-messages",
           nvl(LOCALE_THREAD_MAP.get(Thread.currentThread()),
               Locale.getDefault())).getString(key), key);
}

public static Label label(String key) {
    return new Label(getValue(key));
}

As you can see, standard java.util.ResourceBundle mechanism is used. Language-dependent texts are read from newsletter-messages.properties message bundle. Currently, default texts are in English, but one text is in Polish language. Vaadin allows us to use XHTML code in some cases.

newsletter-messages.properties:

newsletter.subscription.email.prompt=Type in your email address...
newsletter.subscription.info=Please enter your Email address \
and press Subscribe to subscribe to a mailing \
  group or Unsubscribe to cancel your subscription. \
In either case, you will receive confirmation code.
 \
  To enter your confirmation code, please click on the \
I have confirmation code... link.
newsletter.subscription.subscribe=Subscribe
newsletter.subscription.unsubscribe=Unsubscribe
....

newsletter-messages_pl.properties:

newsletter.subscription.email.prompt=Wprowadź adres email...

Default messages are taken from newsletter-messages.properties, but any locale-dependent values can be set in specific properties file.

Vaadin widgets/layout

To make the code short, some of the most commonly used Widgets or Layouts have been provided by simple utility functions (enriched with Locale support where possible). These functions have been grouped in the pl.net.bluesoft.rnd.newsletter.gui.VaadinUtil utility class, e.g.:

public static Label htmlLabel(String key) {
    return new Label(getValue(key), Label.CONTENT_XHTML);
}

public static Button button(String key) {
    return new Button(getValue(key));
}

public static Button button(String key, Button.ClickListener clickListener) {
    Button b = button(key);
    b.addListener(clickListener);
    return b;
}

public static void displayNotification(Window w, String titleKey) {
    displayNotification(w, titleKey, null);
}

public static HorizontalLayout hl(Component... components) {
    return hl("100%", components);
}

public static HorizontalLayout hl(String width, Component... components) {
    HorizontalLayout hl = new HorizontalLayout();
    hl.setSpacing(true);
    hl.setWidth(width);
    for (Component c : components) hl.addComponent(c);

    return hl;
}

example code using such functions and static imports is presented below:

categoriesList.addComponent(hl(
    simpleLabel(cat.getDescription(), "120px"),
    simpleLabel(cat.getNewsletterInfoFrom(), "150px"),
    simpleLabel(cat.getNewsletterInfoMessage(), "180px"),
    button("newsletter.admin.edit.change",
           new Button.ClickListener() {
               public void buttonClick(Button.ClickEvent event) {
                   displayEditWindow((NewsletterCategory)
                                      HibernateUtil.getSession()
                                         .get(NewsletterCategory.class,
                                              cat.getId()));
               }
           }),
    button("newsletter.admin.edit.remove",
           new Button.ClickListener() {
               public void buttonClick(Button.ClickEvent event) {
                   HibernateUtil.getSession().delete(
                         HibernateUtil.getSession().get(
                                NewsletterCategory.class, cat.getId()));
                   loadData();
               }
           })));

Mailing support

Sending of emails is provided on the basis of Liferay API. Class pl.net.bluesoft.rnd.newsletter.mailing.MailingHelper uses this API in a rather straightforward manner:

package pl.net.bluesoft.rnd.newsletter.mailing;

import com.liferay.mail.service.MailServiceUtil;
import com.liferay.portal.kernel.mail.MailMessage;

import javax.mail.internet.InternetAddress;

...

public void sendEmail(String rcpt, String from, String subject,
                      String body, boolean sendHtml) {
    try {
        MailMessage mailMessage = new MailMessage();
        mailMessage.setBody(body);
        mailMessage.setHTMLFormat(sendHtml);
        mailMessage.setFrom(new InternetAddress(from));
        mailMessage.setTo(new InternetAddress(rcpt));
        mailMessage.setSubject(subject);
        MailServiceUtil.sendEmail(mailMessage);
    } catch (Exception e) {
        throw new RuntimeException(e);
    }
}

This approach allows us to use only one SMTP/javax.mail configuration.

Message templating

Some entries from newsletter-messages.properties are used when sending technical emails to the user (e.g. email confirmation). Simple String-based mechanism is used:

private String expandTemplate(String templateKey, String[]... vars) {
    String tmpl = getValue(templateKey);
    for (String[] var : vars) {
        tmpl = tmpl.replace("${" + var[0] + "}", var[1]);
    }
    return tmpl;
}

Which is sufficient for our example, but of course could be replaced by a Freemarker templating mechanism in a future.

blog comments powered by Disqus

Enterprise Applications for Liferay - made easy with Vaadin

2011-10-10T21:03:36Z

Liferay is a great enterprise portal with many pre-built features and options. One feature, that is still missing from Liferay default bundle is a Newsletter Portlet.

In the following posts, I will demonstrate how easy it is to build enterprise-grade solutions with Liferay and one of the best RIA frameworks - Vaadin on the example of a Newsletter Portlet. The Java code is very short (for Java standards at least) - only 1403 lines.

The solution uses simple Hibernate/JPA classes to provide persistency and supports multilingual (i18n) deployments using java.util.ResourceBundle mechanism. Sending emails is done using means provided by Liferay - com.liferay.mail.service.MailServiceUtil.

For the impatient: Newsletter Portlet has already been developed and tested and is available under GNU LGPL at https://github.com/tlipski/newsletter-for-liferay.

If you have any comments or questions, do not hesitate to contact me at: tlipski@bluesoft.net.pl.

Subscription Portlet

Subscription Portlet can be available to all users - whether logged in or not. User can subscribe or unsubscribe and confirm the operation using token received by e-mail.

R&D blog

Software AG integrates Terracotta Inc. technology across product suite

Creating and maintaining production and test environments in the field of integration.

RIS Invocation Manager and Tibco BusinessWorks

Order Management

Who is the leader on the integration solution market?

Consequences of improper use of technologies in application integration and BPM

Too many steps in process

Too big input data

Other side effects

Summary

Multi-Project management of application development - Meet RIS RM

USE CASE

POSSIBLE ERROR SCENARIOS

RIS RM - SOLUTION

SUMMARY

MORE INFORMATION

How to measure and ensure the quality of the integration code?

Development

Code circulation through test environments

Cyclical code reviews

How Liferay Portal boosts crime-prevention effectiveness

Use case

Liferay Based Solution

Liferay Portal and Virtual Hosts

Mule ESB - how fast it really is?

Mule ESB highlights

Use case

Test setup

Test results

Test config

The conclusion

Newsletter for Liferay - Newsletter Admin Portlet

Putting your portlet in Control Panel

The portlet

Newsletter for Liferay - Subscription Portlet

View mode - subscription/unsubscription

Edit mode - portlet configuration

Conclusion

Vaadin, Clojure and Google App Engine

Vaadin

Clojure

Google App Engine

How do they work together?

Newsletter for Liferay - Introduction

Liferay/Vaadin Integration

Hibernate Integration

Locale support

Vaadin widgets/layout

Mailing support

Message templating

Enterprise Applications for Liferay - made easy with Vaadin

Newsletter Sending Portlet

Newsletter Admin Portlet