Since most of our software runs on JVM, we’ve had our share of experience with crashing JVMs (Out Of Any Kind Of Memory), tuning JVM and optimizing its performance. Some are on 32-bit JVMs, others on 64-bits. Some run many small applications, others run bigger applications. Some run resin, others JBoss yet there are some running Tomcat. Most are on Linux, some Windows.

But they all have some things in common:

• they must run 24/7
• they all run server VMs
• they are all web applications

While there is no real way to tell which options will make your JVM work best, we’ve found the following to be helpful. I thought it would be nice to share:

-Xms1024m -Xmx1024m
Setting both Xmx and Xms to the same value will help eliminate memory fragmentation. Your application should run a bit faster, as the VM will not start at minimum and allocate additional memory as the application server / your application starts up.

-XX:MaxPermSize=512M
You will most certainly want to increase your permanent generation size, as the default is often too small. Here we’ve set it to half of assigned memory and works quite fine.

-Xmn128m
Change the new generation size. If your application is creating and releasing a lot of objects in short time (usually correlated with number of connections, usage of your website), you may find yourself with a JVM crashing when the “eden / new generation” has been exhausted. This will show up as “100% eden” in the crash log. Increasing the new generation size might help.

-Xss2m
Each thread in the JVM will get its own stack. The default stack is quite small and setting it a bit higher is usually a good idea. 2048k should be enough usually appropriate for most usage scenarios, but your mileage may vary. Increased when you have really long stacks (quite common if using a servlet container + several frameworks). Your first sign of having a too short stack will be a StackOverflowError.

-Dsun.rmi.dgc.client.gcInterval=3600000 -Dsun.rmi.dgc.server.gcInterval=3600000
These two parameters increate garbage collection interval for RMI connections. Mostly a JBoss issue, but other app servers run just fine with this settings. Should also speed things up a bit.

-Dsun.net.inetaddr.ttl=30
Sun’s Oracle’s JVM has a “feature” which cashes all DNS lookups. Forever. This might be an issue if the some of the external services changes IP and you don’t restart your server very often (reCaptha is one such example). Set this parameter and have JVM forget lookups after a certain time.

-XX:+UseConcMarkSweepGC
Change the garbage collector. We’ve had better experiences using UseConcMarkSweepGC, especially on multi-processor machines. Although, it seems “G1” will be the best after it’s finished.

-XX:+CMSPermGenSweepingEnabled -XX:+CMSClassUnloadingEnabled
Support class unloading. Usefull even in production, as it allows you to completely undeploy the previous application if you’re doing hot-deployment. One option name is old (CMSClassUnloadingEnabled) the other new (CMSPermGenSweepingEnabled) but both still work though.

-Dfile.encoding=utf-8
Since we don’t speak US-ASCII only, we moved everything to UTF-8 several years ago. Even all our JSP pages are defined as @page encoding=”UTF-8” contentType=”..; charset=UTF-8” You would be amazed how are i18n problems just vanished. UTF-8 rules.

-Denvironment.type=prod
We “mark” our servers as “prod”, “test” and “dev”. In ideal world this would not be necessary, but sometimes the code needs to know in which environment it runs. This helps avoid confusion and have that same setting in several different places and each person inventing his own way of determening the enviornment.

-Dorg.apache.catalina.STRICT_SERVLET_COMPLIANCE=false
Tomcat goodie. Being too much servlet-compliant is not always a good thing^(TM). This relaxes some strange constrains that makes applications — especially ones ported from other servlet containers — run better. Sometimes, applications will not run without this parameter at all. If you’re concerned about cross-container compatibility, leave this parameter out and develop exclusively on Tomcat. If you’re running applications developed by different teams and/or vendors, by all means, put it in.

-XX:+UseCompressedOops
Using compressed oopts will decrease your memory usage when running 64-bit JVMs. In a nutshell, it tells JVM to use 32-bit pointers around the code (where possible).

-ea
For development/staging only. Enable assertions. If you’re a prudent developer, you’re code will have a lot of sanity checks. This will enable them. This way it’s easier to spot errors before going live.

