solution: I am still not sure if the scripts executed at boot sequence are executed as root user with limited environment or they are executed as System user. But none the less, execute your commands as stated below

su -u root -l -c "<command>"

This will execute the command you want to execute as the root user, with his own environment as if he is logged in while executing the command.

This comes in handy when lot of tools like svn, git manages authentication using files stored in user home directory, also there are certain path elements which are just too much to setup again.

solution: There is only one elegant solution where, you mention dependency in a single bean configuration. This will avoid the circular referencing and to complete the bean initialization use a BeanPostProcessor, which would complete the initialization of the second bean. I found the code sample in this discussion thread at the bottom.

solution: One of our brilliant developers Avlesh came up with an approach of using url rewriter for converting old urls into new urls. Ours being a java based app, we were already using UrlRewriteFilter. If you are using apache, you could go along with mod_rewrite. Make sure that the old urls get permanently redirected (HTTP 301) to the new URLs. Permanently redirecting a url will suggest search engines that they need to stop service the old URL for any search request, and the new URL takes over the legacy of old one.

solution: Will explain why, but the only solution is to flush session after update and then execute the insert command.

description: Search for “The SQL statements are issued in the following order” without quote on this hibernate documentation. Just for the lazy folks, here is what it says.

The SQL statements are issued in the following order

• all entity insertions, in the same order the corresponding objects were saved using ISession.Save()
• all entity updates
• all collection deletions
• all collection element deletions, updates and insertions
• all collection insertions
• all entity deletions, in the same order the corresponding objects were deleted using ISession.Delete()

(An exception is that objects using native ID generation are inserted when they are saved.)

Except when you explicity Flush(), there are absolutely no guarantees about when the Session executes the JDBC calls, only the order in which they are executed.

solution: The issue is due to the loopback interface not being properly configured. When system boots, it configures network interfaces as per configuration in file “/etc/network/interfaces”. localhost is identified and pingable if interface lo (loopback) is configured. Make sure that following entry is present in the interfaces file –

auto lo
iface lo inet loopback

After saving the file execute “sudo /etc/init.d/networking restart”. This will reload the configuration. Execute “ifconfig lo” to check if you get inet addr:127.0.0.1

solution: Actually it was my mistake that I used the sql Date object, assuming that as it inherits java.util.Date the object behavior would remain same (how foolish of me to expect correct inheritance implementation).  The sql Date tries to imitate database Date object where it does not contain time details. So the solution is to create java.util.Date always with SimpleDateFormat rather than java.sql.Date.

solution:Accept a URL in your appplication with all the parameters requred and in URL rewrite itself, reroute it to internal IP address with the request parameters as it is.

solution:While creating connection using jdbc, use useOldAliasMetadataBehavior=true

description: As per JDBC specification result set interface should provide two methods getColumnName and getColumnLabel. But old MySQL JConnector versions provide only getColumnName method and which returns the column alias (or label). In Certain release (dont remember which one) they started providing both methods, but to keep backward compatibility they introduced a parameter “useOldAliasMetadataBehavior” which would make getColumnName return alias and all the existing applications would still work. Till JConnector release 5.1 default value for this option was true, thus we never faced the heat. When I upgrade to 5.1.x, default value has been set to false and hibernate still thinks that MySQL JConnector would return alias on getColumnName method call.

The only work around till hibernates dialect incorporates this behavior it to explicitly setting option “useOldAliasMetadataBehavior=true“.

solution:Its not a universal solution as such, but please check if the constriant was created properly. If at the time of constraint creation FOREIGN_KEY_CHECKS was set to 0/false; the constraint definition would be stored in information_schema without evaluating if the table/column/schema names used even exists.

description:Though at first glance the behavior of not checking the schema name looks sinister, the very flag FOREIGN_KEY_CHECKS tells MySQL that constriants are not to be checked. This would simple use the table/constraint creation script to dump the definition in information_schema and would be used to evaluate the constraint when activated.

And as the MySQL error descriptions are as bad as they can be, whatever failure happens with data insertion in case of constraint evaluation is coined as constriant failure.

solutiong: There are two ways we can do it.

• eval(‘function_name’+'()’);
• window['function_name']();

description: There isn’t much to discuss about eval way. Its a standard javascript function which can be used to execute javascript code which is in string form. Its perfect to construct method call and execute it.

The second interesting part is using window as array of objects. Window is a very high level object and all the functions, objects and variables defined at global level are stored with it as if its an array. These objects (function is an object) can be referred by their names as keys.

Back to basics of javascript: Everything in javascript is finally stored as an array.