Jboss Boss AS Ent. 4.3.0.G.A

LifeRay Portal 4.4.2

MySql 5.0.45 community

(Linux and Windows almost use the same setting steps)

1. run the Jboss AS installer to install it.

Windows : double click

Linux : terminal>java -jar enterprise-installer-4.3.0.GA-1.ep1.8.jar

2. install MySql from its installer.

3. download 3 files of liferay :

liferay-portal-4.4.2-with-dependencies.war

liferay-portal-dependencies-4.4.2.zip

liferay-portal-sql-4.4.2.zip

4. create an utf-8 database in your mysql, I use lportal as database name here.

mysql>create database lportal character set utf8;

5. unpack liferay-portal-sql-4.4.2.zip, import the database dump under [unpack]/create-minimal/create-minimal-mysql.sql

mysql -uroot lportal < [path from above]/create-minial-mysql.sql --default-character-set=utf8

6. open [JBOSS_HOME]/jboss-as/server/default/deploy/jboss-web.deployer/conf/web.xml

Replace :

<servlet>
<servlet-name>default</servlet-name>
<servlet-class>org.apache.catalina.servlets.DefaultServlet</servlet-class>
<init-param>
<param-name>debug</param-name>
<param-value>0</param-value>
</init-param>
<init-param>
<param-name>listings</param-name>
<param-value>true</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

With :

<servlet>
<servlet-name>default</servlet-name>
<servlet-class>org.apache.catalina.servlets.DefaultServlet</servletclass>
<init-param>
<param-name>debug</param-name>
<param-value>0</param-value>
</init-param>
<init-param>
<param-name>listings</param-name>
<param-value>false</param-value>
</init-param>
<init-param>
<param-name>input</param-name>
<param-value>4096</param-value>
</init-param>
<init-param>
<param-name>output</param-name>
<param-value>4096</param-value>
</init-param>
<load-on-startup>1</load-on-startup>
</servlet>

7. create [JBOSS_HOME]/jboss-as/server/default/deploy/liferay-ds.xml

<?xml version="1.0"?>
<datasources>
	<local-tx-datasource>
		<jndi-name>jdbc/LiferayPool</jndi-name>
		<connection-url>jdbc:mysql://hostname:3306/lportal</connection-url>
		<driver-class>com.mysql.jdbc.Driver</driver-class>
		<user-name></user-name>
		<password></password>
		<min-pool-size>5</min-pool-size>
	</local-tx-datasource>
</datasources>

8. Download mysql-connector-java-5.1.5-bin.jar, copy to [JBOSS_HOME]/jboss-as/server/default/lib/

9. Unpack liferay-portal-dependencies-4.4.2.zip to [JBOSS_HOME]/jboss-as/server/default/lib/

resulting structure will be like this :

[JBOSS_HOME]/jboss-as/server/default/lib/liferay-portal-dependencies-4.4.2/portlet.jar

/portal-kernel.jar

/portal-service.jar

10 .Setup mail properties, open [JBOSS_HOME]/jboss-as/server/default/deploy/mail-service.xml

modify : User, Password, pop3.host, smtp.host, mail.from

11. Open [JBOSS_HOME]/jboss-as/server/default/conf/login-config.xml, comment out the entire <application-policy name="other">

12. unpack liferay-portal-4.4.2-with-dependencies.war, rename the unpacked folder to liferay-portal.war

Move dom4j.jar, jaxen.jar from liferay-portal.war/WEB-INF/lib to [JBOSS_HOME]/jboss-as/lib

Move commons-collections.jar from liferay-portal.war/WEB-INF/lib to [JBOSS_HOME]/jboss-as/server/default/lib (overwrite it if it is already there)

remove hibernate3.jar, jboss-hibernate.jar from [JBOSS_HOME]/jboss-as/server/default/lib

Move liferay-portal.war to [JBOSS_HOME]/jboss-as/server/default/deploy/

13. open [JBOSS_HOME]/jboss-as/server/default/deploy/jbossjca-service.xml

change <attribute name="Debug">true</attribute>

to <attribute name="Debug">false</attribute>

14. open [JBOSS_HOME]/jboss-as/server/default/deploy/jboss-messaging.sar/destinations-service.xml