-Dcom.sun.xml.ws.transport.http.client.HttpTransportPipe.dump=true -Dcom.sun.xml.ws.transport.http.HttpAdapter.dump=true -Dcom.sun.xml.ws.util.pipe.StandaloneTubeAssembler.dump=true
For development/staging only. Enable debugging of JAX-WS /WSIT. All communication (XMLs, HTTP trafic) of webservices will be dumped to your STDOUT. If you’re having problems with webservices and don’t know what’s wrong, sometimes this is the only way to go.

If you have any other useful options, I’d be more than happy to add them to the list.

Bookmark and Share

More »

Powered by Bookmarkify™

Seen a lot of these in your jboss logs?

[com.arjuna.ats.jta.logging.loggerI18N] [com.arjuna.ats.internal.jta.resources.arjunacore.preparefailed] [com.arjuna.ats.internal.jta.resources.arjunacore.preparefailed] XAResourceRecord.prepare - prepare failed with exception XAException.XAER_RMERR
…
javax.transaction.HeuristicMixedException
at com.arjuna.ats.internal.jta.transaction.arjunacore.TransactionImple.commitAndDisassociate(TransactionImple.java:1390)
at com.arjuna.ats.internal.jta.transaction.arjunacore.BaseTransaction.commit(BaseTransaction.java:135)
at com.arjuna.ats.jbossatx.BaseTransactionManagerDelegate.commit(BaseTransactionManagerDelegate.java:87)
at org.jboss.tm.usertx.client.ServerVMClientUserTransaction.commit(ServerVMClientUserTransaction.java:140)

I’ve had this issue with jBoss and Postgres XA datasource after upgrading from Postgres 8.1 to Postgres 8.4.

Was quite puzzled by it, I even tried hacking the jbossjta-properties.xml and datasource config. Nothing worked, Google was of no help.

Later I found out that — surprisingly — reading the manuals helps.

To be exact, there’s a passage in the documentation that states:

If you are using prepared transactions, you will probably want max_prepared_transactions to be at least as large as max_connections, so that every session can have a prepared transaction pending.

By default (since 8.3) I think this parameter is set to “0” and was “5” before that. We copied an older config over and we had it at “5”.

So, since we had max_connections set to 512, I’ve changed the max_prepared_transactions to 1024, restarted the server (reload won’t suffice) and - voila - things started working.

Another one of those: “you need to remember this for the next time”.

Bookmark and Share

More »

Powered by Bookmarkify™

After being quite dissatisfied with the current state of database appenders for log4j (see examples here, here and here) I’ve decided to write my own.

Features:

• uses PreparedStatements exclusively. No more messing with queries, quotes and similar stuff
• uses batch mode to speed up inserts
• inserts are done in another thread to prevent delays with logging
• uses DataSources to better manage database connectivity
• query is database-independent (any SQL-92 compliant server should work)
• config-compatible with Danko’s implementation
• table name and column names can be configured
• does not care if your table has an ID column or not
• drops statements on SQL error

What else could be done?

• Better handling of exceptions. We could keep logged statements (up to a point) or spill them over to another Appender.
• Add the possibility to call a stored procedure instead of doing bulk insert

Without further ado, here’s the code. I’m releasing it under BSD license, so feel free to hack it in any way you like. But if you do make it better, please let me know so I can publish it here.

Bookmark and Share

More »

Powered by Bookmarkify™

Maybe some of you know of that you can speed up your speed up your application a lot, if you compress your CSSs and javascripts. Maybe some of you do it manually or have used online tools. You might have even heard of YUI compressor, which doesn’t use search&repleace but Rhino to analyze your code, making the compression process even more robust.

But, until now you always had to do it manually. Now I have a solution for you: automatic compression of your javascripts and CSSs.

I have created a simple filter that compresses the code on the fly. This makes it transparent to use and seeds up transfer times. Just make sure you cache the result through a cache filter and/or reverse proxy and/or by setting cache headers or you’ll see increased processor usage which won’t make your sysadmin happy.

Usage.

• download the code
• compile with Maven, if you changed anything
• Put this in your web.xml:

