Emil Genov

Forwarding AFTER filtering in Gmail

2011-01-10T00:02:00.001+02:00

The problem: I want to forward all of my mail to other email account (for example my cell phone Email2SMS address). I want to be able to filter some of the messages using gmail filters, and I do not want to forward those filtered messages.

Problem is that gmail, first forwards messages and after that applies filters, just the opposite of what I need.

Solution: Well it's a little convoluted but it works. What I needed, was a forwarding filter that will will forward mail coming from any address, except those from a specific list.

As it took me some time to figure out the right syntax (try and error), I decided to write it down for someone who will need it too.

You can use two filters, first filters unwanted mail, second forwards wanted ones:

1) Matches: from:(not_wanted1@mail.com | not_wanted2@mail.com | not_wanted3@mail.com)
Do this: Skip Inbox, Mark as read, Delete it

2) Matches: from:(-not_wanted1@mail.com,-not_wanted1@mail.com,-not_wanted1@mail.com)
Do this: Forward to you-address@sms.mtel.net

So syntax for filter that matched mail send from any address, except those from a specific list is like this: put a minus in front of address and use comma as list separator. Hope this will help someone, write comment if this got the things done.

IM History Converter Application

2010-12-28T11:34:00.001+02:00

When transitioning to a new job, I got faced with problem of what to do with chat histories I have amassed in my last job. We have used pidgin for communication with jabber servers, and I have also used pidgin for my facebook chat, so all my work related history along with my private history was there.

I really wanted some central storage for this information. After pounding on solutions, I realized that it was there, already existing, waiting for me. Google stores it chat logs inside gmail. Wonderful idea, chats there are safe, easy accessible and what is most important completely search-able.

So I looked through Interwebs, for existing solution, but could not find one. Then I looked at format of pidgin history, and it was simple enough. Text file with each chat, and index files in xml.

I decided I will write this translator myself. Started with defining core objects, such as Contacts, IM Account and chat history logs. Also I decided to make it extensible for other input formats and also for other storage backends. Decision which plugin to use is taken in runtime based on configuration file or user entered parameters.

Gmail storage plugin uses IMAP to directly put chat histories as gmail messages with their original dates.

So If anybody needs it, source code is available. On project page there are descriptions how to run the program. Also you can see how to make and run additional plugins to import chat from other systems. If anybody finds application useful, or have added additional plugins, please write a comment here or contact me on project page. Gracias

Tagging maven build with SVN version, and using this version inside application

2010-10-29T11:07:00.007+03:00

To do this, you need to take following steps:

Add build-number plugin to your project main POM

...
      <build>
              ...
              <plugins>
                  ...
                  <plugin>
                      <groupId>org.codehaus.mojo</groupId>
                      <artifactId>buildnumber-maven-plugin</artifactId>
                      <version>1.0-beta-3</version>
                      <executions>
                          <execution>
                              <phase>validate</phase>
                              <goals>
                                  <goal>create</goal>
                              </goals>
                          </execution>
                      </executions>
                      <configuration>
                          <doCheck>false</doCheck>
                          <doUpdate>false</doUpdate>
                      </configuration>
                  </plugin>
                  <plugin>
                      <groupId>org.apache.maven.plugins</groupId>
                      <artifactId>maven-release-plugin</artifactId>
                      <version>2.0</version>
                  </plugin>
                  ...
              </plugins>
          ...
      </build>
      ...

Change your current jar plugin (or add one if such is missing):

...
                   <plugin>
                      <artifactId>maven-assembly-plugin</artifactId>
                      <version>2.2-beta-2</version>
                      <configuration>
                          <archive>
                              ...
                              <manifest>
                                  ...    
                                  <addDefaultImplementationEntries>true</addDefaultImplementationEntries>
                                  ...
                              </manifest>
                              <manifestEntries>
                                  <Implementation-Version>${pom.version} (SVN version:${buildNumber})</Implementation-Version>
                                  <SVN-Version>${buildNumber}</SVN-Version>
                              </manifestEntries>
                              ...
                          </archive>
                          ...
                      </configuration>
                      <executions>
                          <execution>
                              <goals>
                                  <goal>single</goal>
                              </goals>
                              <phase>package</phase>
                          </execution>
                      </executions>
                  </plugin>
                  ...