clear all text between <server></server>

15. open [JBOSS_HOME]/jboss-as/bin/run.conf

modify the JAVA_OPTS setting to this one

      JAVA_OPTS="-Xms256m -Xmx512m -XX:MaxNewSize=256m -XX:MaxPermSize=256m -Dsun.rmi.dgc.client.gcInterval=3600000 -Dsun.rmi.dgc.server.gcInterval=3600000"

16. But in my experience, JBoss Ent. may not pick up this setting in windows, so

Windows : open [JBOSS_HOME]/jboss-as/bin/run.bat

find : rem JVM memory allocation pool parameters. Modify as appropriate.

change the line follow this one to

set JAVA_OPTS=%JAVA_OPTS% -Xms256m -Xmx512m -XX:MaxNewSize=256m -XX:MaxPermSize=256m

17. start Jboss AS, beware that there are more then one AS : All, default, minimal, production.

The one we setup is default, you can start by

Windows : [JBOSS_HOME]/jboss-as/bin/run.bat -c default

Linux : [JBOSS_HOME]/jboss-as/bin/run.sh -c default

18. open http://localhost:8080, you should see liferay running

19. change the Jboss AS to allow remote connection and bind to port 80

open [JBOSS_HOME]/jboss-as/server/default/deploy/jboss-web.deployer/server.xml

change :

    <Connector port="8080" address="${jboss.bind.address}"
         maxThreads="250" maxHttpHeaderSize="8192"
         emptySessionPath="true" protocol="HTTP/1.1"
         enableLookups="false" redirectPort="8443" acceptCount="100"
         connectionTimeout="20000" disableUploadTimeout="true" />

to :

    <Connector port="80" address="0.0.0.0"
         maxThreads="250" maxHttpHeaderSize="8192"
         emptySessionPath="true" protocol="HTTP/1.1"
         enableLookups="false" redirectPort="8443" acceptCount="100"
         connectionTimeout="20000" disableUploadTimeout="true" />

Then reboot JBoss AS.

http://nerdnotes.wordpress.com/2007/03/30/basic-transactions-in-spring-using-transactionproxyfactorybean/

ServiceBuilder

http://wiki.liferay.com/index.php/Services%2C_entities%2C_and_ServiceBuilder

http://www.javalobby.org/articles/thread-safe/index.jsp

http://www.sleberknight.com/blog/sleberkn/

Unable to resolve the issue of Hibernate session not bound to thread in Liferay when creating a new persistence class extending basePersistence. Guess I would need to read up on spring hibernate configuration for tx mgmt.

Until then would use PortalJNDIUtil for the DataSource.

Really I thought I could solve the Hibernate issue - but its been almost a day now and no solution found,. Need to move on - would come back on this later:

[sourcecode lang='xml']

[/sourcecode]

The configuration of Service classes and Persistence classes in portal-spring.xml is as follows:
================================
LSLocal.iLS.mpl - nothing
LSLocal.Tx - TxMgr,Target (LSLocal.impl),TxAttr
LSFactory - svc - LSLocal.Tx
================================
LS.impl
LS.Tx - LS.impl
LSFactory - svc LS.Tx
================================
LSPersis.Impl
LSPersis.Tx - Target - LSPersis.impl
LSUtil
================================

http://www.liferay.com/web/guest/products/portal/architecture/spring_hibernate
http://www.javalobby.org/articles/thread-safe/index.jsp
http://www.ibm.com/developerworks/web/library/wa-spring2/
http://www.sleberknight.com/blog/sleberkn/

To show the tags in the journal content portlet:(Code from liferay forum)

==============================

#set ($tagsService = $serviceLocator.findService("com.liferay.portlet.tags.service.TagsAssetLocalService"))
#set ($journalArticleResourceService = $serviceLocator.findService("com.liferay.portlet.journal.service.JournalArticleResourceLocalService"))

#set ($longGroupId = $getterUtil.getLong($groupId))
#set ($articleResourcePK = $journalArticleResourceService.getArticleResourcePrimKey($longGroupId, $reserved-article-id.data))
#set ($tagsAsset = $tagsService.getAsset("com.liferay.portlet.journal.model.JournalArticle", $articleResourcePK))
#set ($tagsEntries = $tagsAsset.getEntries())

