My system is configured with a GTX580M gpu, a reguar HDD on Slot 0, and an SSD on Slot 1. I have Windows 7 on the HDD, and my goal is to keep Windows working on this drive, while installing Mint on the SSD. Assuming your goals align, here is what I had to do:

Configuring the BIOS:

The first thing to do is to configure the bios to boot off the Second hard drive (the SSD) first, as this is the drive on which grub will be installed. To do that, go into the bios, and under the Boot menu, set the boot order as -> CD/DVD/BD, Second Hard Drive and finally Hard Drive. Press F10 to save your configuration and exit.

Getting Mint to Boot:

Restart the computer and plop in the Mint 12 DVD. Now normally you would select the Start Linux Mint option, but Mint will fail to boot because acpi runs into problems with the graphics card. To work around this, you will allow you to edit the configuration options passed into the kernel. Highlight this option and press Tab, then right after where it says splash, leave a space and type acpi=off, so it now looks like this:

 quiet splash acpi=off -- 

. Press Enter to boot. You should now be able to boot into the Live Desktop.

The only downside to having acpi off is that your fans will be running at full speed all the time during the install. Don’t worry, we will be able to fix this later.

Installing Mint:

Once the OS has loaded, connect to a Wi-Fi network if possible so the OS can download updates when installing. Click on the CD Icon on the desktop to begin installation. During installation, after you finish partitioning the hard drives, make sure you select the option to install GRUB on the second hard drive, if your configuration is similar to mine. Failing to do so can cause some problems when booting into Windows (the usual ntldr is missing). Installation typically takes about 5 minutes. When its done, pull out the disk and reboot the system.

Rebooting after installation:

You will run into the same acpi issue when rebooting into the operating system, and you will have to edit the kernel params again. When you hit the GRUB page asking you to pick the operating system to boot, highlight “Linux Mint 12″ and hit “e” on your keyboard to edit the configuration. You will again have to add acpi=off to the end of the line which has the quiet and splash options. When you are done, press F10 to boot.

Fixing the GPU:

When you connect to the internet, Mint should automatically detect your graphics card, and ask you to install the restricted drivers from Nvidia. Select the option which says “Post release updates”. Wait for the driver to download and install. Once this is done, also do a full update of the system using the package manager. Now when you reboot your system, you shouldn’t have to edit the kernel params any more, and acpi (which also controls the fans) should work fine.

Fixing Sound:

To fix the sound issue, open a terminal and type

<code>gksudo gedit /etc/modprobe.d/alsa-base.conf</code>

. In the file that opens, append

<code>options snd-hda-intel model=alienware</code>

at the end, in a separate line. Press Ctrl+s to save the file. Now, after you reboot, sound should work fine.

The steps outlined here assume you have a fresh install of Ubuntu 10.04 server, and should pertain to both the 32 and 64 bit versions. <INSTALL_DIR> will be /opt/alfresco.

Installing Java

sudo apt-get install openjdk-6-jre

Setting up MySQL

1. Install MySQL server. During installation, you will have to choose the password for the root user.

sudo apt-get install mysql-server
mysql -u root -p

2. Create a database named alfresco. Also create a user named alfresco and grant the user permissions to the alfresco database. You can replace the value for the password with your own value.

create database alfresco;
select password ('alfresco');
grant all privileges on `alfresco`.* to 'alfresco'@'localhost' identified by password '*F9F457310EF9364D42AABE6D8C24A21712C000B5';
exit

3. Download the Java connector for MySQL from here. Extract the jar file from the download. It is needed when configuring Alfresco.

Installing Alfresco

1. Create a directory named alfresco under /opt/.

2. Create a user named tomcat and assign <INSTALL_DIR> to this user.

sudo mkdir /opt/alfresco
sudo useradd tomcat -M -U -d /opt/alfresco
sudo chown -R tomcat:tomcat /opt/alfresco

3. Download the latest version of Alfresco manual installation package here (version 4.0.d at the time of writing, check if a newer version is available) and Tomcat 7 from here to <INSTALL_DIR> using wget.

4. Install unzip to extract the downloaded files. Unzip the alfresco files to a folder named temp and the tomcat binaries to a folder named tomcat. Move everything under temp/web-server/webapps to tomcat/webapps and move temp/web-server/shared to tomcat/. Also move the MySQL java connector which was downloaded earlier into tomcat’s lib folder. You may find the files under temp/bin useful for installing additional Alfresco modules. If you don’t need these, you can safely remove the temp directory.