<filter>
 <filter-name>CssAndJSCompressorFilter</filter-name>
 <filter-class>com.parsek.web.CssAndJSCompressorFilter</filter-class>
</filter>

<filter-mapping>
 <filter-name>CssAndJSCompressorFilter</filter-name>
 <url-pattern>*.css</url-pattern>
 <dispatcher>REQUEST</dispatcher>
</filter-mapping>

<filter-mapping>
 <filter-name>CssAndJSCompressorFilter</filter-name>
 <url-pattern>*.js</url-pattern>
 <dispatcher>REQUEST</dispatcher>
</filter-mapping>

I’m releasing the code under LGPLv3, so you are free to use it anywhere you want. If you find it useful, do mention my name and put a link to this site and leave a comment how you are using it.

Download the code.

Bookmark and Share

More »

Powered by Bookmarkify™

Recently I’ve came up with a problem that required that I made part of our SVN tree accessible to an outside partner. Of course we did not want to give him access to everything. My first thought was to just use apache reverse proxy and proxy one suburl to root of the public server. Boy was I wrong.

Googling around discovered that this is at least tricky but better yet impossible to do. Therefore, my another solution involved exporting the tree under the same URL but also adding some rewriting rules to make it more user friendly. Wrong, again.

As it turns out your also need to export the virtual !svn directory to make things work. Here it goes, the final solution that seems to be working at the moment:

<VirtualHost *:443>
        ServerAdmin     admin@example.org
        ServerName      project-svn.example.net
        DocumentRoot    /store/web/proxy

        SSLEngine               on
        SSLProtocol             all -SSLv2
        SSLCipherSuite          ALL:!ADH:!EXPORT:!SSLv2:RC4+RSA:+HIGH:+MEDIUM:+LOW
        SSLCertificateFile      /etc/httpd/conf.d/project-svn.example.net.ssl/_.example.net.crt
        SSLCertificateKeyFile   /etc/httpd/conf.d/project-svn.example.net.ssl/_.example.net.key
        SSLCertificateChainFile /etc/httpd/conf.d/project-svn.example.net.ssl/exampleca.crt

        SetEnv          force-proxy-request-1.0 1
        SetEnv          proxy-nokeepalive       1
        SetEnvIf        User-Agent ".*MSIE.*" nokeepalive ssl-unclean-shutdown downgrade-1.0 force-response-1.0

        ErrorLog        "|/usr/sbin/rotatelogs /var/log/httpd/project-svn.example.net/error.443.log.%Y-%m-%d 86400"
        CustomLog       "|/usr/sbin/rotatelogs /var/log/httpd/project-svn.example.net/access.443.log.%Y-%m-%d 86400" full

        <IfModule mod_deflate.c>
            <IfModule mod_headers.c>
                Header set Accept-Encoding "gzip, deflate"
            </IfModule>
            SetInputFilter DEFLATE
            SetOutputFilter DEFLATE
            DeflateFilterNote Input instream
            DeflateFilterNote Output outstream
            DeflateFilterNote Ratio ratio
            BrowserMatch ^Mozilla/4 gzip-only-text/html
            BrowserMatch ^Mozilla/4\.0[678] no-gzip
            BrowserMatch \bMSI[E] !no-gzip !gzip-only-text/html
            SetEnvIfNoCase Request_URI \.(?:gif|jpe?g|png|jar|zip|rar|mpe?g)$ no-gzip dont-vary
            Header append Vary User-Agent env=!dont-vary
        </IfModule>

        ProxyPass               /svnindex.xsl                   http://svn.internal.pri/svnindex.xsl
        ProxyPassReverse        /svnindex.xsl                   http://svn.internal.pri/svnindex.xsl
        ProxyPass               /css/                           http://svn.internal.pri/css/
        ProxyPassReverse        /css/                           http://svn.internal.pri/css/
        ProxyPass               /images/                        http://svn.internal.pri/images/
        ProxyPassReverse        /images/                        http://svn.internal.pri/images/
        ProxyPass               /svnroot/projects/PCKB/         http://svn.internal.pri/svnroot/projects/PCKB/
        ProxyPassReverse        /svnroot/projects/PCKB/         http://svn.internal.pri/svnroot/projects/PCKB/
        ProxyPass               /svnroot/!svn/                  http://svn.internal.pri/svnroot/!svn/
        ProxyPassReverse        /svnroot/!svn/                  http://svn.internal.pri/svnroot/!svn/

        RewriteEngine   on

        RewriteCond             %{SERVER_NAME}  ^project-svn\.example\.net$ [NC]
        RewriteCond             %{REQUEST_URI}  ^(/svnroot(/projects)?)?/?$ [NC]
        RewriteRule             ^(.*)$          /svnroot/projects/PCKB/ [R=301,L]

        RewriteCond             %{SERVER_NAME}  ^project-svn\.example\.net$ [NC]
        RewriteCond             %{REQUEST_URI}  ^/svnroot/projects/PCKB$ [NC]
        RewriteRule             ^(.*)$          /svnroot/projects/PCKB/ [R=301,L]

        RewriteCond             %{SERVER_NAME}  ^project-svn\.example\.net$ [NC]
        RewriteCond             %{REQUEST_URI}  !^/(svnindex.xsl$|css/.+|images/.+|svnroot/(!svn/|projects/PCKB)).*$ [NC]
        RewriteRule             ^(.*)$          /svnroot/projects/PCKB$0 [R=301]