Tags:
#foreach( $entry in $tagsEntries )
#set ($tag = $entry.getName())
#if($velocityCount!=1), #end
$tag#end

CTO of Alfresco and Documentum Co-Founder John Newton blogged on the deal recently. He took the opportunity to claim that this kind of relationship shows content management to be on par with database technologies where integrations and OEM relationships are concerned. That position may be a bit optimistic. If anything, the arrangement is a testament to the good job Alfresco has done delivering on the promise of commercially viable open source content management. To get where John wants to go, the industry has to mature around real standards. (insert applause from Pie here)

The whole idea of an OEM relationship is to enhance not overwhelm the product that is including your software. I don't know all of the reasons that EMC elected to OEM the 5.x code level rather than D6 but from my experience, D5 is much easier to run on a laptop. Anyone who has worked with D6 understands that the footprint of the platform is more Sasquatch-like than ever.

I suppose the party line my be they want to maintain a degree of competitive advantage by not making the D6 capabilities part of the OEM product but something tells me they tried it and quickly passed the point of diminished return in the effort. There is simply too much baggage to overcome.

I've spent a good deal of time in the last few months working with LifeRay. They truly get the open source to OEM model and have a number of successes to show for it. There is even a LifeRay-Alfresco bundle that is very handy. Adobe itself is not a stranger to content management as they have their own light weight WCMS. When it came to enterprise class CM they have heretofore relied on the likes of Documentum. Now LiveCycle is very much a one-stop shop for this class of forms management.

If everything works as advertised, It will become more difficult over time justifying complex Documentum integration for LiveCycle if you can remain in the boundaries of the platform. For others looking for a CMS to OEM and they need it PDQ to get ROI - (sorry about that) - Alfresco now has a marquee reference that's impossible to ignore.

So how does the portal determine what permissions to grant each user? In Liferay, permissions can be associated with a user in a few different ways. The permission can be assigned directly to a user or it can be inherited through the hierarchy of groups (with the assigned permission of course) that the user belongs to. Permissions can also be assigned to a role which then passes it on to whichever user or group has that role. Yes, quite verbose but very powerful. The PermissionChecker is where all this heavy lifting occurs and where we actually determine whether a user “has permissions” to perform certain actions. A PermissionChecker is created or borrowed from a pool and placed in the thread local and themeDisplay object on every request.

The implementation can be swapped out for your own class by extending com.liferay.portal.security.permission.PermissionCheckerImpl and overriding the necessary methods to implement your own functionality. Remember to specify your class name in portal.properties for the property permissions.checker.

Now let’s look at an example of how the PermissionChecker is used in a simple case where we want to add a new page to a community layout set. We start this explanation from within the Communities Portlet lifecycle. We’re adding a new layout to the layout set of a Community group so a process action request gets served by EditPagesAction which is just a struts action class. The first thing that happens is a check permissions call which uses the PermissionChecker to determine whether the user has the rights to perform the action MANAGE_LAYOUTS on targeted layout set of the community group. You will see permission checks like this all over Liferay’s view and service layer classes whenever we try to perform an action on a portal object. An example of what this check might look like:

GroupPermissionUtil.contains(permissionChecker,group.getGroupId(), ActionKeys.MANAGE_LAYOUTS)