sudo -s
apt-get install unzip
su tomcat
cd ~
mkdir temp
mv alfresco.zip temp/
cd temp
unzip alfresco.zip
cd ..
tar -xf apache-tomcat-7-0-23.tar
mv apache-tomcat-7-0-23 tomcat
mv temp/web-server/webapps/* tomcat/webapps
mv temp/web-server/shared tomcat/
mv temp/mysql-connector.jar tomcat/lib
rm -r temp

5. Create a folder named alf_data under <INSTALL_DIR>. This is the main data directory for Alfresco.

6. Install openoffice, pdf2swf and imagemagick

sudo apt-get install imagemagick swftools openoffice.org-common

7. Customize the alfresco-global.properties file found in tomcat/shared/classes. The file below configures Alfresco for the MySQL database, configures open office, imagemagick and swftools, disables ftp and email, and uses the default authentication chain.

###############################
## Common Alfresco Properties #
###############################

#
# Sample custom content and index data location
#
dir.root=/opt/www/alf_data

#
# Sample database connection properties
#
db.name=alfresco
db.username=alfresco
db.password=alfresco
db.host=localhost
db.port=3306

#
# External locations
#-------------
ooo.exe=/usr/bin/soffice
ooo.enabled=true
img.root=/usr
swf.exe=/usr/bin/pdf2swf

#
# Property to control whether schema updates are performed automatically.
# Updates must be enabled during upgrades as, apart from the static upgrade scripts,
# there are also auto-generated update scripts that will need to be executed.  After
# upgrading to a new version, this can be disabled.
#
db.schema.update=true

#
# MySQL connection
#
db.driver=org.gjt.mm.mysql.Driver
db.url=jdbc:mysql://localhost/alfresco?useUnicode=yes&characterEncoding=UTF-8

#
# Index Recovery Mode
#-------------
index.recovery.mode=FULL

#
# Alfresco Email Service and Email Server
#-------------

# Enable/Disable the inbound email service.  The service could be used by processes other than
# the Email Server (e.g. direct RMI access) so this flag is independent of the Email Service.
#-------------
email.inbound.enabled=false

# Email Server properties
#-------------
email.server.enabled=false
#email.server.port=25
#email.server.domain=alfresco.com
#email.inbound.unknownUser=anonymous

#
# The default authentication chain
# To configure external authentication subsystems see:
# http://wiki.alfresco.com/wiki/Alfresco_Authentication_Subsystems
#-------------
authentication.chain=alfrescoNtlm1:alfrescoNtlm

#
# URL Generation Parameters (The ${localname} token is replaced by the local server name)
#-------------
alfresco.context=alfresco
alfresco.host=${localname}
alfresco.port=8080
alfresco.protocol=http
#
share.context=share
share.host=${localname}
share.port=8080
share.protocol=http

imap.server.enabled=false
#imap.server.port=143
#imap.server.host=localhost

# Default value of alfresco.rmi.services.host is 0.0.0.0 which means 'listen on all adapters'.
# This allows connections to JMX both remotely and locally.
#
alfresco.rmi.services.host=0.0.0.0

#
# RMI service ports for the individual services.
# These seven services are available remotely.
#
# Assign individual ports for each service for best performance
# or run several services on the same port. You can even run everything on 50500 if needed.
#
# Select 0 to use a random unused port.
#
avm.rmi.service.port=50501
avmsync.rmi.service.port=50502
attribute.rmi.service.port=50503
authentication.rmi.service.port=50504
repo.rmi.service.port=50505
action.rmi.service.port=50506
wcm-deployment-receiver.rmi.service.port=50507
monitor.rmi.service.port=50508

# FTP server
ftp.enabled=false

# CIFS
cifs.enabled=true
cifs.Server.Name=rocksolid
cifs.domain=WORKGROUP
cifs.hostanounce=true

cifs.broadcast=0.0.0.0
cifs.tcpipSMB.port=1445
cifs.ipv6.enabled=false
cifs.netBIOSSMB.namePort=1137
cifs.netBIOSSMB.datagramPort=1138
cifs.netBIOSSMB.sessionPort=1139

Configuring Tomcat

1. Edit tomcat/conf/catalina.properties and modify the value for shared.loader.

shared.loader=${catalina.base}/shared/classes,${catalina.base}/shared/lib/*.jar

2. Create a file named server.sh under /opt/alfresco and make the file executable. This file will be used to start and shutdown the server.

#!/bin/sh
# Start or stop Tomcat server

# Set the following to where Tomcat is installed
ALF_HOME=/opt/alfresco
cd "$ALF_HOME"
APPSERVER="${ALF_HOME}/tomcat"

# When using Sun's jvm, set JAVA_HOME to /usr/lib/jvm/java-6-sun
export JAVA_HOME="/usr/lib/jvm/java-6-openjdk"
# Set any default JVM values
# This is the maximum I could go with a 32 bit CPU.
# You can set these numbers to much higher values on a 64 bit machine
export JAVA_OPTS='-server -Xms512m -Xmx1470m -XX:MaxPermSize=1G -XX:NewSize=256m'
export JAVA_OPTS="${JAVA_OPTS} -Dalfresco.home=${ALF_HOME} -Dcom.sun.management.jmxremote"
export JAVA_OPTS="${JAVA_OPTS} -Djava.rmi.server.hostname=localhost"
export JAVA_OPTS="${JAVA_OPTS} -Djava.awt.headless=true"

#
if [ "$1" = "start" ]; then
  "${APPSERVER}/bin/startup.sh"
elif [ "$1" = "stop" ]; then
  "${APPSERVER}/bin/shutdown.sh"
fi

chmod +x server.sh

3. Modify permissions to allow the tomcat user ownership of /opt/alfresco

chown -R tomcat:tomcat /opt/alfresco

4. Create an init script to start/stop tomcat when the server reboots. Create a file called alfresco.sh under /etc/init.d. Make this file executable and save it with the following contents.

#!/bin/sh
#
# chkconfig: 2345 80 30
# description: Alfresco Community Startup Script
# adapted by JD
#

RETVAL=0

start () {
    sudo -u tomcat soffice -headless -accept="socket,host=127.0.0.1,port=8100;urp;"
    sudo -u tomcat /opt/www/server.sh start "$2"
    iptables -I INPUT -p tcp --dport 80 -j ACCEPT
    iptables -I INPUT -p tcp --dport 8080 -j ACCEPT
    iptables -I INPUT -p tcp --dport 445 -j ACCEPT
    iptables -I INPUT -p tcp --dport 139 -j ACCEPT
    iptables -I INPUT -p udp --dport 137 -j ACCEPT
    iptables -I INPUT -p udp --dport 138 -j ACCEPT
    iptables -I INPUT -p tcp --dport 1445 -j ACCEPT
    iptables -I INPUT -p tcp --dport 1139 -j ACCEPT
    iptables -I INPUT -p udp --dport 1137 -j ACCEPT
    iptables -I INPUT -p udp --dport 1138 -j ACCEPT
    iptables -t nat -I PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080
    iptables -t nat -A PREROUTING -p tcp --dport 445 -j REDIRECT --to-ports 1445
    iptables -t nat -A PREROUTING -p tcp --dport 139 -j REDIRECT --to-ports 1139
    iptables -t nat -A PREROUTING -p udp --dport 137 -j REDIRECT --to-ports 1137
    iptables -t nat -A PREROUTING -p udp --dport 138 -j REDIRECT --to-ports 1138
    iptables-save
    RETVAL=$?
}

stop () {
    sudo -u tomcat /opt/alfresco/server.sh stop "$2"
    RETVAL=$?
}
case "$1" in
    start)
        start "$@"
        ;;
    stop)
        stop "$@"
        ;;
    restart)
        stop "$@"
        start "$@"
        ;;
    *)
        sudo -u tomcat /opt/alfresco/server.sh "$@"
        RETVAL=$?
esac
exit $RETVAL

5. Finally su as tomcat and start the server

su tomcat
cd ~
./server.sh start

6. You may also want to setup so iptable rules to allow access on port 80.

sudo iptables -t nat -I PREROUTING -p tcp --dport 80 -j REDIRECT --to-port 8080
sudo iptables-save

All the operations available in the API are segregated into one of two sections, the mailbox (user) side and the admin side. The problem was that the Zimbra client only had implementations for the user set of APIs, and I needed to interface with the admin side of things.

So I went back to Google, and this time stumbled upon this great piece of work done by the folks running this website here. These folks must have been in the same boat as me a while back, and they actually managed to roll out their own WSDL for the admin api. Awesome! I finally had something concrete to work with. I quickly downloaded the wsdl and pointed CXF’s wsdl2java at it. Alas, it wasn’t that easy. The folks who wrote this seem to be Rubyists, and even though they claim it works with their Ruby client builder script, none of the Java implementations agreed with them.

So I fired up Eclipse, and had to apply a bunch of fixes, most of them related to namespaces and element ordering, before I had a file that validated perfectly. I also added a couple more operations that I thought I would need while I was at it. Note that all available operations still haven’t been implemented. If you do improve on it, please report back so I can update the file and others could benefit as well. This file has been tested to work with ZCS 6 and 7.

So there you have it folks, without any further ado, I present the elusive Java compliant WSDL for Zimbra’s SOAP API.

You can download the WSDL file here.

Last time I checked Java 6′s wsimport and wsgen were still complaining about something in the file, so I also zipped up the proxy client stubs generated by CXF 2.5, which can be downloaded here.

Android Market's Exponential Growth

If your current device doesn’t support an app you would like to purchase, but you would like to get it anyway, say because you plan to upgrade in the near future, you could still get the app from the online store at this link: https://market.android.com/details?feature=banne­r&id=apps_timed_promotion

Here is the list of fire sale apps for 6/12/2011:

1. SoundHound
2. Asphalt 6: Adrenaline HD
3. Minecraft – Pocket Edition (yep!)
4. SwiftKey X Keyboard
5. Endomondo Sports Tracker PRO
6. Great Little War Game
7. SketchBook Mobile
8. Fieldrunners HD
9. Color & Draw for kids: phone ed
10. Paper Camera

[Show as slideshow]

Also check out how this baby reboots in under 20 seconds:

So who is hoping to find one of these under the Christmas tree? Stay tuned for our next post where we rip it apart and apply some quality thermal paste to keep it running cool..

Prerequisites:

• I use the Eclipse IDE but any IDE of your choice should suffice as long as you know your way around.
• Download Spring 3 from here and download CXF 2.5 from here.
• Create a working install of Tomcat in your IDE or standalone.
• Intermediate working knowledge of Java is assumed.

Project Setup:

• Create a new Dynamic Web project in Eclipse.
• Add the following JARs from your Spring and CXF downloads into the lib folder:

spring-asm-3.0.6.RELEASE.jar
spring-beans-3.0.6.RELEASE.jar
spring-context-3.0.6.RELEASE.jar
spring-context-support-3.0.6.RELEASE.jar
spring-core-3.0.6.RELEASE.jar
spring-web-3.0.6.RELEASE.jar
commons-logging-1.1.1.jar
wsdl4j-1.6.2.jar
wss4j-1.6.3.jar
xml-resolver-1.2.jar
xmlschema-core-2.0.1.jar
xmlsec-1.4.5.jar
jaxrpc.jar
saaj.jar
saaj-api-1.3.jar
cxf-2.5.0.jar
bcprov-jdk16-146.jar
serializer-2.7.1.jar
xalan-2.7.1.jar
dom4j-1.6.1.jar

When creating web services, two approaches are possible: Contract-first and Contract-last. In contract-first, you define the service contract in WSDL (Web Service Definition Language) first, and then implement your service to the contract. This approach is better suited for newer projects. However, since the project I was working on already had the Java code written, the contract-last approach was a better choice, which is also what I will be explaining here.

The Server:

First up is our Java class, GreetingService. The service defines a single method, greet. It accepts a username and returns a greeting to the caller as a String (I know, I apologize for my lack of imagination).

package test;

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebResult;
import javax.jws.WebService;

/**
 *
 * @author JD
 *
 */