To get version inside your code use:

public String getVersion() {
    return <some class inside jar, that is created by maven>.class.getPackage().getImplementationVersion();
}

To get version from running program (server) using only command line:
1. Create an JMX interface, with method getVersion() exposed, expose this interface in JMX on host XXX.YYY.ZZZ on port PPP
2. Download cmdline-jmxclient utility jar from it's site
3. Issue this:
```
java -jar cmdline-jmxclient-0.10.3.jar a:a  XXX.YYY.ZZZ:PPP <name of your JMX bean> Version
```

Team time

2009-11-06T19:52:00.001+02:00

The river was not really nasty this time, but it was a quite an adventure. After safely got on land, we celebrated this with a big lunch :)

Robots at work

2009-07-09T19:59:00.002+03:00

This might be the future of MFC technology we work now with. Worth a try.

You are being monitored

2009-04-14T09:50:00.005+03:00

Oldie, but Goldie ...

2007-11-26T11:43:00.000+02:00

Language talks :)

2007-10-24T21:06:00.000+03:00

The Last Language War / Language Trolling Post You'll Ever Need To Read (Hopefully) - I never have so much laugh since reading How to shoot yourself in the leg... which by the way seems a lot of outdated.

Classes vs. Ids

2007-10-14T20:24:00.000+03:00

Today, while trying to fix broken rendering of aero-bg.com on Firefox, I delved deeper in CSS of site. Interesting though the css, almost randomly used in some cases ids and in other classes. I almost forgot, what the difference between those selectors are, so I refreshed myself, reading this incredible peace of info. To make things short, this is what are important differences:

1. Repeated use within a document

Classes can be used as many times as needed within a document.
IDs can only be applied once within a document.

So, if you need to use the same specific selector more than once, classes are a better choice.

2. Combining class selectors

You can use multiple classes to style an HTML element but you can only use one ID when styling an HTML element. This means that class selectors have a wider range of applications.

3. IDs have higher specificity than classes

There may be times when a declaration conflicts with another declaration. These conflicts are resolved using the Cascade rules. In simple terms, if a class selector and ID selector were to be in conflict, the ID selector would be chosen.

Also following article has it's controversal way to detach scripts for handling DOM events, from presentation.

Exploits For A Mom

2007-10-14T10:44:00.000+03:00

Recently SQL injection is a next big thing. So let's see an up side of it :)

So, do You SANITIZE?

Top Ten Software Architecture Mistakes

2007-10-14T01:33:00.001+03:00

I have stumble upon some of this mistakes, and some of them could be avoided just by better planning. So this are good things for me to know in my future career.

Scrum stickies

2007-10-09T10:21:00.000+03:00

This is our interpretation of sticky notes task implementation. Direct on office windows. Cute :)

Industria is in top 50 key innovators

2007-03-09T09:42:00.001+02:00

It’s not every day that Industria(the company I work for) is mentioned along with household names such as Adidas, BSkyB, BMW, Rolls Royce, Royal Bank of Scotland, Skype, Vodafone and Virgin Atlantic.

However, that’s just where we are in the March edition of global monthly CNBC European Business, which has named us as one of this year’s 50 key innovators among European companies.

Described by the panel of judges as being “potentially one of the biggest contributors to a European future of digital convergence and IPTV“, Industria joins some of the world’s best-known companies on the list, which was compiled by a variety of experts on each of the ten sectors looked at.

According to the magazine, “Industria’s ambition can be seen in its office locations: the UK, Ireland, Bulgaria and China. This Icelandic tiger specialises in software for bridging mobile and fixed-line networks, and its IPTV services platform subsidiary Zignal is creating a real stir.”

How to implement Java Web Services with XFire

2007-02-24T17:00:00.001+02:00

Exporting WebService with XFire

Using XFire proprietary configuration file - This method is simple and has a good interoperability with .Net applications. Problem is that everything is hardcoded, and can not be used Spring for wiring up the components. Should be used if other method does not give you good results (which was the case with XFire prior of version 1.2.4)

