Archive for the ‘Solutions’ Category

Startup in recovery-only mode

Tuesday, February 1st, 2011

It has happened a couple of times that people have asked me how to startup only the recovery part of their applications. While there is no built-in support in Atomikos (for now), here is a way to do it with Spring:

  • Concentrate your DataSource, ConnectionFactory and TransactionManager bean definitions in one config file, say infrastructure-config.xml (the term will sound familiar to those who practice Domain-Driven Design (DDD)
  • Use this config file in your application; this is your full runtime
  • Create a separate Main that initializes Spring with nothing else but this config; this will be your recovery-only rutime

Voila! Enjoy…

DBCP and XA with Atomikos as JTA

Wednesday, January 12th, 2011

Interesting blog post on how to use DBCP in XA mode, with Atomikos as the JTA…

Maven staging repo for our 3.7.0M5 build

Tuesday, December 7th, 2010


The Sonatype maven staging repo for our latest build is available here


Nice video on Transactions at JavaOne

Friday, November 12th, 2010

In this talk at JavaOne this year, Mark Little does a nice job explaining about transactions and why they are useful. He did a nice job - even if it is on behalf of our competitors;-)

Maven repository being migrated to nexus

Saturday, October 23rd, 2010

Our maven repository is being migrated to a new location with nexus behind it. This means that download emails no longer contain the repository location until this has been implemented…

Thanks for your understanding!

Releases 3.7.0M4 ready

Friday, October 22nd, 2010

The next milestone build in our new maven ecosystem is ready!

We’ve fixed a lot of cosmetic issues from the previous releases (but expect no perfection yet:-).

Available on our website

Releases 3.7.0M2 are out!

Tuesday, October 12th, 2010

Big news: our new 3.7.0M2 releases are out for ExtremeTransactions and TransactionsEssentials!

If you look at the release notes then you will see that there are not that many new features (besides bug fixes and some important performance tuning). So what makes these new releases big news then? It’s our new release process and build infrastructure that made them possible.

That’s right: we have a new build process. We are now officially using maven and mercurial for our builds, instead of ant and svn. Also, we have tuned our repository architecture to better match our business model: we are now tuned towards more frequent releases of ExtremeTransactions and optimized even more for our support business.

So we hope you enjoy the new releases as much as we do! Beware though: they are milestone builds, meaning they are bound to have minor issues still. This is mostly due to initial imperfections in our new build process. After all, it _is_ a new way of working for all of us!

Reflections on the testQuery property

Monday, September 27th, 2010

The Atomikos connection pooling mechanism invalidates connections when there are any errors - just to be sure that later transactions are not corrupted by prior errors on the connection stream to the back-end. Also, sometimes connections simply time out in the back-end, and are closed without warning. So it may happen that you have some ‘erroneous’ connections in the pool at any given time, and you will only find out the next time you try to use one of these connections (i.e., in your application logic you will see exceptions related to this).

To avoid this (and have the pool proactively validate connections for you) just set a testQuery on the AtomikosDataSourceBean instance. The idea is that you supply a snippet of SQL code that can be used by the pool to test if the connection is still valid. If not, it will be replaced automatically - and you should never get any erroneous connection out of the pool.

The fact that the testQuery is optional has been confusing to some users. Consequently, we’ve been asked to make it required or default to something meaningful. We’ve seriously thought about this, but there are a few problems here:

  • Making it required means breaking a lot of existing, working configurations when they upgrade to our newest release. That is because these existing configurations usually do not include any testQuery settings and the new release would fail to read the configuration and initialize correctly - thereby breaking backwards compatibility. We did not want to do this.
  • Providing a reasonable default is equally difficult, if not even harder: it turns out that there is no known SQL statement that will work for all DBMS. So our default testQuery - whichever we choose - would always fail on some systems. We did not want to do this either.

So what did we do to improve this? After some input from our LinkedIn group we now have a serious warning message in the logs whenever you don’t set the testQuery.

Note: this will be available in our very next release - due beginning of October.

Developer access unlimited

Monday, September 20th, 2010

Maybe you have noticed: we have recently changed our developer access formula - based on customer feedback. Whereas the ‘old’ formula used to be ticket-based and expired after 1 month, the new developer access is as follows:

  • There is no limit on the number of issues
  • Expiry is after either 3 or 6 months (your choice) - which gives you plenty of time to experiment
  • There is, however, a limit of 1 named contact at the side of the customer

Again, this is based on input we got from several customers and prospects. Thanks for your feedback!

PS yes, the old formula has been discontinued: we too experienced problems with the issue limit…

SOA: when to favor components over services

Saturday, August 21st, 2010

When implementing a service-oriented architecture (SOA), there is always the choice between components (included modules of reusable functionality) versus services (deployed once, reused by calls over the network).

How do you know which one to choose? There is a lot of things to consider, but these will give you a head-start:

  • if there is a need for different configuration parameters per consumer, favor a component
  • if performance of remote network calls is problematic, favor a component
  • if deploy-once is crucial, favor a service
  • if you have no control over the deployment parameters, favor a service (e.g., if the provider is a third party)
  • to dynamically switch between both, choose service component architecture (SCA)

Also, keep in mind that components require setting up the required infrastructure (database schema, queues, etc) for each deployment.

Probably most readers of this blog post will know about components, because you probably use TransactionsEssentials as a component :-)