@WebService(name = "GreetingService", targetNamespace = "http://test/")
public class GreetingService {

	@WebMethod
	public @WebResult(name = "greeting")
	String greet(@WebParam(name = "user") String user) {
		return "Hi there, " + user + "!";
	}

}

As you can see, this is a POJO with some annotations sprinkled in. The only required annotation would be @WebService.
Everything else simply assists in generating cleaner WSDL. For example, without the @WebParam annotation, the names of method arguments would be replaced with arg0, etc, making life a little difficult for a client.

Next up is our Spring configuration file, which will contain instructions for CXF to expose our service as a web service. Save this as a file named cxfContext.xml and put it in the WEB-INF directory.

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"
	xmlns:soap="http://cxf.apache.org/bindings/soap" xmlns:cxf="http://cxf.apache.org/core"
	xsi:schemaLocation="http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd
         http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

	<!-- Interceptors -->
	<bean id="logIn" class="org.apache.cxf.interceptor.LoggingInInterceptor" />
	<bean id="logOut" class="org.apache.cxf.interceptor.LoggingOutInterceptor" />
	<!-- SAAJ Interceptor needs to be explicitly declared only in CXF 2.0.x -->
	<bean id="saajIn" class="org.apache.cxf.binding.soap.saaj.SAAJInInterceptor" />
	<bean id="wss4jIn" class="org.apache.cxf.ws.security.wss4j.WSS4JInInterceptor">
		<constructor-arg>
			<map>
				<entry key="action" value="UsernameToken Timestamp" />
				<entry key="passwordType" value="PasswordText" />
			</map>
		</constructor-arg>
	</bean>

	<!-- The CXF Bus -->
	<cxf:bus>
		<cxf:features>
			<cxf:logging />
		</cxf:features>

		<cxf:properties>
			<entry key="ws-security.validate.token" value="false" />
			<entry key="ws-security.ut.no-callbacks" value="true" />
			<entry key="ws-security.ut.validator" value="test.UTValidator" />
		</cxf:properties>

		<cxf:inInterceptors>
			<ref bean="logIn" />
		</cxf:inInterceptors>
		<cxf:outInterceptors>
			<ref bean="logOut" />
		</cxf:outInterceptors>
		<cxf:inFaultInterceptors>
			<ref bean="logIn" />
		</cxf:inFaultInterceptors>
		<cxf:outFaultInterceptors>
			<ref bean="logOut" />
		</cxf:outFaultInterceptors>
	</cxf:bus>

	<!-- End points -->
	<jaxws:endpoint id="greeter" serviceName="GreetingService"
		implementor="test.GreetingService" address="/">
		<!-- wsdlLocation="WEB-INF/wsdl/library.wsdl" This will be generated automcatically
			when not specified -->
		<jaxws:inInterceptors>
			<ref bean="saajIn" />
			<ref bean="wss4jIn" />
		</jaxws:inInterceptors>
	</jaxws:endpoint>