Using XFire with Spring - this is 'semi-automatic' way. It still gives us power of entirely Spring configured WS, without problems that we have with fully automated JSR181 annotation approach

Using XFire with Spring and JSR181 Annotations - very powerfull way. Has advantage, that is independent of XFire. Compatible with JAX-WS java standard for WS. Integrates smootly with Spring. No manual operations, completely automatic. Beautiful

Creating WebService Implementation

Creating New WebService From Scratch - here we make interface and implementation, annotate them and deploy them to XFire
Creating WebService from WSDL - describes usage of wsgen XFire tool, for automatic generation of java classes from WSDL

Specifics

Additional Reading

XFire + Spring quick start guide
Client and Server Stub Generation from WSDL
XFire download
Remoting and web services using Spring
Basic Spring Web services with XFire and JSR 181
Namespaces in XML 1.0
JSR 181 Spec
XFire client building
Installation of Eclipse XFire Plugin - Add the following URL http://dist.codehaus.org/xfire/update/ to Help -> Software Updates -> Find and Install

Inheritance and XFire

2007-02-24T16:48:00.001+02:00

Sometimes we need to use polymorphism and it is already supported by WSDL, so here is a little tricky explanation how to do this using XFire.

For example we have a basic type Party and two classes that extend it: Individual and Organisation. We define method in interface, that accepts Party, but we need to be possible to use Individual and Organisation objects with this method too. This is solved by adding following annotations to implementation of service:

@WebService(serviceName = "PartyProcessImpl", endpointInterface = "com.industria.PartyProcess")
@ServiceProperties(properties={
  @ServiceProperty(key=AegisBindingProvider.WRITE_XSI_TYPE_KEY, value="true"),
  @ServiceProperty(key=AegisBindingProvider.OVERRIDE_TYPES_KEY, list={"com.party.Individual","com.party.Organisation"})
  })
public class PartyProcessImpl implements PartyProcess {

basically in second @ServiceProperty annotations, we give a list of classes, that need to be check if override some of basic types that are used into WS interface.

Creating WS from an WSDL file

2007-02-24T16:46:00.001+02:00

If you must use preexisting WSDL file, You can use tool in XFire to generate you an Java implementation of it. It's like issuing this ant script:

<target name="wsdl" depends="createDirs">
  <path id="xfire-classpath">
   <fileset dir="${libDir}/xfire">
    <include name="*.jar" />
   </fileset>
  </path>

  <taskdef name="wsgen" classname="org.codehaus.xfire.gen.WsGenTask"
        classpathref="xfire-classpath"/>


  <wsgen outputDirectory="${basedir}/target/generated-source"
     wsdl="${basedir}/src/com/industria/tea/soap/TaskEscalation.wsdl" package="com.industria.tea.soap" overwrite="true"/>
 </target>

where $libDir/xfire contains all jars taken from XFire distribution to avoid version mismatch

where:

wsdl - location of wsdl file ( can be any valid url )
outputDirectory - output directory for generated classes
package - package where client code will be placed
overwrite - allows to overwrite previously generated classes ( without this option, generator will refuse to generate classes if such already exists )

Creating WS from scratch

2007-02-24T16:37:00.001+02:00

In this case we just create our Java interface and implementation and annotate them with JSR-181 annotations. After this WSDL can be retrieved by going to http://<server_name>:8080/<war_name>/services/<serviceName>?wsdl

Here is a step-by-step manual for doing this:

First start as normal POJO object that implements functionality you need to expose as WS:

package com.industria.order.validation;

public class AllocatedResourceVerificationImpl implements AllocatedResourceVerification{

	public void validate(String resourceId, String resourceName, String resourceValue) throws ValidationException{
		log.info("Invoked: "+resourceName);
	}
}

Extract all functions needed into interface, this helps separate implementation from definition, and is always a good thing (TM) to program to interfaces, so we have

package com.industria.order.validation;

public interface AllocatedResourceVerification {

    public void validate(String resourceId,String resourceName,String resourceValue) throws ValidationException;
}

package com.industria.order.validation;

public class AllocatedResourceVerificationImpl implements AllocatedResourceVerification{

