<build>
        <plugins>
            <plugin>
                <groupId>org.apache.felix</groupId>
                <artifactId>maven-bundle-plugin</artifactId>

                <configuration>
                    <instructions>
                        <Bundle-Version>${tuscany.version}</Bundle-Version>
                        <Bundle-SymbolicName>org.apache.tuscany.sca.binding.atom</Bundle-SymbolicName>
                        <Bundle-Description>${pom.name}</Bundle-Description>
                        <Export-Package>org.apache.tuscany.sca.binding.atom*</Export-Package>
                        <Import-Package>org.apache.tuscany.sca.assembly.xml;version="2.0.0", *</Import-Package>
                    </instructions>
                </configuration>
            </plugin>
        </plugins>
    </build>

mvn org.apache.felix:maven-bundle-plugin:manifest

<module-root>/META_INF/manifest.mf

git add META-INF
or
svn add META-INF

public interface AtomCBinding extends Binding {
   QName TYPE = new QName(SCA11_TUSCANY_NS, "binding.atom");
   ...
}

public class AtomBindingImpl implements AtomBinding {
   private String name;
   private String uri;

   public QName getType() {
	return TYPE;
   }

    ...
}

public interface BindingProviderFactory<M extends Binding> extends ProviderFactory<M> {

    /**
     * Creates a new reference binding provider for the given endpoint reference
     *
     * @param endpointReference defines the component/reference/binding against which to create the provider
     * @return The binding provider
     */
    ReferenceBindingProvider createReferenceBindingProvider(EndpointReference endpointReference);

    /**
     * Creates a new service binding provider for the given component and
     * service.
     *
     * @param endpoint defines the component/service/binding against which to create the provider
     * @return The binding provider
     */
    ServiceBindingProvider createServiceBindingProvider(Endpoint endpoint);

}

FactoryExtensionPoint modelFactories = extensionPoints.getExtensionPoint(FactoryExtensionPoint.class);

public class AtomReferenceBindingProvider implements ReferenceBindingProvider {

    private RuntimeComponentReference reference;
    private AtomBinding binding;

    public AtomReferenceBindingProvider(EndpointReference endpointReference,
                                        AtomBinding binding) {

    	this.reference = (RuntimeComponentReference) endpointReference.getReference();
        this.binding = (AtomBinding) endpointReference.getBinding();
    }

    ...
}

public class AtomServiceBindingProvider implements ServiceBindingProvider {


    private MessageFactory messageFactory;

    private Endpoint endpoint;
    private RuntimeComponent component;
    private RuntimeComponentService service;
    private InterfaceContract serviceContract;
    private AtomBinding binding;
    private ServletHost servletHost;

    ...

    public AtomServiceBindingProvider(Endpoint endpoint,
                                         MessageFactory messageFactory,
                                         ServletHost servletHost) {
        this.endpoint = endpoint;
        this.component = (RuntimeComponent)endpoint.getComponent();
        this.service = (RuntimeComponentService)endpoint.getService();
        this.binding = (AtomBinding) endpoint.getBinding();
        this.messageFactory = messageFactory;
        this.servletHost = servletHost;

    }

    ....

...

public class AtomTestCase {

	private SCADomain domain;

	@Before
	public void setUp() throws Exception {
		domain = SCADomain.newInstance("AtomBinding.composite");
	}

	@After
	public void tearDown() throws Exception {
		domain.close();
	}

        ....
}

public class AtomTestCase {

	private static Node node;

	@BeforeClass
	public static void setUp() throws Exception {
	    try {
                // use the contribution helper to find the location of the contribution directory
                // based on a class that is know to be in the contribution
    		String contribution = ContributionLocationHelper.getContributionLocation(AtomTestCase.class);

                // create a note to load the contribution and run the named composite
    		node = NodeFactory.newInstance().createNode("AtomBinding.composite", new Contribution("test", contribution));

                // as an alternative to using the helper you can of course specify the location of the
                // contribution directly, for example,
                //
                // node = NodeFactory.newInstance().createNode(new Contribution("test",
                //                                             "my/directory/structure/atom-contribution.zip"));
                //
                // Note also that no composite is named here. It is assumed that the contribution
                // specifies a deployable composite in the sca-contribution.xml file

                // start the node to make SCA services available
    		node.start();
    	    } catch (Exception e) {
    		e.printStackTrace();
    	    }
	}

	@AfterClass
	public static void tearDown() throws Exception {
	    node.stop();
    	    node.destroy();
	}

        ...
}

        <dependency>
            <groupId>org.apache.tuscany.sca</groupId>
            <artifactId>tuscany-node-impl</artifactId>
            <version>2.0-SNAPSHOT</version>
            <scope>test</scope>
        </dependency>