</beans>

Lines 10 – 21 define the required interceptors for implementing WS-Security via the WSS4JInInterceptor and for logging. Line 50 defines the end point. Details on the attributes can be found here Notice how everything can be configured in a very Spring-like way thanks to the custom namespaces. Also note how common properties for all endpoints, such as logging interceptors and properties can be defined in the bus and don’t have to be repeated for each endpoint.

The

<cxf:properties>

element specifies a set of properties for the bus. Here we are saying we will be handling authentication ourselves, via ws-security.ut.validator key in the UTValidator class, and that no password callback handlers are required by setting ws-security.validate.token to true. If you use a different password scheme other than PasswordText, like PasswordDigest, you would have to set the plain text password from the digest in the password callback class. Note that the properties can also be overridden per endpoint using the

<jaxws:properties>

child element of

<jaxws:endpoint>

.

The authentication method we have chosen here is UserNameToken, which validates a username and password provided by the client, and Timestamp. While this is sufficient for development and testing, this needs to be beefed up by either encrypting the transport(https) or by using security tokens in production.

The UTValidator is simply a subclass of CXF’s UsernameTokenValdator, and overrides the verifyPlaintextPassword method to provide custom authentication. In a real world application, an authentication service such as one that validates the credentials provided against a directory such as LDAP can be used. If validation fails, this method must throw a WSSecurityException with the error code (the first constructor argument) set as WSSecurityException.FAILURE.