	public void validate(String resourceId, String resourceName, String resourceValue) throws ValidationException{
		log.info("Invoked: "+resourceName);
	}
}

Anotate interface - this is needed only if we gonna use XFire automatic handling of JSR181 annotated classes (see Exporting WebService - Using XFire with Spring and JSR181 Annotations)

Anotate interface with a @WebService anotation, the only nessesary parameter is targetNamespace,
Anotate each method you want to expose with @WebMethod anotation

If you want parameter of operations to have a names in WSDL, anotate them with @WebParam

package com.industria.order.validation;

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

@WebService(targetNamespace = "http://www.industria.com/contracts/Addons/Salesforce/OrderManager")
public interface AllocatedResourceVerification {


    @WebMethod
    public void validate(@WebParam(name = "resourceId")String resourceId,
    		@WebParam(name = "resourceName")String resourceName,
    		@WebParam(name = "resourceValue")String resourceValue) throws ValidationException;
}

Anotate implementaion

You must put @WebService anotation

giving serviceName - this is name with which this service will be exported by XFire

and endpointInterface - this is pointer to the interface we implement

package com.industria.order.validation;

import javax.jws.WebService;

import org.apache.commons.logging.Log;
import org.apache.commons.logging.LogFactory;

@WebService(serviceName = "AllocatedResourceVerification",
			endpointInterface = "com.industria.order.validation.AllocatedResourceVerification")
public class AllocatedResourceVerificationImpl implements AllocatedResourceVerification{

	protected static final Log log = LogFactory.getLog(AllocatedResourceVerificationImpl.class);

	public void validate(String resourceId, String resourceName, String resourceValue) throws ValidationException{
		log.info("Invoked: "+resourceName);
	}
}

Exporting WebService - Using XFire with Spring

2007-02-24T16:27:00.001+02:00

Project structure and contents

Template project is attached to this page, feel free to use it and update it.

As all Java WS are deployed as WAR file, at some point your project must create one. Here some guidelines how to have a one that works:

In WEB-INF/web.xml file, XFireSpring servlet is instantiated. For it's parameter contextConfigLocation, we specify spring config file that will be discussed in next step. Mappings are usual one, this file is same as the one used for working of Spring with XFire:

<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
	version="2.4">

	<display-name>XFire</display-name>

	<context-param>
		<param-name>contextConfigLocation</param-name>                   (1)
		<param-value>classpath:xfire-servlet.xml</param-value>
	</context-param>

	<servlet>
		<servlet-name>XFireServlet</servlet-name>                        (2)
		<display-name>XFire Servlet</display-name>
		<servlet-class>
			org.codehaus.xfire.spring.XFireSpringServlet
		</servlet-class>
	</servlet>

