BowerStudios.com

My typical method for rounding numbers failed me when accessing an industrial device, and I was puzzled as to why.

BigInteger checksum(final BigInteger checksum, final BigDecimal val){
  return checksum + Math.round(val)
}

What I didn't realize was that there were multiple ways of performing tie breaking when doing rounding. Wikipedia has a nice article defining Tie breaking

I needed to define the Rounding Mode
BigInteger newSum = checksum + val.setScale(0, RoundingMode.HALF_EVEN)

Useful links:

• This post clued me in as to what to do: Stackoverflow by Grodriguez
• Rounding Modes
• BigDecimal.setScale
• Nice stack overflow post regarding the difference between setScale and round
• Additional detail on the difference between setScale and round fromaraklefestel referenced by the stack overflow post above

stackoverflow

Nice summary of setMaxInactiveInterval by BalusC on stackoverflow

I found it helpful in conjunction with this answer by sourcedelica

The idea being, that we can automatically log users with certain roles out of the application automatically after a certain amount of time.

As implemented in Grails with Spring Security:

Create a class MyAppAuthenticationSuccessHandler:
class MyAppAuthenticationSuccessHandler extends AjaxAwareAuthenticationSuccessHandler {
@Override
public void onAuthenticationSuccess(final HttpServletRequest request, final HttpServletResponse response,
final Authentication authentication) throws ServletException, IOException {
if(authentication?.authorities){
authentication.authorities.each{ GrantedAuthority grantedAuth ->
if(grantedAuth.authority.equals("ROLE_OPS_USER")){
// For Ops users, timeout after 10 minutes
request.session.setMaxInactiveInterval(10*60)
}
}
}
super.onAuthenticationSuccess(request, response, authentication);
}
}

In resources.groovy:

authenticationSuccessHandler(MyAppAuthenticationSuccessHandler) {
requestCache = ref('requestCache')
defaultTargetUrl = SpringSecurityUtils.securityConfig.successHandler.defaultTargetUrl // '/'
alwaysUseDefaultTargetUrl = SpringSecurityUtils.securityConfig.successHandler.alwaysUseDefault // false
targetUrlParameter = SpringSecurityUtils.securityConfig.successHandler.targetUrlParameter // 'spring-security-redirect'
ajaxSuccessUrl = SpringSecurityUtils.securityConfig.successHandler.ajaxSuccessUrl // '/login/ajaxSuccess'
useReferer = SpringSecurityUtils.securityConfig.successHandler.useReferer // false
redirectStrategy = ref('redirectStrategy')
}

• Create and Use Self-Signed Certificates - Particularly this bit (modified for my env) about exporting a key from your keystore, and importing it into the trust store:
  Export the certificate
  keytool -export -rfc -alias tomcat -file tomcat.cer -keystore .keystore -keypass changeit -storepass changeit
  Import the "self" certificate into the truststore
  keytool -import -v -trustcacerts -alias tomcat -file tomcat.cer -keystore /etc/ssl/certs/java/cacerts -storepass changeit
• Adding self-signed https certificates to java keystore
• Configure Java to use a specific Truststore
  -Djavax.net.ssl.trustStore="C:\ca.keystore"
-Djavax.net.ssl.trustStorePassword="password"

On StackOverflow

More info about the elements function in the Hibernate docs

It might be easier to just setup an instance of CAS on a developer's machine rather than trying to work around your security in your development environment. Here's how:

General Configuration we'll setup:
Apache Web server on Ubuntu. We'll just use Apache for ssl and connect to Apache Tomcat 6 over ajp.

Add a hostname to use throughout the guide. I'll use defiant.
sudo vi /etc/hosts
127.0.1.1 defiant

Install Apache
sudo apt-get install apache2

Enable ssl module and default ssl site for apache
sudo a2enmod ssl
sudo a2ensite default-ssl

Add a mapping from apache to cas in the default-ssl apache conf: /etc/apache2/sites-enabled/default-ssl
<Location /cas>
ProxyPass ajp://defiant:9009/cas
SSLRequireSSL
</Location>

Enable mod proxy_ajp (also enables mod proxy)
sudo a2enmod proxy_ajp

Generate the ssl key Guide
cd /etc/ssl
sudo openssl genrsa -out private/defiant.key 2048
sudo openssl req -new -key private/defiant.key -out private/defiant.csr
sudo openssl x509 -req -days 3650 -in private/defiant.csr -signkey private/defiant.key -out certs/defiant.crt
make sure you use the name you entered in the hosts file as the "COMMON NAME"

Restart apache
sudo apachectl restart

Import the self-signed cert into java (https://bowerstudios.com/node/569)
sudo keytool -import -file certs/defiant.crt -keypass changeit -keystore /etc/ssl/certs/java/cacerts -alias defiant

Untar tomcat to /usr/local/bin (I'm using my own version instead of the packaged version as I've made a few small config changes.
Change the ports 8005, 8080 and 8009 in conf/server.xml to 9005, 9080 and 9009

In the current state, you will have apache, ssl and tomcat setup, you'll just need to configure cas and drop it in.

Several libraries are currently available:

• opencsv
• javacsv
• mindprod
• A discussion on stackoverflow

StackOverflow
SourceForge

A nice summary on Stack Overflow

I use the Maven properties plugin quite a bit, so I created a bash function for it.

In .bashrc add these lines:
function mvnr {
mvn properties:read-project-properties "$@"
}

I enjoy using lib-notify, but I forget to use it a lot, so I redefined the execution for mvn to add it automatically. For good measure, I did the same to ant and gradle.

This is all done on Ubuntu 12.04 with .bashrc in the home directory, but it should work for any unix based os that has the lib-notify library, the syntax may be slightly different is all.

First we need to comment out the existing alert alias.
# Add an "alert" alias for long running commands. Use like so:
# sleep 10; alert
#alias alert='notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e '\''s/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//'\'')"'

Now we transform it into a function and add an additional step, play a sound.
function alert {
notify-send --urgency=low -i "$([ $? = 0 ] && echo terminal || echo error)" "$(history|tail -n1|sed -e 's/^\s*[0-9]\+\s*//;s/[;&|]\s*alert$//')"
play -q /path/to/a/sound/file.wav
}

Now that the alert alias is a function, we can reuse it in the mvnr function we added above
function mvnr {
mvn properties:read-project-properties "$@"
# if using the mvn function below, comment the next line to avoid getting two notifications
alert
}

Let's spread that alert functionality across maven, ant and gradle. We need to specify the full path to the executable since we are redefining the "alias", else we'll get an infinite loop.
function mvn {
$MAVEN_HOME/bin/mvn "$@"
alert
}
function ant {
$ANT_HOME/bin/ant "$@"
alert
}
function gradle {
$GRADLE_HOME/bin/gradle "$@"
alert
}

I heartily recommend taking advantage of lib-notify for any build system: maven, gradle, ant, make, rake, etc.