package test;

import org.apache.ws.security.WSSecurityException;
import org.apache.ws.security.handler.RequestData;
import org.apache.ws.security.message.token.UsernameToken;
import org.apache.ws.security.validate.UsernameTokenValidator;

public class UTValidator extends UsernameTokenValidator {

	@Override
	protected void verifyPlaintextPassword(UsernameToken usernameToken,
			RequestData data) throws WSSecurityException {
		// usernameToken.getName(), usernameToken.getPassword(), authenticate against
		// directory store or database. Do nothing if successful. Throw
		// throw new WSSecurityException(WSSecurityException.FAILED_AUTHENTICATION); on failure.
	}

}

The final configuration on the server side is the web.xml file, which will initialize the Spring context, pass in our own Spring context as well as a couple from CXF (which are in its own jar files) to the ContextLoaderListener, and finally setup the CXF servlet which will handle all incoming requests for our service.

<?xml version="1.0" encoding="UTF-8"?>
<web-app xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xmlns="http://java.sun.com/xml/ns/javaee" xmlns:web="http://java.sun.com/xml/ns/javaee/web-app_2_5.xsd"
	xsi:schemaLocation="http://java.sun.com/xml/ns/javaee http://java.sun.com/xml/ns/javaee/web-app_3_0.xsd"
	version="3.0">
	<display-name>jax-ws-spring-test</display-name>

	<context-param>
		<!-- Spring contexts -->
		<param-name>contextConfigLocation</param-name>
		<param-value>
			classpath:META-INF/cxf/cxf.xml
      		        classpath:META-INF/cxf/cxf-servlet.xml
      		        /WEB-INF/cxfContext.xml
		</param-value>
	</context-param>

	<!-- Listener which bootstraps the Spring config files -->
	<listener>
		<listener-class>org.springframework.web.context.ContextLoaderListener</listener-class>
	</listener>

	<!-- The CXF Servlet -->
	<servlet>
		<servlet-name>CXFServlet</servlet-name>
		<servlet-class>org.apache.cxf.transport.servlet.CXFServlet</servlet-class>
		<load-on-startup>1</load-on-startup>
	</servlet>
	<servlet-mapping>
		<servlet-name>CXFServlet</servlet-name>
		<url-pattern>/*</url-pattern>
	</servlet-mapping>

</web-app>

And thats it! Now if you were to fire up your server, package the project as a war and deploy it on the server, your web service should be up and running. You can verify this by navigation to http://localhost:8080//greetingservice?wsdl on your browser to view the WSDL that is automatically generated by CXF based on the JAX-WS annotations defined in your service class.

The Client:

To test the service, create a second Dynamic web project, and use the same build path as the previous project.

What we will need to create a working client to test the service:

1. The service interface which will be proxied by Spring.
2. A spring context configuration file to define the jaxws client proxy for the service.
3. A password callback handler which will supply the authentication token when invoking the service
4. A simple spring bean to test the proxy and invoke the greet operation.

The service interface can be generated from the WSDL either by CXF’s wsdl2java tool or Java 6′s wsimport utility. The source below was generated by wsimport when invoked as follows:

wsimport -d . -keep http://localhost:8080/jax-ws-spring-test/greetingservice?wsdl

package test;

import javax.jws.WebMethod;
import javax.jws.WebParam;
import javax.jws.WebResult;
import javax.jws.WebService;
import javax.xml.ws.RequestWrapper;
import javax.xml.ws.ResponseWrapper;

/**
 * This class was generated by the JAX-WS RI.
 * JAX-WS RI 2.1.6 in JDK 6
 * Generated source version: 2.1
 *
 */
