optimistic-locking

I'd like to run tests that simulate users modifying certain data at the same time for a grails application. Are there any plug-ins / tools / mechanisms I can use to do this efficiently? They don't have to be grails specific. It should be possible to fire multiple actions in parallel. I'd prefer to run the tests on functional level (so far I'm using Selenium for other tests) to see the results from the user perspective. Of course this can be done in addition to integration testing if you'd recommend to run concurrent modification tests on integration level as well. I have used Geb (http:/

In my current project I use Spring Data JPA with Hibernate but consider this as a more general question that should also cover "plain" JPA. I'm uncertain how I should deal with OptimisticLockException when using @Version . Due to how my application works some relationships have CascadeType.PERSIST and CascadeType.REFRESH , others also have CascadeType.MERGE . Where to handle OptimisticLockException As far as I can tell handling this on the service layer won't work especially with CascadeType.MERGE because then the offending entity could be one that needs to be handled by another service ( I

Assume I'd like to implement some kind of optimistic locking and use ETags to indicate the most up to date resource state. This means, clients will use an If-Match header when PUT ting for an update. According to the HTTP spec , the server has to return 412 Precondition failed if the ETag provided for the If-Match header doesn't match the current state of the resource. However, 409 Conflict seems to be closer to what I want to express semantically, especially as it gives guidelines what to include in the response. Is it terribly wrong to rather return 409 in case of a failure to match an ETag

I am writing a web application where two different users can update a list of things, to do list, for example. I have come to realize that, optimistic locking mechanism works best since I don't expect high contention. I was looking at transaction isolation levels and now I am a little confused. Looks like different transaction isolation levels also solve similar problems. How are these two different concepts related to each other? If possible, with a simple example. Both of these things are related to data consistency and concurrent access, but they are two different mechanisms. Locking

I have a many-to-many relationship where the link table has an additional property. Hence the link table is represented by an entity class too and called Composition . The primary key of Composition is an @Embeddable linking to the according entities, eg. 2 @ManyToOne references. It can happen that a user makes an error when selecting either of the 2 references and hence the composite primary key must be updated. However due to how JPA (hibernate) works this will of course always create a new row (insert) instead of an update and the old Composition will still exist. The end result being that