</VirtualHost>

Few notes about the the configuration:

• the project we are exporting is PCKB
• our SVN lives on http://svn.internal.pri/svnroot
• browser output is beautified through a stylesheet, therefore we’ll need to proxy it also along with all required resources
• no security is enforced on the proxy:: back end apache handles all security and is configured for complete authentication (read + write) when requesting the repository through the proxy

Bookmark and Share

More »

Powered by Bookmarkify™

If you have ever banged your head when using JAX-WS / WSIT at this error:


[ERROR] fault "getBusinessCaseFault" in operation "getBusinessCase" does not have a SOAP fault extension
line 3213 of file:/service.wsdl


Boy than I have a solution for you. As it turns out, your WSDL was probably generated by Axis. And, as it turns out, it was probably faulty. Our WSDL included 40-something methods and the first 32 were OK, but the last few were invalid and caused the parser to choke.

Look for <wsdl:operation…> tag and in it you’ll see something like this:

<wsdl:fault name="getBusinessCaseHistoryFault">


When in fact, it should be like this:

<wsdl:fault name="getBusinessCaseHistoryFault">
<soap:fault name="getBusinessCaseHistoryFault" use="literal" />
</wsdl:fault>


After we fixed these elements everything went on just fine. I am still not quite sure whether it’s JAX-WS’ or Axis’ bug, the specification seems to be a bit fuzzy on this issue. But nevertheless, things started working.

Just thought it would be nice to share.

Bookmark and Share

More »

Powered by Bookmarkify™

Recently I’ve taken up the task of learning Python after being quite a few years in Java. There are some posts — biased towards Python IMHO — that I’ve tried to take into account, but I just thought I’d throw in my €0.02.

Please note that while I’ve been working with Java for quite a few years, I’ve just started learning Python, but it’s not the first dynamic language I’ve used. If anything, I’ve mastered javascript and even used it as a core feature for an insurance enterprise system and are quite aware of pros and cons of dynamic vs. static languages.

If you see anything wrong or disagree, please let me know. Now, let’s go sink our teeth into side by side comparison.

Java vs. Python Productivity - an Overview

String printf(Object... args) {
	printf("Default message", args);
}
 
String printf(String message, Object... args) {
	// code here
}
 
...
 
// Usage
printf(1, 2, 3, 4);
printf("Hello world", "foo","bar", 5.5d);
List a = new ArrayList();
a.add(1);
a.add("foo");
a.add("bar");
printf("Hello world", a);
printf(a);

def printf(message="Hello world", *args):
	# the code
 
...
 
# Usage
printf(1, 2, 3, 4)
printf("Hello world", "foo", "bar", 5.5)
# Note:
# printf(message = 'Hello world', "foo", "bar")
# will not work
printf(message = 'Hello world')