@WebService(name = "GreetingService", targetNamespace = "http://test/")
public interface GreetingService {

    /**
     *
     * @param user
     * @return
     *     returns java.lang.String
     */
    @WebMethod
    @WebResult(name = "greeting", targetNamespace = "")
    @RequestWrapper(localName = "greet", targetNamespace = "http://test/", className = "test.Greet")
    @ResponseWrapper(localName = "greetResponse", targetNamespace = "http://test/", className = "test.GreetResponse")
    public String greet(
        @WebParam(name = "user", targetNamespace = "")
        String user);

}

The client Spring context contains the client proxy definition and is shown next:

<?xml version="1.0" encoding="UTF-8"?>
<beans xmlns="http://www.springframework.org/schema/beans"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance" xmlns:jaxws="http://cxf.apache.org/jaxws"
	xmlns:soap="http://cxf.apache.org/bindings/soap" xmlns:cxf="http://cxf.apache.org/core"
	xsi:schemaLocation="
         http://www.springframework.org/schema/beans http://www.springframework.org/schema/beans/spring-beans-3.0.xsd
         http://cxf.apache.org/core http://cxf.apache.org/schemas/core.xsd
         http://cxf.apache.org/jaxws http://cxf.apache.org/schemas/jaxws.xsd">

	<!-- Interceptors -->
	<bean id="logIn" class="org.apache.cxf.interceptor.LoggingInInterceptor" />
	<bean id="logOut" class="org.apache.cxf.interceptor.LoggingOutInterceptor" />
	<bean id="saajOut" class="org.apache.cxf.binding.soap.saaj.SAAJOutInterceptor" />
	<bean id="wss4jOut" class="org.apache.cxf.ws.security.wss4j.WSS4JOutInterceptor">
		<constructor-arg>
			<map>
				<entry key="action" value="UsernameToken Timestamp" />
				<entry key="user" value="ws-client" />
				<entry key="passwordType" value="PasswordText" />
				<entry key="passwordCallbackClass" value="test.PWCallbackHandler" />
			</map>
		</constructor-arg>
	</bean>

	<!-- The CXF Bus -->
	<cxf:bus>
		<cxf:features>
			<cxf:logging />
		</cxf:features>

		<cxf:inInterceptors>
			<ref bean="logIn" />
		</cxf:inInterceptors>
		<cxf:outInterceptors>
			<ref bean="logOut" />
		</cxf:outInterceptors>
		<cxf:inFaultInterceptors>
			<ref bean="logIn" />
		</cxf:inFaultInterceptors>
		<cxf:outFaultInterceptors>
			<ref bean="logOut" />
		</cxf:outFaultInterceptors>
	</cxf:bus>

	<!-- Client Proxies -->
	<jaxws:client
		name="{http://www.springframework.org/schema/beans}GreetingService"
		address="http://localhost:8080/<your_project_name>/greetingservice?wsdl"
		serviceClass="test.GreetingService"
		wsdlLocation="http://localhost:8080/<your_project_name>/greetingservice?wsdl"
		serviceName="GreetingService" endpointName="GreetingServicePort">

		<jaxws:outInterceptors>
			<ref bean="saajOut" />
			<ref bean="wss4jOut" />
		</jaxws:outInterceptors>
	</jaxws:client>