	<servlet-mapping>
		<servlet-name>XFireServlet</servlet-name>                        (3)
		<url-pattern>/servlet/XFireServlet/*</url-pattern>
	</servlet-mapping>

	<servlet-mapping>
		<servlet-name>XFireServlet</servlet-name>
		<url-pattern>/services/*</url-pattern>
	</servlet-mapping>

	<listener>
		<listener-class>
			org.springframework.web.context.ContextLoaderListener    (4)
		</listener-class>
	</listener>

</web-app>

(1) Defines that file xfire-servlet.xml, will be automatically available to Spring. Will define this in next section.
(2) Define XFireServlet
(3) Map it to XXX/services/... path, where XXX will be WAR name
(4) Add context listener, so Spring will auto-load xfire-servlet.xml file, see Spring documentation for more detail

Create spring config file (I have named it xfire-servlet.xml) for configuring XFire services. Put it in classpath.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
	<bean id="jaxbServiceFactory" class="org.codehaus.xfire.jaxb2.JaxbServiceFactory" />              (1)
	<import resource="classpath:org/codehaus/xfire/spring/xfire.xml" />                               (2)
	<import resource="classpath:webservices.xml" />                                                   (3)
</beans>

(1) Defines JaxbFactory that will be used by all service exporters
(2) Includes XFire internal (in xfire.jar) spring configuration
(3) Includes our spring configuration file, in which we will define our exporter/implementation class pairs, for each WS we want to build. This is discussed in next paragraph.

Create spring config file (webservice.xml) for instantiation of service implementations and exporters:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
	<bean id="XFireContractFirst" class="org.example.xfirecontractfirst.XfireContractFirstImpl" />	   (1)
	<bean name="XFireContractFirstService" class="org.codehaus.xfire.spring.ServiceBean">              (2)
		<property name="serviceBean" ref="XFireContractFirst" />
		<property name="serviceClass" value="org.example.xfirecontractfirst.XfireContractFirst" /> (3)
		<property name="serviceFactory"><ref bean="jaxbServiceFactory"/></property>                (4)
	</bean>
</beans>

(1) This is instantiation of WS implementation class
(2) This is instantiation of exporter
(3) Which has parameters of implementation bean and service interface
(4) Must use JAXB2 binding in order to have interoperability with .Net clients

In lib folder You should have following jars:
- xfire-all-1.2.4.jar
- xfire-jsr181-api-1.0-M1.jar
- activation.jar
- commons-logging-1.0.4.jar
- mail-1.4.jar
- jdom-1.0.jar
- stax-api-1.0.1.jar
- wsdl4j-1.5.2.jar
- wstx-asl-3.0.1.jar
- log4j-1.2.8.jar
- spring.jar
- XmlSchema-1.1.jar
- jaxb-api-2.0.jar
- jaxb-impl-2.0.1.jar
- jaxb-xjc-2.0.1.jar (only for generation of java classes from WSDL, not needed to be in WAR file, after that)

If you gonna run under Java 1.4, make sure to remove annotations that wsgen have putted in java code generated from WSDL. Also remove xfire-jsr181-api-1.0-M1.jar from classpath.

For creating WAR this ant code fragment could be used:

<war warfile="webservice.war" webxml="webcontent/web.xml">
	<zipfileset dir="lib" prefix="WEB-INF/lib" />
	<zipfileset dir="bin" prefix="WEB-INF/classes"/>
</war>

Adding a new WS

Once you have all this plumbing code set in place, adding a new WS is just a song:

Just create interface and implentation of service
Create implementation and exporter beans in webservices.xml file

Example project

All this can be seen in attached example ws project. Just unpack it, add needed libs (see for list up) from current (version >= 1.2.4) XFire distribution, and run ant which will

create WS implementation classes from WSDL, compile them and generates WAR file. Deploy this file to Application server and test deployed WS.

Exporting WebService - Using XFire with Spring and JSR181 Annotations

2007-02-24T15:44:00.001+02:00

NOT WORKING
This still does not work, look at Codehaus issue, when this is resolved is worth trying again

Project structure and contents

Template project is attached to this page, feel free to use it and update it.

As all Java WS are deployed as WAR file, at some point your project must create one. Here some guidelines how to have a one that works:

<?xml version="1.0" encoding="ISO-8859-1"?>

<web-app xmlns="http://java.sun.com/xml/ns/j2ee"
	xmlns:xsi="http://www.w3.org/2001/XMLSchema-instance"
	xsi:schemaLocation="http://java.sun.com/xml/ns/j2ee/web-app_2_4.xsd"
	version="2.4">

	<display-name>XFire</display-name>

	<context-param>
		<param-name>contextConfigLocation</param-name>                   (1)
		<param-value>classpath:xfire-servlet.xml</param-value>
	</context-param>

	<servlet>
		<servlet-name>XFireServlet</servlet-name>                        (2)
		<display-name>XFire Servlet</display-name>
		<servlet-class>
			org.codehaus.xfire.spring.XFireSpringServlet
		</servlet-class>
	</servlet>

	<servlet-mapping>
		<servlet-name>XFireServlet</servlet-name>                        (3)
		<url-pattern>/servlet/XFireServlet/*</url-pattern>
	</servlet-mapping>

	<servlet-mapping>
		<servlet-name>XFireServlet</servlet-name>
		<url-pattern>/services/*</url-pattern>
	</servlet-mapping>

	<listener>
		<listener-class>
			org.springframework.web.context.ContextLoaderListener    (4)
		</listener-class>
	</listener>

</web-app>

(1) Defines that file xfire-servlet.xml, will be automatically available to Spring. Will define this in next section.
(2) Define XFireServlet
(3) Map it to XXX/services/... path, where XXX will be WAR name
(4) Add context listener, so Spring will auto-load xfire-servlet.xml file, see Spring documentation for more detail

Create Spring file (I have named it xfire-servlet.xml) for configuring XFire services. Put it in classpath.

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>

	<bean id="webAnnotations"
		class="org.codehaus.xfire.annotations.jsr181.Jsr181WebAnnotations" />        (1)
	<bean id="handlerMapping"
		class="org.codehaus.xfire.spring.remoting.Jsr181HandlerMapping">             (2)
		<property name="typeMappingRegistry">
			<ref bean="typeMappingRegistry" />
		</property>
		<property name="xfire">
			<ref bean="xfire" />
		</property>
		<property name="webAnnotations">
			<ref bean="webAnnotations" />
		</property>
	</bean>

	<bean
		class="org.springframework.web.servlet.handler.SimpleUrlHandlerMapping">
		<property name="urlMap">
			<map>
				<entry key="/">
					<ref bean="handlerMapping" />
				</entry>
			</map>
		</property>
	</bean>

	<bean id="typeMappingRegistry"
		class="org.codehaus.xfire.jaxb2.JaxbTypeRegistry"                            (3)
		init-method="createDefaultMappings" singleton="true">
	</bean>


	<import resource="classpath:org/codehaus/xfire/spring/xfire.xml" />                  (4)
	<import resource="classpath:webservices.xml" />                                      (5)
</beans>

(1) Defines usage JSR 181 Anotations
(2) Defines same for mapping
(3) Defines usage of JAXB2. This is very important. Without it XFire will use AEGIS binding, which gives unpleasant effects of creating non-existent namespaces for schema element with unbounded type in WSDL
(4) Includes xfire.xml spring configuration file residing in xfire-all.jar
(5) Includes our own spring configuration file which defines all beans that will be exposed as service. The same will be done for every bean instantiated by Spring, that is JSR 181 anotated, so this file is not strictly needed, but is good to group all WS implementation beans instantiations in same configuration file. This is discussed in next paragraph.

Create spring config file (webservice.xml) for instantiation of service implementations and exporters:

<?xml version="1.0" encoding="UTF-8"?>
<!DOCTYPE beans PUBLIC "-//SPRING//DTD BEAN//EN" "http://www.springframework.org/dtd/spring-beans.dtd">
<beans>
        <bean id="XfireContractFirst" class="org.example.xfirecontractfirst.XfireContractFirstImpl" /> (1)
</beans>

(1) This is instantiation of WS implementation class, which must have JSR-181 Annotations in it.

In lib folder You should have following jars:
- xfire-all-1.2.2.jar
- xfire-jsr181-api-1.0-M1.jar
- activation.jar
- commons-logging-1.0.4.jar
- mailapi_1_3_1.jar
- jdom-1.0.jar
- stax-api-1.0.1.jar
- wsdl4j-1.5.1.jar
- wstx-lgpl-3.0.2.jar
- log4j-1.2.8.jar
- spring.jar
Make sure that server runs Java 5, because of use of annotations

For creating WAR this ant code fragment could be used:

<war warfile="webservice.war" webxml="webcontent/web.xml">
	<zipfileset dir="lib" prefix="WEB-INF/lib" />
	<zipfileset dir="bin" prefix="WEB-INF/classes"/>
</war>

Adding a new WS

Once you have all this plumbing code set in place, adding a new WS is just a song:

Just create interface and implentation of service
Annotate them with JSR-181 annotations
And add a line in webservices.xml file

It's simple as that

Example project

All this can be seen in attached example ws project. Just unpack it, add needed libs (see for list up) from current (version >= 1.2.4) XFire distribution, and run ant which will create WS implementation classes from WSDL, compile them and generates WAR file. Deploy this file to Application server and test deployed WS.