As mentioned earlier, a user can inherit a permission from a hierarchy of groups that the user belongs to or a role that is directly or indirectly associated with the user. This hierarchical complexity is handled by a class within the PermissionChecker called the PermissionCheckerBag. So what’s in the bag? On first call to perform an action the bag is actually empty (null to be technically correct). Based off the user id we grab all the Organizations and UserGroups that the user belongs to along with the corresponding Groups since all these “containers” are also represented as Groups. We also obtain and throw in the roles as well. You can think of the PermissionCheckerBag as a container for all the user’s Group and Role associations per community and also contains helper (permission shortcut) methods that determine whether a user is a community owner or admin. This object is stored for the remainder of the request and discarded when the PermissionChecker is returned to the pool. (For performance reasons we should cache this object for the entire user session. This issue is now http://support.liferay.com/browse/LEP-6273). This class can also be extended as the implementation class com.liferay.portal.security.permission.PermissionCheckerBagImpl is only used in PermissionChecker.

Now that we have the PermissionCheckerBag inside the PermissionChecker we are ready for the next step of the process, checking the bag's groups and roles for the permission to perform the action MANAGE_LAYOUTS. As with all service calls in Liferay this one begins with a *ServiceUtil helper class, in this case PermissionServiceUtil which is used to obtain the proper service via Spring. This service class can be easily swapped out in portal-spring.xml if so desired. The utility uses PermissionServiceFactory to get the PermissionService bean and its default implementation com.liferay.portal.service.impl.PermissionServiceImpl or a class that you implement yourself. In our example for adding a layout to the community layout set we first need to start by getting a list of resources scoped for Individual, Group, Group Template and Company through another service helper ResourceLocalServiceUtil (lets leave this service alone unless you are planning to offload resource management to another datastore). Resources identify the target object that you are trying to “MANAGE_LAYOUTS” on. Now with this list of resources and the PermissionCheckerBag we can do a check for the permissions we are looking for. The actual call looks like this:

PermissionLocalServiceUtil.hasUserPermissions(user.getUserId(), groupId, actionId, resourceIds, bag)

This PermissionService contains the bulk of the logic for Liferay permissions and brings together all the data gathered up to this point to perform the required queries. This call is made from the PermissionChecker and can also be customized to implement your own authorization logic if required. Again, just swap out the service implementation.

Let’s look at some of the SQL calls used to figure out permissions for a user to add a layout. First we want to find all the Permissions for the action we are performing on the resource.

SELECT {Permission_.*} FROM Permission_ WHERE (actionId = ?) AND (resourceId = ? OR resourceId = ? OR resourceId = ? OR resourceId = ?)

Once we have all the Permissions for the action and resource we want to check to see if any of the user associations either directly or inherently has the permission. We do this via the PermissionFinder which is helper class for performing custom SQL calls for permissions. The PermissionFinder performs a custom SQL based on the permissions.user.check.algorithm specified in portal.properties and returns true if the user has an association to the permission. Of course these SQL calls are made once before they are cached in the portal for subsequent requests.

So there you have it. PermissionChecker Explained. In case anyone was wondering.

]]> http://vbizet.wordpress.com/?p=74 Tue, 10 Jun 2008 09:47:20 +0000 Admin http://vbizet.wordpress.com/?p=74 Etant Webmaster, je suis amené à utiliser les dernières technologies web pour réaliser des sites.
En février 2008, je me suis penché sur un CMS qui commence à s'étoffer : Liferay.

Malgré des premiers réglages qui peuvent poser problème et une navigation parfois pertubante (onglets de couleurs différentes sans être sélectionnés), le résultat peut être assez bon, si l'on possède toutes les cartes : il faut tout de même installer quelques modules supplémentaires pour profiter pleinement de l'application.

En effet, le réglage de certains "portlets" (les modules) sont inexistants : j'aurais, par exemple, bien aimer choisir quelle banque d'image afficher sur telle page ou ne pas avoir à ré-importer le document quand j'en change la description !

Même si les CMS ont la réputation d'avoir le juste minimum, Liferay compense par ses graphismes très 2.0.

Un annuaire	Une base documentaire	Un calendrier
Gestion des articles (contenus des pages)	Une banque d'images (avec miniatures !)

Liferay manque donc d'intuitivité et de fonctions mais reste prometteur.

Pour mieux vous en rendre compte, vous pouvez tester la démo

So first all css files are merged into one by the CSSBuilder and then compressed using the YUi-C.

http://developer.yahoo.com/yui/compressor/

[sourcecode lang="xml"]

classname="com.liferay.portal.tools.CSSBuilder"
classpathref="portal.classpath"
fork="true"
newenvironment="true"
>



classname="com.yahoo.platform.yui.compressor.YUICompressor"
classpathref="lib.classpath"
fork="true"
newenvironment="true"
>

[/sourcecode]

Uuden yksikön johtaja Tuija Wickström kommentoi uuden yksikön painopistettä:

Valtaosa liikevaihdosta ja tuotoista verkossa syntyy mainonnasta, minkä takia panostamme uusiin mainonnan ratkaisuihin sekä verkkomediamyyntimme kehittämiseen. Sen lisäksi olemme aloittamassa yhteistyötä Sanoma Digitalin Verkkomediamyynnin kanssa.

Uudet Akuankka.fi, Perhe.fi ja Vauva.fi nojaavat paljolti yhteisöllisyyteen ja käyttäjäkeskusteluihin. Jonkin verran palveluissa on myös blogeja ja lehtien nettijatkoja. Vauva.fi ja Perhe.fi vaikuttavat konsepteiltaan kovin samantyyppisiltä. Akuankka.fi on sitten selkeästi nuoremmalle väelle suunnattu "tarinamaisempi" verkkopalvelu jossa myös erilaisilla peleillä ja kilpailuilla on tärkeä rooli.

Aikaisemminhan on jo ollut tiedossa, että Sanoma Magazines suuntaa vahvasti verkkoon ja nämä ensimmäiset palvelut ovat vasta alkua laajemmassa uudistusten sarjassa. Samalla Sanoma Magazinesilla on tavoitteena siirtyä käyttämään laajamittaisesti mm. LifeRay-portaalialustaa verkkopalveluidensa alustajärjestelmänä. LifeRay-alusta on jo aikaisemmin valittu Sanomien uusien palveluiden yhdeksi alustaratkaisuksi. Suomessa LifeRay:ta tarjoaa jo varsin laaja toimittajajoukko, mm. Logica ja SanomaData. SanomaData on myös hiljattain vahvistanut oman Internet-yksikkönsä teknologiaosastoa ja palveleekin laajasti SanomaWSOY:n eri yksiköitä, myös LifeRayn osalta.

Uudistunut Akuankka.fi on kevään aikana päässyt TNS Metrixin mukaan jopa 50 000 viikkokävijän lukuihin, mutta on sieltä tullut hiljakseen alaspäin noin 13-20 000 viikkokävijän määriin. Korkea piikki selittynee paljolti aggressiivisella alkuvuoden mainoskampanjalla.

Vauva.fi on sitävastoin takonut tasaisen tappavasti reilua 40 000 viikkokävijäänsä jo viime vuoden puolelta lähtien. Itse asiassa luvuissa on heilahtelua suorastaan hämmentävän vähän.

Das neue LP 5.0.1 ist draußen und da hat sich einiges getan. Stichwort AJAX, Icefaces Support usw.
Somit werden wir bald wieder ein Upgrade anstreben. Das wird kein Spaß... oder doch?

www.kqv.de

- the installation of liferay portal using its WAR distribution. this allows system administrators to deploy in existing application server installation.

// its recommended to have a good understanding of the deployment procedure of Java EE applications in the application server of choice.

1. Download and install netbeans and glassfish: Download and install netbeans-6.0.1-ml-linux.sh then Go to /user/local/glassfish-v2ur1/bin and execute ./asadmin start-domain domain1
2. Download and install JDK5
3. Download and install MySQL
4. Download liferay WAR file
5. Create a database for liferay. i.e: create database lportal character set utf8; liferay will automatically create tables and populate it the first time it starts.

What is a Portlet?

Portlets are small web applications that run into a portion of a web page.

The heart of any portal implementation is its portlets, becuase portlets are where the functionality of any portal resides.

Liferay's core is a portlet container, and this container is only responsible for aggregating the set of portlets that are to appear on any particular page. Meaning that all feautres and the functionality of your portal application must be in its portlets.

Portlet applications, like servlet applications, have become a java standard which various portal server vendors have implemented.

The JSR-168 standard defines the portal specification.

A JSR-168 standard portlet should be deployable on any JSR-168 portlet container.

The portal server handles certain "givens" that apply to servlet-based projects, such as control over URLs or access to the HttpServletRequest object.

Portal Applications come generally into two flavors:

1) Portlets can be written to provide small amounts of functionality and then aggregated by the portal server into a larger application

or

2) Whole applications can be written to reside in only one or few portlet windows.

What is a Theme?

Themes are hot deployable plugins which can completely transform the look and feel of the portal.

Theme creators can make themes to provide an interface that is unique to the site that the portal will serve. As themes make it possible to change the user interface so completely that it would be difficult or impossible to tell that the site is running on liferay.