</beans>

Make sure you replace with the name of your project in the snippet above. Worthy of note is how the InInterceptors on the Server side are mirrored by OutInterceptors on the client side.

The PWCallbackHandler is an implementation of a CallbackHandler, and is responsible for providing the password to be encoded in the soap request header. Note that by calling the setIdentifier method, a different username can also be set. This allows for specifying different credentials per request. In a real world client, these values would probably come from a Session variable or from a SessionContextHolder.

package test;

import java.io.IOException;

import javax.security.auth.callback.Callback;
import javax.security.auth.callback.CallbackHandler;
import javax.security.auth.callback.UnsupportedCallbackException;

import org.apache.ws.security.WSPasswordCallback;

public class PWCallbackHandler implements CallbackHandler {

	@Override
	public void handle(Callback[] callbacks) throws IOException,
			UnsupportedCallbackException {
		WSPasswordCallback c = (WSPasswordCallback) callbacks[0];
		// in a real world client these would probably come from SecurityContextHolder
		// or some session object
		c.setIdentifier("jd");
		c.setPassword("secret");
	}

}

The Web.xml will contain the same content as the one from the server project.

Finally, we create a spring bean which will have the proxy injected, and will then call the greet method on the service:

package test;

import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.beans.factory.annotation.Qualifier;
import org.springframework.scheduling.annotation.Scheduled;
import org.springframework.stereotype.Service;

@Service
@Qualifier("greetingServiceClient")
public class GreetingServiceClient {

	@Autowired
	private GreetingService gs;

	@Scheduled(cron="0 m h * * ?")
	public void testService() {
		try {
			System.out.println(gs.greet("Jeshurun"));;
		} catch (Exception e) {
			e.printStackTrace();
		}
	}

}

Adjust the cron task by replacing the h with the hour of your current time, and m with two minutes plus your current time’s minute.

Deploying the project on the server, and waiting for the cron to kick in should print “Hi there, Jeshurun!”. You can even deploy the client on a separate machine to make it even more awesome.

To sum things up, lets see how CXF stacks up against other popular stacks:

1. Easy Spring integration by using custom namespaces.
2. Modular, lets you pick and choose eactly the features you need.
3. Setting up security is relatively easy.
4. Uses standard JAX-WS annotations, so your services can be ported easily to a different stack if needed.
5. Way better documentation compared to Metro, although not on par with Spring (but definitely getting there).
6. Performance is comparable to Metro and is faster than Axis.
7. Can be integrated right into your project and doesn’t force you to deploy each service as a separate war.

Some of the cons for me, which are making me think twice about using it:

1. There seems to be no easy way of defining the jaxws:endpoint or jaxws:client as an abstract bean and create beans which inherit common properties. Because of this, properties such as interceptors have to be redefined for every endpoint or client definition, even when they are exactly the same. This could make your configuration xml lengthy and error-prone in larger projects.
2. Can’t be configured to automagically detect POJOs annotated with @WebService and publish them, like Spring’s SimpleJaxWsServiceExporter.

Supposedly the problem occurs when the equals and compareTo method in the type contained in the Collections aren’t consistent with each other, and the sizes of the collections compared aren’t equal. Look at the following link for an example
JDK Bug 6394757 : (coll) AbstractSet.removeAll is surprisingly dependent on relative collection sizes.