If you are new to Python, there is a nice post explaining its core features in 10 minutes. My verdict so far? Python¹ can be more productive in small-scale scenarios. Great language to write scripts, jobs, crons, small, fast and hacked-up webs but not really something I would base my enterprise solution on. But, on the other hand, enterprise applications have the need for scripting, crons, jobs, small tasks which can be edited by the end user (Administrator) without the need for restaring the server or redeploying the application. The best way to accomplish this task would be by using a language such as Python.

Note:

¹ I am comparing core language features only, not frameworks built on top of it, i.e. Django, Groovy, Seam or Rails.

² Tried with node.textContent only.

³ Actually, I haven’t had that much experience with python yet, but as I understand, this are direct wrappers/copies of OS functions with same names.

⁴ The function strptime, for example, will not parse the timezone in format “+/-hh:mm”. Even named timezones (i.e. PST, DST) are only checked and not processed. You can do it with an external library though.

Bookmark and Share

More »

Powered by Bookmarkify™

I was sent this nice link from a friend and a cooworker today.

Worth checking it out.

Bookmark and Share

More »

Powered by Bookmarkify™

I was just thinking the other day, how funny the licencing business has become. You “buy” things but you do not really buy them, they’re just “lended” to you for an indefinite period of time. Furthermore you’re allowed to use them only in a certain way within a certain timeframe and should not dissasemble or find out how they work.

Imagine yourself buying a shovel at your local hardware store but the label on it clearly states: “This shovel is licenced for grave-digging only. Any other use, including but not limited to gardening, canal digging or backyard rearaning is strictly forbidden. You are not allowed to dissasemble this shovel, change any of it’s parts — regardless of their condition — or lend it to a friend, coworker, family member or any other person, either living or dead. You are allowed to keep only one (1) copy of shovel at any given time in your shed. If you break any rule stated above, licence for this shovel is revoked and the shovel reclaimed automatically.”

Scary, come to think of it.

Bookmark and Share

More »

Powered by Bookmarkify™

Image via Wikipedia

Seems that a lot of people think that Java Collections framework needs an update. There are some resents to how Apache’s Commons Collections Framework is handling things, most of them focusing on not supporting generics and breaking some contracts of the standard collections API.I’ve talked about Apache’s framework before. But behold: another player has entered the playing fields. This time it’s Google. Funny enough they haven’t tried to fix Apache’s API but rather develop their own API which they hope will get included into JDK 7.

I will do some performance measurements between both and let you know which classes are faster and more optimized. Otherwise, Google presents us with the following (new) collection objects:

• BiMap, unique two-way map, equivalent to Apache’s BidiMap.
• Multimap, equivalent to Apache’s MultiMap. Both allow multiple values per single key.
• Multiset is something that Apache calls a Bag. Both allow multiple instances of the same value to appear in a set.
• ReferenceMap. Surprise, Apache has a class with the same name.Both do the same. Allow you to use strong/weak/soft references for keys and values. Both are replacements for weirdly designed WeakHashMap.
• ForwardingMap/List/Set… to aid you in creating your own wrapper classes around other collection objects

The package also adds some utility classes, which can also be found in various other libraries, but it’s nice to know we also have them here:

• PeekingIterator is something that should be in Java’s collection framework in the first place. It allows you to “peek” at the next element without actually grabbing it, as next() does. While not widely useful, it makes some tasks a lot simpler.
• Nullable annotation, which allows you to clearly define that null is an acceptable input parameter for a given metthod. Frankly, I think that JetBrains approach is better of, since it provides both Nullable and NotNull, the JAR is only 6KB and annotations are understood by the GUI. Furthermore, results from method cals can also be annotated.
• numerous other improvements, and utilities to make your life easier, such as creating an ArrayList from Iterator, creating a Map from a list of parameters etc.

Also worth of reading is an interview with Kevin and Jared, authors of the package and especially a comparison that’s available on another blog.

Bookmark and Share

More »

Powered by Bookmarkify™