{toc}

h1. *Adding Core Services*

If you want to add your own services, the best way to follow is to create your own 'kernel' which is extending the DSB kernel. Since we are using the Fractal component model in Petals ESB/DSB, you must also use it for your service.

To illustrate this chapter, let's add a simple and powerful service : The HelloWorld Service\!

{info}The source code for this illustration is available under the DSB samples folder in SVN at [https://svn.petalslink.com/svnroot/trunk/research/commons/dsb/samples]{info}
We assume that you are Maven-aware so we do not explain all the commands here... 

h2. Create a new kernel

Create a new project :

{code}
mvn archetype:generate
{code}
and choose groupId:org.petalslink.dsb.sample.custom, artifactId:custom-kernel, version:1.0-SNAPSHOT

Use the dsb-kernel as dependency in your new project POM:

{code:language=xml|linenumbers=true|theme=Confluence} <dependency>
<groupId>org.petalslink.dsb</groupId>
<artifactId>dsb-kernel</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>{code}

h2. Create the interface

Let's create a new project for the API definition of your service:

{code}
mvn archetype:generate
{code}

and choose groupId:org.petalslink.dsb.sample.custom, artifactId:custom-api, version:1.0-SNAPSHOT

Let's create a simple interface for our Hello service, HelloService.java:

{code:language=java|linenumbers=true|theme=Confluence}
package org.petalslink.dsb.sample.custom.api;

/**
* @author chamerling
*
*/
public interface HelloService {

String sayHello(String input);

}
{code}

h2. Implement your service

Let's go back to our kernel and add the API as dependency:
{code:language=xml|linenumbers=true|theme=Confluence}
<groupId>org.petalslink.dsb.sample.custom</groupId>
<artifactId>custom-api</artifactId>
<version>1.0-SNAPSHOT</version>
{code}

Now, let's implement the Hello service, create the HelloServiceImpl in the org.petalslink.dsb.sample.custom.kernel package :
{code:language=java|linenumbers=true|theme=Confluence}
package org.petalslink.dsb.sample.custom.kernel;

import org.petalslink.dsb.sample.custom.api.HelloService;

/**
* @author chamerling
*
*/
public class HelloServiceImpl implements HelloService {

@Override
public String sayHello(String input) {
return "Hello : " + input;
}

}
{code}

Is it enough? No... Since we use a component framework, we need to add component related configuration and dependencies in our kernel project. Let's add the required Fractal annotations and methods in the service implementation, the updated implementation looks like :

{code:language=java|linenumbers=true|theme=Confluence}
/**
*
*/
package org.petalslink.dsb.sample.custom.kernel;

import org.objectweb.fractal.fraclet.annotation.annotations.FractalComponent;
import org.objectweb.fractal.fraclet.annotation.annotations.Interface;
import org.objectweb.fractal.fraclet.annotation.annotations.LifeCycle;
import org.objectweb.fractal.fraclet.annotation.annotations.Monolog;
import org.objectweb.fractal.fraclet.annotation.annotations.Provides;
import org.objectweb.fractal.fraclet.annotation.annotations.type.LifeCycleType;
import org.objectweb.util.monolog.api.Logger;
import org.ow2.petals.util.LoggingUtil;
import org.petalslink.dsb.sample.custom.api.HelloService;

/**
* @author chamerling
*
*/
@FractalComponent
@Provides(interfaces = { @Interface(name = "service", signature = HelloService.class) })
public class HelloServiceImpl implements HelloService {

@Monolog(name = "logger")
private Logger logger;

private LoggingUtil log;

@LifeCycle(on = LifeCycleType.START)
protected void start() {
this.log = new LoggingUtil(this.logger);
}

@LifeCycle(on = LifeCycleType.STOP)
protected void stop() {

}

@Override
public String sayHello(String input) {
return "Hello : " + input;
}
}

{code}

Is it enough? Almost... Let's say to Maven he has to do some extra steps at compilation time:
{code:language=xml|linenumbers=true|theme=Confluence}
<plugin>
<groupId>net.sf.alchim</groupId>
<artifactId>spoon-maven-plugin</artifactId>
<version>0.7.1</version>
<executions>
<execution>
<goals>
<goal>recompile</goal>
<goal>test-recompile</goal>
</goals>
</execution>
</executions>
<dependencies>
<dependency>
<groupId>log4j</groupId>
<artifactId>log4j</artifactId>
<version>1.2.9</version>
</dependency>
<dependency>
<groupId>org.objectweb.monolog</groupId>
<artifactId>monolog</artifactId>
<version>1.8</version>
</dependency>
</dependencies>
</plugin>
{code}


And add the spoon.cfg.xml at the root level of the custom-kernel project with this content :
{code:language=xml|linenumbers=true|theme=Confluence}
<?xml version="1.0" encoding="UTF-8"?>
<spoon>
<spoonlet artifactId="fractal-spoonlet" groupId="org.objectweb.fractal.fraclet.annotation"
version="2.0.2"/>
</spoon>
{code}

h2. Create your custom distribution project

We do not have any other way to create a distribution other that cloning some existing distribution and to customize its configuration files. To be faster, clone the default distribution files from the dsb-distribution project located at [http://svn.petalslink.org/svnroot/trunk/research/commons/dsb/distributions/dsb-distribution/] into a new _custom-distrib_ folder.
Next we need to add our previous modules to the distribution dependencies :
{code:language=xml|linenumbers=true|theme=Confluence}
<dependency>
<groupId>org.petalslink.dsb.sample.custom</groupId>
<artifactId>custom-kernel</artifactId>
<version>1.0-SNAPSHOT</version>
</dependency>
{code}


h2. Add your service to the distribution

Now that we have our service API, implementation and distribution, let's add this service to the software component model. To be simple, let's add it in the top level component described in _custom-distrib/src/main/resources/Petals.fractal_ :

{code:language=xml|linenumbers=true|theme=Confluence}
<component definition="org.petalslink.dsb.custom.kernel.HelloServiceImpl" name="CustomServiceImpl"/>
{code}

This will instantiate our component when the DSB starts

h1. Packaging your distribution

h1. Launching