Anyways, the rule of thumb for me from now is if need be to implement a SortedSet Set that will have either removeAll or retainAll called on, use an HashSet instead, and later use Collections.sort

Set<MyType> mySet = new HashSet<MyType>();
// add some elements, do some operations
mySet.removeAll(anotherCollection);
List<MyType> myList = new ArrayList<MyType>(mySet);
Collections.sort(myList);

After much thought I have decided to sell my Xperia X10. I have only had the phone for a few months, but as I develop apps for Android, I need a phone with the latest Android version.

I’ve attached some pictures below, and as you can see from them, the phone is in excellent shape and has no scratches on the body. I’ve always used a screen guard so the screen has no scratches as well, and I also have a new spare screen guard which I will give with the phone.

The phone comes with a 16GB microSD memory card. I’ve never used the headphones that came with it. My asking price is $315 + shipping. Click on the images to view them in full resolution.

Check out the pictures below:

Other Specifications:
2G Network: GSM 850 / 900 / 1800 / 1900
3G HSDPA: 850 / 1900 / 2100 / 800 – X10a for Americas
Display: 480 x 854 pixels, 4.0 inches TFT capacitive touchscreen
Memory: 1 GB storage, 384 MB RAM
Card slot: microSD, up to 32GB, 16GB card included
Data: 3G, EDGE, GPRS, HSDPA, Wi-Fi, Bluetooth, USB 2.0
Camera: 8 MP, 3264×2448 pixels, autofocus, LED flash
Operating System: Android OS 2.1

Full Specifications

What is interesting is that I started receiving these emails soon after of my credit card was used fraudulently online to purchase merchandise from stores in France. Thankfully, my bank refunded the purchases and issued me a new card.

Below is an screenshot of a phishing email masquerading to be from TD Canada Bank:

While phishing emails like these can be very much like the real thing, a little diligence can go a long way to help spot these as fake right away. Here are a few pointers from the image above that might help spot a fake email:

1. The email has a generic greeting. In this case its “Dear TD Canada Trust Valued Customer”. If the email were legitimately from your bank, they would know who you are, and would address the email to your name.
2. The link in the email is fraudulent. Although the link text seems to indicate that it leads to the actual TD site, it doesn’t. How do you identify this? Its simple. Just hover your mouse over the link and you would notice that it actually points to a completely different domain. And the link is not secure either (uses http:// instead of https://). The actual link is usually visible on your browser or email client’s status bar. Keep in mind though that the website this link leads to will be almost identical to the real thing.
   
3. There is almost always a sense of urgency in the email.
4. The emails are usually riddled with typos / grammatical errors.

Here is a similar email for RBC. Unfortunately I deleted mine so this image is courtesy of Google.

And this is the scam website it links to:

A few pointers that might help keep you from getting scammed:

1. Buy a reputed anti-virus product (Kaspersky is my personal favourite) if you don’t have one already and keep it updated all the time, if you are running Windows.
2. Don’t ever open unsolicited email from senders you don’t know / trust. The holiday season is prime time for amazing deals / offers that will entice you to drop your guard. Remember, the old adage still holds, “if its too good to be true, it probably isn’t”.
3. Switch to Linux! Well, at least when you are logging into your bank’s website / making purchases with your credit card. Most, if not all of these phishing emails and almost all viruses out there are targeted towards Windows users. Switching to Linux saves you a lot of pain as these Windows executable viruses have no impact on a Linux machine. Plus you can get away with not using an anti-virus. And its free! If you need Windows for a proprietary program such as Microsoft Office, you can always run Windows in a virtual machine such as VMware player.
4. If you think your financial information might have been compromised, contact your bank immediately.

If you have already fallen for one of these scams, don’t feel embarrassed! An eCard that was spoofed as being sent from the Whitehouse conned several employees of the US government this holiday season and stole several gigabytes of sensitive government data. This only shows that sometimes, even the experts can fall for these scams, although it beats me why the US government hasn’t heard of a simple thing called SPF yet!

Stay safe online this new year!

I’m not sure why this happens (and I haven’t had time to dig into the source, perhaps I will file a bug report when time permits), but to get around this the following steps worked:

1. Make sure you have remove the install directory.
2. Login to the front end.
3. Click on the “members” link on the top right and then click on the site admin’s username.
4. Right beside the username you should see a link which says [ Administrate user ]. Click on the link.
5. Re-authenticate yourself.
6. Click on proceed to acp.
7. You should now be looking at the admin panel.

Did this work for you? Do let me know in the comments below!