Theme developer is able to modify everything from the border around a portlet window to every object on the page, because all of the objects are easy to find.

Additionally, theme developers don't have to customize every aspect of their themes, as when the SDK is used, themes become only a list of differences from the default theme. this allows themes to be smaller and less cluttered with extraneous data that already exists in the default theme (such as graphics for emotions for the message boards portlet).

Intf_01

Util_o1 --> This has refc to Intf_01 which is plugged in by Spring

Impl_01 -> this implements Intf_01

Classes call Util static which calls one instance of Impl to return data.

All Util's and Intefcs are in portlet-service package
All Impl's are in portal-impl package.

Then what about portlet-kernel?.
This keeps interfaces for ?--- being accessed by external deployments in the container

In portal-impl you have custom-sql ->Default.xml that keeps reference to all the xml files having custom sql's.

Reason is that not all classes are allowed to open Hibernate session - you need to check the Hibernate settings for the given classes in the file portal-spring.xml

And then enable PermissionCheckerImpl to access the hibernate sessions.
For now - trying with JournalArticleFinderUtil and its Impl.

Nopes, the thread itself does not have access!! Amazing - now what to do??
I think now I would need to go and check the settings of the class wrt hibernate..

There is some issue of accessing the hibernate apis from the Business layer and not the Action layer

The action layer is with all the Util's class and intfc
And Business Layer is with Local,Remote etc interfaces and implementations.

So now I am trying to access the api using JournalArticleLocalService.getfinder().myMethod();

Nopes Hibernate did notwork for me - I need to understand the Service Builder method in Liferay
Used JNDI instead.

Critical JIKES compiler can sometimes be unforgiving about exceptions in throws clause and does not compile correctly. For this used modern compiler instead - this took around 3 hrs to know. Tough one.
##Set the following to true to track user clicks in memory for the
#duration # of a user's session. Setting this to true allows you to view all
#live # sessions in the Admin portlet.
#
session.tracker.memory.enabled=true
#
session.tracker.persistence.enabled=false

to clear wrong preferences:
SELECT * FROM portletpreferences where preferences like '%LDAP%';

delete from portletpreferences where preferences like '%LDAP%';

delete from portletpreferences where preferences like '%CAS%';

servlet.service.events.pre.error.page=/common/error.jsp should be enabled by default to allow for more graceful handling of exceptions that are thrown in ServicePreAction

Using Trove unix fast for - performance - collections

• download the library
• make the modifications to the web.xml. You have to install the filter AjaxAnywhere and the appropriate filter mapping. Below is the code:<filter>
<filter-name>AjaxAnywhere</filter-name>
<filter-class>org.ajaxanywhere.AAFilter</filter-class>
<init-param>
<param-name>preSendHandlerClass</param-name>
<param-value>org.ajaxanywhere.jsf.MyFacesClientStateSavingPreSendHandler</param-value>
</init-param>
</filter><filter-mapping>
<filter-name>AjaxAnywhere</filter-name>
<url-pattern>*.jsp</url-pattern>
</filter-mapping>

A great example of using AjaxAnywhere is the displaytag library. Below is the sample code of this:


<aa:zone name="userTable">
<display:table name="pageScope.service.allCars" id="userList" class="displaytag" pagesize="10"
defaultsort="1" defaultorder="descending" export="true" requestURI="/ext/reports/view_reports">
<display:column property="make" title="Make" sortable="true" headerClass="sortable" />
<display:column property="model" title="Model" sortable="true" headerClass="sortable" />
</display:table>
</aa:zone>

The work is done from the following script:

ajaxAnywhere.getZonesToReaload = function() { return "userTable" }
ajaxAnywhere.onAfterResponseProcessing = function() { replaceLinks() }
function replaceLinks() {
// replace all the links in with onclick's that call AjaxAnywhere
var sortLinks = $('userList').getElementsByTagName('thead')[0]
.getElementsByTagName('a');
ajaxifyLinks(sortLinks);
if (document.getElementsByClassName('pagelinks').length > 0) {
var pagelinks = document.getElementsByClassName('pagelinks')[0]
.getElementsByTagName('a');
ajaxifyLinks(pagelinks);
}
}
function ajaxifyLinks(links) {
for (i=0; i < links.length; i++) {
links[i].onclick = function() {
ajaxAnywhere.getAJAX(this.href);
return false;
}
}
}
replaceLinks();

