Technical blog

Poor man's approach in practice

2011-06-05T13:46:00.001-07:00

One day we ran into problem when an application was randomly starting using more CPU resources as usual. It continued picking more and more CPU resources from time to time. Thread dump showed many threads though we couldn't understand wich of them is problematic...and I remembered about poor man's profiler and its approach: the stack that's all we need to!

Htop is awesome
At first we simply caught problematic thread using htop (you just need to remember about tree process view, type t-button, or anyway you need to see all forked java processes with its identifiers and CPU usage). We just obtained a java thread wich took more CPU than others. We got an identifier of native OS thread, let it be 3256, but what's next?

Jstack
I like jstack, it helps me all the time I deal with spontaneous problems. If you look thru the content of jstack output you'll see some thread identifiers and all of them are hexadecimal. Thus we converted our native thread id into hex representation 0xcb8. Lazy guys can use Integer.toHexString ;)

The final step
We searched by our hexadecimal string in jstack output (don't forget about leading zeros, therefore just search by value, i.e. cb8 in our case). Matched nid thread attribute value (suppose stands for native id) was our problematic thread with its stack. In fact we were getting infinite loop. The problem is localized and will be fixed soon.

MySQL: ON DUPLICATE KEY UPDATE breaks generated key list of extended INSERT

2011-05-22T09:22:00.002-07:00

When extended INSERT (insert with several tuples in one query) is used with ON DUPLICATE KEY UPDATE clause and there're unique key conflict the Connector/J's Statement will return incorrect list of generated identifiers that cannot be matched with tuples from INSERT query at all. There are steps to reproduce this issue:

create a table with auto increment primary key and unique key:

create table TEST_TABLE(
        id int auto_increment, 
        test_field varchar(255), 
        primary key (id), 
        unique key(test_field)
) engine=InnoDB;

insert the following row:

insert into TEST_TABLE(id, test_field) values(100, 'test1');

perform an extended insert with ON DUPLICATE KEY UPDATE clause via JDBC driver:

insert into TABLE(test_field) values('test2'),('test1'),('test3') 
on duplicate key update id=LAST_INSERT_ID(id);

and check returned generated keys:

at first, you'll get 4 values instead of 3: [1, 2, 3, 4]
at second, there's no correct id for test1 row in returned list

Thus only for the first row returned id will be correct, if test1 will be first in a query whole list will be incorrect and cannot be matched with inserted rows. The only workaround is to use separate query to retrive generated identifiers to reduce count of Data Base access and avoid the split of this extended insert in separate queries. I've looked thru the code in com.mysql.jdbc.StatementImpl and found that It retrieves count of affected rows and just increments the value of LAST_INSERT_ID for each update and gets sequential list of identifiers. But in fact it can be nonsequential: for my case I expect the result set: [1, 100, 3] <-- 3 is here because of the 2nd value, or even [1, NULL, 3] will be normal. But current result: [1, 2, 3, 4] is very confused and cannot be matched with inserted rows.

In fact MySql returns unexpected count of updated rows in such case because of this behavior:

For INSERT ... ON DUPLICATE KEY UPDATE statements, the affected-rows value is 1 if the row is inserted as a new row and 2 if an existing row is updated.

I've reported new #61213 issue for MySQL Connector/J and according to Mark Matthews the fix raises a modification in MySQL server protocol because there's currently no way to get generated keys for whole data set though LAST_INSERT_ID returns only the first one. Thus be aware of this issue.

How does JVM handle locks

2011-04-30T11:49:00.002-07:00

As we are talking about the latest version of Sun Hotspot Java Virtual Machine 1.6 there're the following three types of locks performed by JVM when you try to acquire lock from java.util.concurrent.locks.Lock implementation or enter synchronized block:

biased: sometimes even in concurrent systems there's no contention and JVM shouldn't borrow mutex from OS for perform locking in this case. Hotspot can operate with its own internal data structures to simulate locking in more effective way. For example, if synchronized part of code is not executed concurrently in real time, JVM assigns an owner thread id to an object used as mutex in your Java code using CAS operation and additionally stores the reentrancy count if CAS is passed. It is biased lock - the 'lightest' type of locks done by JVM. Reentrancy count will be updated by lock owner thread just as usual local variable without CAS. If CAS fails it means another thread already gets this lock and in this case JVM stops the mutex owner thread, flushes thread context into the main memory and checks the reentrancy count. If it's 0 JVM escalates lock to thin type otherwise to fat (I assume the main purpose is the wait time, it should be very small if lock is thin). Note Hotspot uses the same field for storing owner thread id in mutex object as for caching identity hash code. Thus if you retrieve identity hash code on you mutex once then it will be unavailable for biased locking even it was already used as biased. More info about biased locks is described in David Dice's blog.
thin: it's a simple spin lock. It helps to save time for thread context switching when time for spinning is quite small. When one thread tries to acquire an occupied mutex it spins some time until the lock will be freed. The count of spins is based on internal JVM resolution and may depend from different factors: statistics gathered by JVM about your application, count of used threads, CPU and so forth. JVM determines when thin lock becomes inefficient and escalates it to fat lock.
fat: the 'strongest' type of lock when JVM requests for an OS mutex and uses OS scheduler engine for threads parkings and wake ups. It is much costly than previous types because in this case JVM should directly interact with OS every time when thread acquires and frees the lock.

The GrinderStone is nominated for Eclipse Community Awards

2011-02-02T14:43:00.000-08:00

The GrinderStone, an IDE for Grinder load testing scripts development, is nominated for Eclipse Community Awards 2011 in Best Developer Tool section. Any comments will be appreciated on GrinderStone nominee page. We thank our users and give them unique Grinder scripts development features based on Eclipse platform.

MySQL 5.5 won't start on Mac OS 10.6

2011-01-25T11:14:00.001-08:00

Modify the mysql.server script file using the following command :

sudo /Applications/TextEdit.app/Contents/MacOS/TextEdit /usr/local/mysql/support-files/mysql.server

Locate the configuration defining the basedir and set the following :

basedir=/usr/local/mysql 
datadir=/usr/local/mysql/data

Save the file and start the mysql server in the system preferences or terminal.

from MySQL Developer Zone

InnoDB: strange deadlock

2010-11-07T13:18:00.004-08:00

One time I've noticed that some concurrent threads that perform inserts into one simple table can cause deadlock in MySQL. I don't have auto increment primary key in a table and generate id on application level. So let concurrent inserts are performed into this table in separate transactions with default isolation level (repeatable-read):

insert into TEST values(...);
insert into TEST values(...);
insert into TEST values(...);
.....

I got deadlock! Why?! As I understand according to this discussion if two different concurrent inserts try to lock the same gap at the end of a table at the same time (i.e. concurrently set X lock) we will get deadlock (I think it should be livelock but not deadlock...it's a bit strange). In a case if primary key is auto increment we will have lock by auto_inc index and all inserts will wait for granting lock - so no deadlock here can happen, only livelock and InnoDB successfully handles this case.

I think InnoDB should lock the primary key index during insert in a case if it is not auto increment. ~~I think there's a problem with locks granularity in InnoDB - I'll try to research this problem and submit it to Oracle.~~

UPDATE

One guy told me the reason of this deadlock. It was the reason in inserts performed from separate threads that became not ordered and InnoDB locked some necessary gaps in indexes - I missed that I had an index in a table - for record insertions (some threads, some monitors, not ordered actions...potential deadlock...it's classic). See detailed explanation here. Thus I was wrong when told you that InnoDB has a problem with locks granularity...

JBPM concurrency issue: Action altered id

2010-10-18T14:00:00.002-07:00

I've been working for several days on problem when some concurrent threads create process instances from one process definition. In my environment I deploy one process definition on application startup and use this instance during whole application lifecycle. It means that this instance becomes detached and is used in all JBPM related places. The error was:

org.hibernate.HibernateException: identifier of an instance of org.jbpm.graph.def.Action was altered from 532 to 533

After data base dumps analysis I've obtained a problematic place. It was in jobs processing (or in other definitions - timers) persistence. JBPM performs manual cascade persistence of Action from ProcessDefinition called by this timer. The following code snippet from org.jbpm.db.JobSession is problematic:

public void saveJob(Job job) {
    session.saveOrUpdate(job);

    if (job instanceof Timer) {
        Timer timer = (Timer) job;
        Action action = timer.getAction();

        if (action != null && !session.contains(action)) {
            session.save(action);
        }
    }
}

As process definition is detached - linked Action also is detached so Session will always persist Action as new instance (note: they call save and not merge). I don't know why JBMP do that because we cannot create timer without process instance and we cannot create process instance without fully persisted process definition (may be process definition can be changed on the fly? don't think that it's correct behavior). I created JBPM-2950 but hadn't got any response. The same with HHH-4309 - we created it more than one year ago but anyone responded. I don't know why these problems stay ranked as Major and Critical - may be JBoss doesn't wanna see them? Comparing this approach with Spring Issue tracking where I always get a responses in a few days or even hours.

In any case I would like to share the patch fixing this problem.
At first we should correct check Action existence in Persistence Context: I replaced it with id nullabillity check, because when Action is persisted and Session is flushed we will get non zero id and we don't need to update this Action because we don't change it.

public class JbpmJobSession
    extends JobSession {

    private Session session;

    public JbpmJobSession(Session session) {
        super(session);
        this.session = session;
    }

    @Override
    public void saveJob(Job job) {
        session.saveOrUpdate(job);

        if (job instanceof Timer) {
            Timer timer = (Timer) job;
            Action action = timer.getAction();

            // action already persisted? 
            if ((action != null) && (action.getId() == 0L)) {
                session.save(action);
            }
        }
    }

}

Then we should correct JBPM DB persistence service to allow saving jobs via our modified session:

public class JbpmDbPersistenceService
    extends DbPersistenceService {

    public JbpmDbPersistenceService(
           DbPersistenceServiceFactory persistenceServiceFactory) {
        super(persistenceServiceFactory);
    }

    @Override
    public JobSession getJobSession() {

        if (jobSession == null) {
            Session session = getSession();

            if (session != null) {
                jobSession = new JbpmJobSession(session);
            }
        }

        return jobSession;
    }
}

Then create corresponding factory:

public class JbpmPersistenceServiceFactory
    extends DbPersistenceServiceFactory {

    @Override
    public Service openService() {
        return new JbpmDbPersistenceService(this);
    }

}

And one step to finish: modify persistence service to yours in jbpm.cfg.xml


    .....
    
        
        ....
    
    ....

That's it.

Fibonacci numbers built with SQL

2010-10-09T13:35:00.003-07:00

I've been at work today and my friend Eugene has told me that he read somewhere about one guy who calculated Fibonacci numbers using SQL. He asked me to do the same... and after 5-10 minutes I've got the following query:

select N from (
       select @f0 N, @fn:=@f1+@f0, @f0:=@f1, @f1:=@fn 
       from   (select @f0:=0, @f1:=1, @fn:=1) x, 
       information_schema.COLUMNS p limit 10) y;

The result is:

| 0 |
| 1 |
| 1 |
| 2 |
| 3 |
| 5 |
| 8 |
| 13 |
| 21 |
| 34 |

The length of sequence can be adjusted with the limit clause.
Or the same more friendly result in one line is:

select concat(group_concat(N),',...') from (
       select @f0 N, @fn:=@f1+@f0, @f0:=@f1, @f1:=@fn 
       from   (select @f0:=0, @f1:=1, @fn:=1) x, 
       information_schema.COLUMNS p limit 10) y;

Than you should see:

| 0,1,1,2,3,5,8,13,21,34,... |

Instead of information_schema.COLUMNS table any table with many rows can be used.

GrinderStone 2.5.3

2010-09-26T06:21:00.001-07:00

I've released new GrinderStone 2.5.3 version. It has come with the following features:

redirect for all Grinder outputs to Eclipse terminal (feature #9)
compatibility with latest version of PyDev (issue #26)
ability to debug Grinder scripts using nano time calculation (issue #27)

As usual release can be downloaded from official project site or using Eclipse Update

Transparent clustering solutions

2010-09-13T15:23:00.002-07:00

I've spent these weekends to research and compare two transparent clustering solutions: Terracotta and Hazelcast.

As a result I would choose Terracotta, a proven solution for clustering second-level cache, http sessions and distributed locks, but the Hazelcast solution seems pretty fresh, interesting and more explicit than Terracotta.

I always choose explicit solutions comparing with implicit during software architecting. It simplifies understanding and source code support, reduces the number of problems and as a result increases application stability. The main arguments in support of Terracotta I would pick:

data consistency: Terracotta is a client-server solution which ensures the safety backups and the actual state (compatibility) of all cluster nodes. In Hazelcast (it's solution without master server) all nodes are equivalent excepting super client. If both nodes will fail at the same moment, then status of the various nodes in the cluster will be inconsistent, because each node keeps a backup for only one its neighbor. It is configured and the maximum number of backups is 3 but anyway it doesn't guarantee that we won't get the situation when three adjacent nodes will fail at the same time. Thus it can lead to stale data on different nodes in a cluster
network latency: network load in case of Terracotta is less than during Hazelcast usage, because it sends only the changed data (delta), in Hazelcast full object tree is serialized and is sent to necessary node(s)
real world clustering solutions: as already mentioned above, ready-made solution for clustering http sessions (although this is done by Hazelcast, but there's no session state visualization) and second-level cache (Ehcache)
persistent data: Terracotta storage engine doesn't need any further elaboration if we need to store persistent data, in Hazelcast we have to develop our own storage (for example providing the MapStore implementation)

The minuses I can evolve (somebody can discuss about these points, but for me they are more negative than positive):

implicit solution: Terracotta lets you do application clustering implicitly for an application itself (though this point is less neutralized by the fact of annotations existence that allows you to do this declaratively)
instrumentation: bytecode instrumentation already ensures that the application won't work as written in the source code, another implicit element of the Terracotta solution implementation. Thus sometimes you have to write your code that already assumes that it will be instrumented and used by Terracotta

The best development strategy

2010-09-04T14:03:00.003-07:00

When I met my old friend in Nederlands he sad me that in the company he was working for they follow one general rule:

Perform many small changes because they cause small problems instead of big changes that in any case cause big problems

I think it's the best strategy of software development.

Spring: case when mix of plain JDBC and Hibernate JPA will fail

2010-08-15T11:41:00.002-07:00

I suppose it's a new problem in Spring connection management related to all 3.X versions:
when you executes query in RowMapper the next query outside of this RowMapper will fail with HibernateException.

I've created SPR-7393 related to this issue and it successfully fixed now.

MySQL batch queries processing

2010-07-19T11:12:00.001-07:00

I was very surprised when we've got an issue with batch queries execution via MySQL JDBC driver: in our project we have to save big chunk of data to one table - approximately 1.5K records as one batch. It takes more than 1 minute - 86320ms - for loaded server! And...

The reason is that MySQL does not support batches!

Enabling profiling in mysql session I've seen that freeing items operation (in a case of INSERT statement it means table cache flush) takes ~0.12sec for each row so if you multiply this time on count of records you'll get my 86seconds. Instead of batches MySQL supports extended INSERT statement (multiple rows insertion in one query). In a case of extended INSERT table cache is flushed at once for all 1.5k rows instead of flushing rows one by one. It is equivalent of batch but you have to:

1st way
rewrite query to look like

INSERT INTO tbl_name (a,b,c) VALUES(1,2,3),(4,5,6),(7,8,9);

see MySQL INSERT syntax

2nd way
enable rewritable batch statements in ConnectorJ MySQL JDBC driver specifying rewriteBatchedStatements=true in connection URL. In this case driver will parse sql statement and rewrite it as extended INSERT.

We've chosen 1st way to avoid performance degradation on SQL modification in driver and rewrited query takes 128ms now (instead of 86320ms).

...MySQL is a database just like no other.

OpenOffice: Concatenate cells with separator

2010-07-06T13:50:00.000-07:00

In OO you cannot concatenate even range of cells so I've obtained solution, at first go to menu:

Tools > Macros > Organize > Basic... Container:'MyMacros', Library:'Standard'
create new module
create new Macros with the following body:

Function VVJOIN(v(), optional sep)
REM join a *v*ertical *v*vector with optional separator (default "")
REM use with TRANSPOSE for horizontal vectors
On Error Goto NullErr
   If isMissing(sep) then sep = ""
   iLB = lBound(v(), 1)
   iUB = uBound(v(), 1)
REM convert from 2D array to flat array:
   Dim a(iLB to iUB)
   For i = iLB to iUB
      a(i) = v(i, 1)
   next
   VVJOIN = join(a(), sep)
exit function
NullErr:
REM return #VALUE
   VVJOIN = Null
End Function

Examples:

=VVJOIN(A1:A9) - concatenates vertical vector
=VVJOIN(TRANSPOSE(A1:G1)) - concatenates horizontal vector
=VVJOIN(A1:A9;", ") - concatenates vertical vector with separator

got it info from OO Community Forum

Leadership in self-organization team

2010-06-28T12:19:00.000-07:00

Completely agree with Michael:

I don't believe in self-organization without leadership. It is a myth.

Michael Dubakov, CEO Target Process, from his Twitter

any process cannot head people in the right direction (development, requirement analysis, management etc.)

The Self-Organizing Team is a myth because it communicates an absolute. What is more real is an appropriate level of direction coupled with suitable delegation and trust. In order to make our project teams effective, I must provide guidance and a behavioral framework for the team to operate in. Within these somewhat strict guidelines, all other decisions are delegated, and I trust them to make the right choices. This balance between directing and delegating has proved to be the appropriate balance between self-organization and dictated-organization. The team members are very happy as well because they are pushed in the direction of success.

Jeffrey Palermo, CTO Headspring Systems, from his blog

Estimations vs Support expenses

2010-06-27T12:44:00.000-07:00

According to AntiPatterns: Refactoring Software, Architectures, and Projects in Crisis:

approximately 70% of cost of software is a time of delivery and support

Think about it when you give your estimations to produce more qualitative solutions.

Replace subselect queries with constants in Hibernate

2010-06-26T05:44:00.004-07:00

Let's see the case of parent and child entities (one to many association) using Hibernate

PARENT_TABLE (ID,...)
CHILDREN_TABLE (PARENT_ID,...)

For example we want to load parent and children using eager load fetch type and of course in this case we have to use subselect strategy to avoid duplicates of parent entities in result list (because join strategy is used by default).

When you try to load list of parents Hibernate will load parent entities using filter condition

SELECT ID from PARENT_TABLE WHERE ...filter condition...

and then it will do the following ugly subselect for children:

SELECT * FROM CHILDREN_TABLE where PARENT_ID in (
       SELECT ID from PARENT_TABLE WHERE ...filter condition...
)

instead of using in clause with constants keys for parent entities (it already loaded parents and know its ids):

SELECT * FROM CHILDREN_TABLE where PARENT_ID in (
...constants got from query to PARENT_TABLE, i.e.: 1,2,3,4,5...
)

Looking back to one of my previous posts about MySQL indexes the query with subselect will be very slow and inefficient because MySQL iterates over the whole table! We got that equivalent queries were running more than 60 sec in production! I suppose any Data Base will process queries with IN clause with constants much more faster than query with subselect, so I don't know why this feature is turned off by default in Hibernate.

To replace this subselect with PARENT_ID constants from previous query to parent table you should change fetch mode from SUBSELECT to SELECT (in a case of eager fetch type) and add batch size (we set it to 100). Otherwise you can setup batch size for all entities at once in SessionFactory (or EntityManagerFactory, i.e. to whole Persistence Unit) using hibernate.default_batch_fetch_size property.

MySQL table size query

2010-06-23T14:02:00.001-07:00

The following query calculates table size in currently used database:

SELECT table_schema,
       table_name,
       ROUND(data_length / 1024 / 1024,2) total_size_mb
FROM   information_schema.tables
WHERE  table_schema = database()

MySQL indexes on subqueries

2010-06-17T12:53:00.003-07:00

I was surprised when I got a problem that MySQL doesn't honor indexes when subquery used in IN clause! Problematic query was:

SELECT A, B FROM TABLE_1 WHERE A IN (SELECT A FROM TABLE_2)

If TABLE_1 has index on A then it won't be used by outer query. Problem is caused by missed subquery optimization in MySQL 5.x, outer query won't use indexes if subquery is used:

Thus there are two ways to fix indices issue: 1. use JOIN instead of subselect where it's possible, i.e.

SELECT A, B FROM TABLE_1 t1 INNER JOIN TABLE_2 t2 ON t1.A=t2.A

2. use EXISTS for subqueries, i.e.

SELECT A, B FROM TABLE_1 t1 WHERE EXISTS 
(SELECT 1 FROM TABLE_2 t2  WHERE t1.A=t2.A)

In both approaches we force to use index on A from TABLE_1. These described features are really performed tweaks and they work well in production for us.

Article from MySQL Reference Manual about IN subqueries optimization

http://dev.mysql.com/doc/refman/5.1/en/in-subquery-optimization.html

Problems with subqueries are fixed only in 6.0

http://forge.mysql.com/wiki/6.0_Subquery_Optimization_Cheatsheet

Spring: Classpath resource resolving from jars using wildcards

2010-06-13T12:42:00.004-07:00

When I tried to setup load for Spring context files using infinitive nesting of packages in jars, i.e. using ** as wildcards, I noticed that Spring couldn't load my files from jar files and started silently without any errors. After some investigations I noticed a problem in resolution of the pattern classpath:**/ac-*.xml. The fastest fix for me was in providing another way to load these context files:

1. At first I changed the pattern classpath:**/ac-*.xml to relative application root

WEB-INF/lib/*.jar!/**/ac-*.xml

2. I introduced ability to process this pattern in Spring's ServletContextResourcePatternResolver extending it:

public class ServletContextResourcePatternResolverImpl extends
    org.springframework.web.context.support.ServletContextResourcePatternResolver {

  /**
   * Constructor from superclass.
   */
  public ServletContextResourcePatternResolverImpl(ServletContext servletContext) {
    super(servletContext);
  }

  /**
   * Constructor from superclass.
   */
  public ServletContextResourcePatternResolverImpl(ResourceLoader resourceLoader) {
    super(resourceLoader);
  }

  /**
   * {@inheritDoc}
   */
  @SuppressWarnings("unchecked")
  protected void doRetrieveMatchingServletContextResources(ServletContext 
                 servletContext, String fullPattern, String dir, Set result) 
                 throws IOException {
    Set candidates = servletContext.getResourcePaths(dir);
    if (candidates != null) {
      boolean dirDepthNotFixed = (fullPattern.indexOf("**") != -1);
      for (Iterator it = candidates.iterator(); it.hasNext();) {
        String currPath = (String) it.next();
        if (!currPath.startsWith(dir)) {
          // Returned resource path does not start with relative
          // directory:
          // assuming absolute path returned -> strip absolute path.
          int dirIndex = currPath.indexOf(dir);
          if (dirIndex != -1) {
            currPath = currPath.substring(dirIndex);
          }
        }
        if (currPath.endsWith("/")
            && (dirDepthNotFixed ||
                        StringUtils.countOccurrencesOf(currPath, "/") <
                        StringUtils.countOccurrencesOf(fullPattern, "/"))) {
          // Search subdirectories recursively:
          // ServletContext.getResourcePaths
          // only returns entries for one directory level.
          doRetrieveMatchingServletContextResources(servletContext, 
                                                   fullPattern, currPath, result);
        }
        // START FIX
        // In this place I have to delegate jars processing to my own method
        if (currPath.endsWith(".jar")) {
          doRetrieveMatchingJarEntries(servletContext, currPath,
              org.apache.commons.lang.StringUtils.substringAfter(fullPattern,
                  ResourceUtils.JAR_URL_SEPARATOR), result);
        }
        // END FIX
        if (getPathMatcher().match(fullPattern, currPath)) {
          result.add(new ServletContextResource(servletContext, currPath));
        }
      }
    }
  }

  /**
   * Method extracts entries from the given jar by pattern. 
   * I've introduced it to resolve patterns
   * related to jars relative application root.
   * 
   * @param servletContext servlet context
   * @param subPattern wildcards to obtain resources from jar
   * @param jarFilePath path to jar file
   * @param result collection with resources
   * @throws IOException if jar cannot be opened
   */
  @SuppressWarnings("unchecked")
  private void doRetrieveMatchingJarEntries(ServletContext servletContext, 
      String jarFilePath, String subPattern, Set result) throws IOException {

    if (org.apache.commons.lang.StringUtils.isNotBlank(subPattern)) {

      String absoluteJarPath = servletContext.getRealPath(jarFilePath);
      JarFile jarFile = new JarFile(absoluteJarPath);

      for (Enumeration entries = jarFile.entries(); entries.hasMoreElements();) {
        JarEntry entry = (JarEntry) entries.nextElement();
        String entryPath = entry.getName();
        if (getPathMatcher().match(subPattern, entryPath)) {
          result.add(new UrlResource(ResourceUtils.URL_PROTOCOL_JAR + ":"
              + ResourceUtils.URL_PROTOCOL_FILE + ":" + absoluteJarPath
              + ResourceUtils.JAR_URL_SEPARATOR + entryPath));
        }
      }
    }
  }
}

3. I redefined this resolver in my own XmlWebApplicationContext in the following way:

public class XmlWebApplicationContextImpl extends XmlWebApplicationContext {

  /**
   * Default constructor.
   */
  public XmlWebApplicationContextImpl() {
    super();
  }

  /**
   * {@inheritDoc}
   */
  @Override
  protected ResourcePatternResolver getResourcePatternResolver() {
    return new ServletContextResourcePatternResolverImpl(this);
  }

}

and specified this class in web.xml in case of Spring MVC usage

<servlet>
 <servlet-name>ApplicationServlet</servlet-name>
 <servlet-class>org.springframework.web.servlet.DispatcherServlet
 </servlet-class>
 <init-param>
  <param-name>contextConfigLocation</param-name>
  <param-value>WEB-INF/lib/*.jar!/**/ac-*.xml</param-value>
 </init-param>
 <init-param>
  <param-name>contextClass</param-name>
  <param-value>com.test.context.XmlWebApplicationContextImpl
  </param-value>
 </init-param>
</servlet>

All context files matched to lookup pattern are loaded fine now. I posted this problem to Spring JIRA as new issue SPR-7198 and my changes from ServletContextResourcePatternResolverImpl were successfully merged into Spring sources by Juergen Hoeller. He confirmed that main problem is in resolving ** if they are exactly in start of resource name, read his comment:

"classpath*:" unfortunately has a fundamental limitation in that it requires as base path to search from. For example, "classpath*:META-INF/*/context.xml" or classpath:com/mycompany/**/context.xml" should work fine. JVM ClassLoaders are able to resolve such base packages at runtime, for further traversal down the package hierarchy, but do not resolve classpath roots in jar files, unfortunately - which is why specifying the base package makes a difference. Going through WEB-INF/lib jar files directly, as you do, is a fine workaround for that limitation

JBoss Tools Richfaces breaks Eclipse

2010-06-01T15:05:00.003-07:00

When I tried to use new version of JBoss Tools 3.1.0.GA I was surprised that RichFaces plugin breaks Eclipse: when I tried to build project or just open any JSF (xhtml) page I saw high CPU usage and increase of occupied memory in heap status monitor and...after some times Eclipse failed with OutOfMemory. I figured out that it was KB (Knowledge Base) Builder which was running at this time. I discovered that KB builder was refactored to use tag library descriptors (tld), schemas and others from referenced resources in autocomplete. After some investigations using jstack I saw the following traces related to KB:

at org.jboss.tools.common.model.filesystems.impl.JarAccess.getContent(JarAccess.java:201) 
at org.jboss.tools.common.model.filesystems.impl.JarFolderImpl.createFileObject(JarFolderImpl.java:92) 
at org.jboss.tools.common.model.filesystems.impl.JarFolderImpl.loadChildren(JarFolderImpl.java:74) 
at org.jboss.tools.common.model.impl.RegularObjectImpl.getChildren(RegularObjectImpl.java:58) 
at org.jboss.tools.jst.web.kb.internal.scanner.LibraryScanner.parseInPackages(LibraryScanner.java:104)

and

at java.lang.String.intern(Native Method) 
at org.jboss.tools.common.model.impl.XModelObjectImpl.set(XModelObjectImpl.java:135) 
at org.jboss.tools.common.model.impl.RegularObjectImpl.set(RegularObjectImpl.java:103) 
at org.jboss.tools.common.model.filesystems.impl.FileAnyImpl.set(FileAnyImpl.java:181) 
at org.jboss.tools.common.meta.impl.adapters.XAdapterModelElement.setProperty(XAdapterModelElement.java:26) 
at org.jboss.tools.common.model.impl.XModelObjectImpl.set_0(XModelObjectImpl.java:146) 
at org.jboss.tools.common.model.impl.XModelImpl.createModelObject(XModelImpl.java:264) 
at org.jboss.tools.common.model.filesystems.impl.JarFolderImpl.createFileObject(JarFolderImpl.java:96) 
at org.jboss.tools.common.model.filesystems.impl.JarFolderImpl.loadChildren(JarFolderImpl.java:74) 
at org.jboss.tools.common.model.impl.RegularObjectImpl.getChildren(RegularObjectImpl.java:58) 
at org.jboss.tools.jst.web.kb.internal.scanner.LibraryScanner.parseInPackages(LibraryScanner.java:104)

I tried to resolve this issue disabling validation but It didn't help me. I couldn't disable KB builder at all because I actually used only autocomplete from Jboss Tools Richfaces which depends to KB. I supposed the main problem was in big workspace that I used: it contains approximately 120 java projects generated by eclipse maven plugin and 1500 xhtml pages.

Thus I got all investigated information and posted new bug into Jboss Tools Jira JBIDE-6372. I was very surprised when after some discussions and investigations this problem was fixed! I've checked it out!

Thanks to Jboss Tools development team for this hot fix!

New Release: GrinderStone 2.5.2

2010-05-30T13:02:00.002-07:00

GrinderStone 2.5.2 is a new release with the following list of improvements:

fix for debugging using new version of Grinder 3.4 (issue #25)
ability to reference Java projects from Jython projects (issue #24)
support for Eclipse 3.6 (Helios)
impoved Eclipse Update Site to allow discovery PyDev site out of the box, i.e. you don't need install PyDev manually before GrinderStone installation - our Eclipse Update Site does it for you automatically. Just specify the new URL in Eclipse update manager.

As usual you can download binary and source packages from official GrinderStone site

Cool class name in AspectJ

2010-05-28T14:06:00.001-07:00

I've noticed cool class name in AspectJ sources in org.aspectj.weaver.patterns package:

HasThisTypePatternTriedToSneakInSomeGenericOrParameterizedTypePatternMatchingStuffAnywhereVisitor

He-he, is it long? Yes, but it's clear what this class does ;)

Problem with video during dual monitor usage in Ubuntu solved!

2010-05-18T15:49:00.002-07:00

When I setupped dual monitors in my Ubuntu (additional monitor for my notebook) I got a problem that any video players showed blank or black screen during video processing. Solution was:

ALT+F2
enter gstreamer-properties
go to Video tab
choose No Xv option in Plugin selectbox

And video is shown fine now, but It takes more CPU resources.

The easiest way to integrate Spring with GWT

2010-05-13T04:41:00.008-07:00

There are so many articles how to integrate GWT and Spring but I think the following described solution is the easiest. I used to develope one appllication approximately one year ago and used this solution, so I can recommend it now.

At first let's create an abstract class which integrates Spring with GWT on RemoteService level. I've included transaction management into this integration because it simplifies and clarifies Tx management in GWT services, i.e. all remote service methods will be transactional out of the box in this case.

public abstract class SpringIntegratedTransactionalGWTService extends 
                RemoteServiceServlet
                implements ServletConfigAware, InitializingBean {

    /**
     * UID.
     */
    private static final long serialVersionUID = -985899061621516290L;

    protected final Log logger = LogFactory.getLog(getClass());

    /** Transaction holder. */
    private static final ThreadLocal<transactionstatus> txStatus = new ThreadLocal<transactionstatus>();

    /** Transaction manager. */
    private transient PlatformTransactionManager txManager;

    /** Spring servlet's configuration. */
    private transient ServletConfig config;

    /**
     * Overridden for transaction management. Method tries to start transaction.
     */
    @Override
    protected void onBeforeRequestDeserialized(String serializedRequest) {
        startUserTransaction();
    }

    /**
     * Overridden for transaction management. 
     * Method tries to roll back transaction and fill
     * response data.
     */
    @Override
    protected void doUnexpectedFailure(Throwable e) {
        logger.error(e.getLocalizedMessage(), e);
        resolveUserTransaction(false);
        respondWithFailure(getThreadLocalResponse(), e);
    }

    /**
     * Overridden for transaction management. 
     * Method tries to complete transaction depends on
     * returned data.
     */
    @Override
    protected void onAfterResponseSerialized(String serializedResponse) {
        resolveUserTransaction(isResponseSuccessfull(serializedResponse));
    }

    /**
     * Method notify force commit to TX manager.
     */
    protected void forceCommitUserTransaction() {
        resolveUserTransaction(true);
    }

    /**
     * Method fills response data for unexpected error occurring.
     * 
     * @param response response
     * @param ex error
     */
    private void respondWithFailure(HttpServletResponse response, Throwable ex) {
        try {
            response.setContentType("text/plain");
            response.setStatus(HttpServletResponse.SC_OK);
            response.getWriter().write(ex.getLocalizedMessage());
        } catch (IOException e) {
            logger.error("respondWithFailure failed while sending"
                            + " the previous failure to the client", e);
        }
    }

    /**
     * Method tries to start transaction.
     */
    private void startUserTransaction() {
        TransactionStatus status = txManager.getTransaction(new DefaultTransactionDefinition());
        if (!status.isNewTransaction()) {
            logger.warn("Transaction is not new. Check your services workflow.");
        }
        txStatus.set(status);
    }

    /**
     * Method checks serialized response for correctness.
     * 
     * @param serializedResponse response
     * @return <code>true</code> if response processed correctly, otherwise <code>false</code>
     */
    private boolean isResponseSuccessfull(String serializedResponse) {
        boolean result = true;
        if (serializedResponse == null) {
            result = false;
        } else if (serializedResponse.startsWith("//OK")) {
            result = true;
        } else if (serializedResponse.startsWith("//EX")) {
            result = false;
        }
        return result;
    }

    /**
     * Method resolves transaction for current thread.
* <b>NOTE:</b> we have single threaded transactions here.
     * 
     * @param isResponseSuccessfull value indicates response correctness
     */
    private void resolveUserTransaction(boolean isResponseSuccessfull) {
        TransactionStatus status = txStatus.get();
        try {
            if (status != null && !status.isCompleted()) {
                if (!isResponseSuccessfull || status.isRollbackOnly()) {
                    txManager.rollback(status);
                    if (logger.isDebugEnabled()) {
                        logger.debug("Transaction is rolled back.");
                    }
                } else {
                    try {
                        txManager.commit(status);
                        if (logger.isTraceEnabled()) {
                            logger.trace("Transaction is commited.");
                        }
                    } catch (Throwable e) {
                        if(!status.isCompleted()){
                            txManager.rollback(status);
                        }
                        if (logger.isDebugEnabled()) {
                            logger.debug("Transaction is rolled back.");
                        }
                        throw e;
                    }
                }
            } else {
                if (logger.isTraceEnabled()) {
                    logger.trace("Transaction is not present or completed"
                                    + " after service work completion.");
                }
            }
        } catch (RuntimeException e) {
            throw e;
        } catch (Throwable e) {
            throw new RuntimeException(e.getLocalizedMessage(), e);
        } finally {
            txStatus.remove();
        }
    }

    @Autowired
    public void setTransactionManager(@Qualifier("transactionManager")
                                             PlatformTransactionManager manager) {
        this.txManager = manager;
    }

    /**
     * {@inheritDoc}
     */
    public void setServletConfig(ServletConfig servletConfig) {
        this.config = servletConfig;
    }

    @Override
    public ServletConfig getServletConfig() {
        if (config != null) {
            return config;
        }
        return super.getServletConfig();
    }

    /**
     * {@inheritDoc}
     */
    public void afterPropertiesSet() throws Exception {
        validateInitialization(txManager);
    }

    /**
     * Method validates the given collection of properties and 
     * if it contains <code>null</code>
     * {@link BeanInitializationException} will be thrown.
     * 
     * @param properties properties to validate
     */
    protected void validateInitialization(Object... properties) {
        // org.apache.commons.lang.ArrayUtils
        if (ArrayUtils.contains(properties, null))
            throw new BeanInitializationException(getClass().getSimpleName()
                            + " bean is not initialized correctly. "
                            + "Initialize all properties before usage.");
    }

    /**
     * Performs deserialization.
     */
    private void readObject(ObjectInputStream aInputStream) throws ClassNotFoundException,
                    IOException {
        aInputStream.defaultReadObject();
        // I store Spring application context in separate class
        ApplicationContext context = ApplicationContextHolder.getContext();
        if (context == null) {
            logger.error("Spring is not initialized yet but system tries to deserialize "
                            + "Spring dependent component.\n "
                            + "It can be system error in a case of cluster "
                            + "or smth else.\n But it also can be a "
                            + "simple warning in a case of system restart when "
                            + "Servlet container tries to restore "
                            + "previous state of Http servlets\n "
                            + "In this case just skip this error.");
        } else {
            context.getAutowireCapableBeanFactory().autowireBean(this);
        }
    }
}

where ApplicationContextHolder looks like:

@Component
public final class ApplicationContextHolder implements ApplicationContextAware {
    /** Spring application context. */
    private static ApplicationContext context;

    public void setApplicationContext(ApplicationContext applicationContext) throws BeansException {
        ApplicationContextHolder.context = applicationContext;
    }

    public static ApplicationContext getContext() {
        return context;
    }
}

Include the following lines into Spring XML configuration file to allow handling HTTP requests by annotated HTTP servlets:

<bean class="org.springframework.web.servlet.handler.SimpleServletHandlerAdapter" />

and do not forget mapping of Spring Dispatcher servlet in web.xml for each GWT module:

<servlet>
 <servlet-name>ApplicationServlet</servlet-name>
 <servlet-class>
  org.springframework.web.servlet.DispatcherServlet
 </servlet-class>
</servlet>

<servlet-mapping>
 <servlet-name>ApplicationServlet</servlet-name>
 <url-pattern>
  /com.test.gwt.Module/dispatcher/*
 </url-pattern>
</servlet-mapping>

Example of Spring annotated GWT servlet (and of course you can Autowire any field of this class using Spring):

@Controller
@RequestMapping(value = "/**/test")
public class TestServiceImpl extends SpringIntegratedTransactionalGWTService implements ITestService {

    public void test(){
        System.out.println("Tx GWT Service called.");
    }
}

where ITestService is:

public interface ITestService extends RemoteService {
    public void test();
}

and corresponding async service:

public interface ITestServiceAsync {
     public void test(AsyncCallback<Void> callback);
}

Let's create void async callback (for testing purposes):

public class VoidAsyncCallback implements AsyncCallback<Void> {

    public void onFailure(Throwable caught) {
        GWT.log("Void Request processing fails", caught);
    }

    public void onSuccess(Void result) {
        GWT.log("Void Request processed successfully", null);
    }
}

And example of GWT remote service usage:

IAdministrationServiceAsync service = GWT.create(IAdministrationService.class);
ServiceDefTarget endpoint = (ServiceDefTarget) service;
String moduleRelativeURL = GWT.getModuleBaseURL() + "dispatcher/test";
endpoint.setServiceEntryPoint(moduleRelativeURL);

service.test(new VoidAsyncCallback());