The above code is also applicable in JSR-168 portals, like Liferay.

• Using an open source bundle: <The Easiest and Fastest Method> includes an embedded database.
  1. Install Java SE runtime environment
  2. Unzip the bundle
  3. Run liferay

  Its recommended for people that want to review liferay's functionality ASAP!

• Detailed installation procedure: install liferay to an existing application server (i.e glassfish, tomcat, etc) recommended for production environments.
• Using the ext. environment: provide a full development environment to extend the functionality provided by liferay. Recommended for developers to use on their laptops, for doing the customization work.

Note: liferay portal version 4.4 edition is called Liferay Enterprise Portal, and it supports servlet containers and full application servers. this edition doesn't use EJB's internally but does fully support them for custom portlets and applications.

Bundle Installation for Solaris:

java -jar -Xmx300m liferay-portal-glassfish-sunos-4.4.0.jar

then go into the glassfish dir

ant -f setup.xml

Then startup glassfish as usual.

Bueno, primero lo primero… para entender lo que es un portlet, hay que hablar de “portal”. ¿Qué es un portal? Un portal es un sitio en el que puedes poner a disposición del usuario o los usuarios una serie de información, recursos y servicios que pueden venir de fuentes distintas. Un portal puede estar conformado por varios portlets. ¿Y qué es un portlet? Una respuesta sencilla podría ser “una porción de código”. Sin embargo, según Java Portlet Specification, “un portlet es un componente web basado en tecnología Java, administrado por un portlet container, que procesa peticiones y genera contenido dinámico. Los portlets son empleados por los portales como componentes de interfaz de usuario que proveen una capa de presentación a los Sistemas de Información”.

El responsable de manejar el ciclo de vida del portlet es el portlet container. Mientras, que el responsable de la agregación del contenido generado a la página es el portal.

Es muy importante tener en cuenta que los portlets al proveer una capa de presentación no deberían contener lógica de negocio. Por lo tanto, sería indicado que hagamos que ellos consuman web services.

Para el curso empleamos Liferay 4.2.2 con Tomcat 5.5 para JDK 5.0 y Eclipse Europa. En los siguientes post, seguiré subiendo mis notas de las siguientes clases.

Technorati Tags: java, programacion, portal, portlet, liferay

• Sharepoint (predicted by Forrester to "steamroll" other enterprise Web 2.0 apps in 2008)
• A couple interesting ones a progressive CIO I met with the other day is implementing:
  • Attensa (RSS feeds of activities in your business you care about)
  • K2 blackpearl which "gives users the tools to design, assemble, execute, monitor and optimize dynamic business applications"

But as a big fan of Eric Raymond, I'm especially interested in open source Enterprise 2.0 tools, a couple interesting looking ones which I've come across in the last week:

• Liferay Portal, a a Java-based open source enterprise portal and content management system (CMS). InfoQ has a post on on Liferay's latest release.
• Intalio is a "business process mapping" (BPM) tool. And BPM is a very hot topic these days. Most BPM tools I have used (e.g., ARIS, for SAP) are not very useful because a)the diagrams produced from them tell very little to people untrained in the methodology (thus it's hard to get validation from business process owners themselves); b)the "to be" diagrams don't tie back very well to the software. Intalio aims to overcome this--their methodology is so different, they call it "BPM 2.0". They use BPEL4People, which seems very promising to me, and, in lay people's terms, what the business analyst designs as a "to be" business process, can then be quickly and easily built using Intalio's Designer, Server and Workflow modules. The tools build are AJAXy, SOA-ish Web 2.0 tools--as is even the way of interacting with the tools apparently.

Of course, BEA Weblogic, IBM WebSphere, Microsoft SharePoint are out there.

What else?

Links:

• http://java-source.net/open-source/portals
• http://www.manageability.org/blog/stuff/open_source_portal_servers_in_java
• http://java-source.net/open-source/portals/ipoint-portal
• http://www.rlhc.net:8080/lightPortal/index.jsp
• http://www.theserverside.com/news/thread.tss?thread_id=41211
• http://www.birt-exchange.com/modules/products/index.php?productid=6
• http://www.birt-exchange.com/modules/products/index.php?productid=10

We did it ! We have embeded a FreeDashboard document (both static and dynamic) into Liferay ! And its running well.

We are now in position to offer a Dashboard service that put together Pentaho xaction (basically reports and charts), FreeMetrics Alerts, FreeMetrics KPIs, FreeAnalysis Olap reports and any kind of label / picture / text into a consistent FreeDashboard document, with dynamic filter on top of it. This document can then be managed using Liferay document management services (PDF management, workflow of publication ...)

All in one, you can now take benefit of the top features of each platform and provide any kind of layout to publish your results, then design high quality content to be published against your Liferay portail. Just think of this : for those of you who know Liferay ease of use and powerfull features, having a BI system embeded into Liferay, especially a Dashboard Management System, is the best things that could have happen to both world : BI and portails.

Stay connected, this is just the beginning ...

Have Fun !

Patrick

Supporting Components

There are two components that act in a supporting role that should be taken out of the equation. They are the database and the full-text index engine. Why? Those items shouldn't be provided by the content management vendor. In most products, they aren't. Exceptions include SharePoint and Oracle's Stellent. However, as they are separate products and licensed independently, it doesn't count.

Of course there is technically the possibility of an exception. A company could create their own database and/or indexing engine for their repository. In that situation, you have to take it into account the database speed. However, I doubt that that they could match those vendors that utilize 3rd party databases like SQL Server and Oracle, except maybe in price/performance equation.

There is a need to eliminate the variable performance that can be introduced by the databases. There are two basic approaches:

• Use the recommended database vendor. This had the benefit of using the database for which the system is best designed.
• Average the results. Using the same database for each one isn't fair as one may be optimized for Oracle while another may be optimized against SQL Server. I would take the performance measured against each and average it out. In theory, that will give you a comparative measure between different systems.

Index engines are trickier. Most only support one so you have to use them. Tests can't be designed to minimize the full-text search when judging performance. That is one of the key features. So I think one should try and separate the search capabilities into a separate set of tests to try and isolate the performance. One day all index engines will be plug-and-play and we will be able to truly be able to measure the system.

The User Interface

Here is another problem. Are we measuring the performance of an ECM platform or a suite? If a suite, you need to test the standard User Interface. If platforms, then try backing them onto a custom UI hosted on Liferay or some other common platform.

Some people can design most impressive engines, it is the web interface that they fall apart upon.

So What is Left?

Well, first, load it with content. I'm thinking at least 100,000 different pieces of content. Half stored throughout a layered, deep, hierarchy and half in a small number of folders. Don't forget to add several pieces of metadata. This will set things up for the tests.

What do you measure? Well, several things:

• Move large folder hierarchies around.
• Mass meta-data updates.
• Process query result sets.
• Anything else define in the system requirements (if a system does it, test it)

When all is said and done, add at least 50% more content (or remove half of it) and repeat. Performance can suffer as a repository grows, so it is important to test it large. When doing this, be sure to size all the systems as recommended for the amount of content. If a system tells you that it needs X and you give it X/2, of course it isn't going to work well. If you through everything on the same size box, you are beginning to compare efficiency, not just performance.

Remember Our Purpose

Lopartu is designing a new system, so telling him how to compare existing systems doesn't help him much. Contrary to the above indications, databases and index engines are critical in the design. A poor database design can cripple a system. Comparing two systems running on SQL 2005 will reveal those design flaws.

Performance also isn't everything. If you can't protect content, track it, or manage it through its lifecycle, it doesn't matter how fast it is. That is another consideration. When designing a system for high-performance, it is critical to design it to handle all of the functionality that any target organization would need. In addition, don't forget to design for all the feature that you don't know.

That is the real trick. The older ECM platforms are burdened by legacy design concepts that are either dated or that never panned-out. The ease of upgrade from one version to another limits the ability to remove these design characteristics. Alfresco has the benefit of not being limited by its own history. However, if they are successful, they will be burdened by their own design when new ideas and features come forth.

Now, hit me with your best shot. I know you want to do so.